How to create recursive hash of hash ? (With unlimited deep)

Please, I try to create a complexe datastructure. I know how to do

$branch{'level1'}{'level2'}{'level3'}='leaf';

But I don't know how to create

$branch{'level1'}....{'levelN'}='leaf';

I try something like that :

$branch{'leaf'} = "1";
$branchREF = \%branch;
$branchtmp{'level3'} = $branchREF;

So I succefully get :

$VAR1 = 'level3';
$VAR2 = {
          'leaf' => '1'
        };

But for the next step, to do a recrusive N hash of hash, I try :

%branch = %branchtmp;

But the result is completly wrong... %branch is not what I'm expecting. To do my recursivity, I need to reuse my first %branch and not create a new one. How can I do please ?

A.

I strongly recommend using an existing solution such as Data::Diver.

use Data::Diver qw( DiveVal );

my @keys = map "level$_", 1 .. 3;

my $branch = {};
DiveVal($branch, map \$_, @keys) = 'leaf';
  -or-
my %branch;
DiveVal(\%branch, map \$_, @keys) = 'leaf';

Obviously, it can be done without module too.

sub DiveVal :lvalue {
   my $p = \shift;
   $p = \( $$p->{$_} ) for @_;
   $$p
}

my @keys = map "level$_", 1 .. 3;

my $branch;
DiveVal($branch, @keys) = 'leaf';
  -or-
my %branch;
DiveVal(\%branch, @keys) = 'leaf';

How my DiveVal works:

Pre-loop:          $p references $branch
After loop pass 0: $p references $branch->{level1}
After loop pass 1: $p references $branch->{level1}{level2}
After loop pass 2: $p references $branch->{level1}{level2}{level3}
Returned:          $branch->{level1}{level2}{level3}

The extra level of indirection has many benefits.

• It removes the need to treat the last key specially.
• It removes the need to create the hash before it's dereferenced.
• It removes the need for the root to be a reference to a hash. Instead, any scalar can be the root, even an undefined one.
• It makes it easy to extend DiveVal to support mixed array/hash structures.

Data::Diver can help you:

#!/usr/bin/perl
use warnings;
use strict;

use Data::Diver qw{ DiveVal };
use Data::Dumper;

my %branch;
DiveVal(\%branch, map "level$_", 1 .. 3) = 'leave';
print Dumper \%branch;

Output:

$VAR1 = {
          'level1' => {
                        'level2' => {
                                      'level3' => 'leave'
                                    }
                      }
        };

Or, if you want to implement it yourself:

#!/usr/bin/perl
use warnings;
use strict;

use Data::Dumper;

sub set_value {
    my ($struct, @list) = @_;
    if (@list > 2) {
        set_value($struct->{ $list[0] } = {}, @list[ 1 .. $#list ]);
    } else {
        $struct->{ $list[0] } = $list[1];
    }
}


my %branch;
set_value(\%branch, map("level$_", 1 .. 3), 'leave');
print Dumper \%branch;