I've been in your exact same position before. Here's a snippet which may save you some hair-pulling:

#!/usr/bin/perl -w
use strict;
use Data::Dumper;
my $s = {
     foo =>'bar',
     baz => {
         troz  => 'zort',
         blort => {
               poit => 'qux',
              }
        }
    };

print Dumper $s;
# This works in 5.6.1 and later
set($s, qw/baz blort poit/) = "Whee!";
set($s, qw/baz troz/) = "Joy!";
# In 5.6.0 (and earlier) you have to:
# set($s, qw/baz blort/)->{poit} = "Whee!";
# set($s, qw/baz/)->{troz} = "Joy!";
print Dumper $s;

sub set : lvalue {
  @_ == 1 ? $_[0] : set($_[0]{$_[1]},@_[2..$#_]);
}
[download]

perl -pe '"I lo*`+$^X$\"$]!$/"=~m%(.*)%s;$_=$1;y^`+*^e v^#$&V"+@( NO CARRIER'

It's not clear to me what you are trying to do. After you have traversed the hash refs as you have shown and $nodule has the hash ref of $structure->{stuff}{hierarchy}{album}, then changing $nodule->{$target} will have the effect of changing $structure->{stuff}{hierarchy}{album}{$target}.

Some more code or context would be useful.

YuckFoo

Update: Some code to traverse a list of hash keys and change the last one. HTH.

#!/usr/bin/perl

   use strict;

   my ($hash);

   $hash->{one}{two}{three} = 'before';
   print "$hash->{one}{two}{three}\n";

   changehash($hash, [qw(one two three)], 'after');
   print "$hash->{one}{two}{three}\n";

#-----------------------------------------------------------
sub changehash {

   my ($node, $keys, $val) = @_;
   my $key;

   my $last = pop(@{$keys});

   for $key (@{$keys}) {
      if (defined ($node->{$key})) {
         $node = $node->{$key};
      }
      else {
         print STDERR "Unknown key: $key\n";
         return;
      }
   }

   if (defined ($node->{$last})) {
      $node->{$last} = $val
   }
   else {
      print STDERR "Unknown key: $last\n";
      return;
   }
}
[download]

Hey YuckFoo. Ready for context? Here goes...

I'm getting a hashref from a DB_File, and unfreezing the data structure contained within with Storable. Then I traverse a user-defined path in the hashref and set a key in it, and it'll eventually get frozen back to the DB_File. An added complication (one that I should have mentioned, with hindsight :() is that if the full path doesn't exist, I have to create all the hashrefs leading up to the end - whilst still preserving everything that was in the original data structure. Here's a literal chunk of code from what I have.

    # the first element of $path is always a key in the DB_File
    my ($root, $tip) = (shift(@path), pop(@path));
    
    # get old tree
    my $old = thaw($db{$root});
    
    # start off at the root
    $nodule = $old;
    
    while (my $next_key = shift @path) {
        unless (exists $nodule->{$next_key}) {
            $nodule->{$next_key} = {};    
        }
        $nodule = $nodule->{$next_key};
    }
    
    $nodule->{$tip} = $content;
    print Dumper($old);
[download]

The thing is, when I print $old with Data::Dumper, I would expect it to be a structure looking like this (given that @path = ('foo', 'bar'), $tip = 'baz' and $content = 'some arbitrary data'):

$VAR1 = {foo =>
        {bar =>
            {baz => 'some arbitrary data'}
        }
    };
[download]

Instead it looks like:

$VAR1 = undef;

So that's what I want to achieve, and the example I gave in the question seems to be lose context in this environment, when by all rights it should work. Damn real life.



--
my one true love

Amoe,

Thanks, problem well stated. Unfortunately I couldn't reproduce the problem. I think you are not getting what you expect in $old when thawing. Try print Dumper($old) immediately after thawing.

YuckFoo

use strict;
use warnings;

my $structure = {
    stuff => { 


        hierarchy => { 
            album => { 
                bar => 'the right one',
               },
        },  
    },
};

my $path = [ 'stuff', 'hierarchy', 'album' , 'bar' ];

print get_structure_value($structure,$path) , "\n";
$structure = return_new_structure($structure,$path,'new value');
print get_structure_value($structure,$path) , "\n";

sub make_eval {
    my ($path) = shift;
    my $string = "\$hashref->";
    $string .= "{$_}" for @$path;
    return $string;
}

sub get_structure_value {
    my ($hashref,$path) = @_;
    my $string = &make_eval($path);
    return eval($string);
}

sub return_new_structure {
    my ($hashref,$path,$set) = @_;
    my $string = &make_eval($path); 
    eval("$string = '$set'");
    return $hashref;
}
[download]

sub make_eval { 
    my ($path) = shift; 
    my $string = "\$hashref->"; 
    $string .= "{$_}" for @$path; 
    return $string; 
}
[download]

Dangerous and broken when $_ contains anything unusual, and slower than hell unneccessarily even when it doesn't. Please don't use this code for anything.

-- Randal L. Schwartz, Perl hacker

You gotta love eval :0)

my $path = [ 'stuff', 'hierarchy', 'album', 'Oops}=do{warn"JaPh!"}# <-
+ run any arbitrary code' ];
[download]

cheers

tachyon

s&&rsenoyhcatreve&&&s&n.+t&"$'$`$\"$\&"&ee&&y&srve&&d&&print