I was talking previously about your first method which you called "Replicate Entire". The one that was so fast. And as far as I can see not working (except if you don't mind that the copies still all access the same data in the source HoH)

You now showed results from the third method instead where you copy a subhash. Which is basically working correct as there is no problem in copying a simple hash.

Well, I downloaded your code, and I verified your results and I got basically the same thing. I re-ran my code and they "appeared" to be 2 separate hashes. I have never used the "Replicate Entire" method before, and don't think I know enough about it to use it in the future.

I used the third method because that is what I would like to use, but as it stands there is not enough performance improvement to go back into the code and make the changes.

Thank you

"Well done is better than well said." - Benjamin Franklin

Update: Anyway $Account{"0"} is a reference to a hash. The purpose of this is to create a new hash and "take out one level of hash key" which is a reference. $Account{$i}{$key} should be a scalar and likewise $TAccount{$key} should be a scalar - the {$i} keys are "gone". I still think something is a bit weird with the code below, but I think I grok the idea of what is supposed to happen.

print "\nB:Acct:    ",\%Account,"\t",\$Account{"0"},"\t",
       \$Account{"1"},"\t",\$Account{"10"},"\n";
#######      
{   #I'm guessing this is a typo ????
#######
   my %TAccount = (); 
   keys( %TAccount ) = $i;
   foreach my $key ( keys %{ $Account{$i} } )
   {  
       $TAccount{$key} = $Account{$i}{$key}; 
   }
   print "A:TAcct1:  ",\%TAccount,"\t",\$TAccount{"0"},
                     "\t",\$TAccount{"1"},
                     "\t",\$TAccount{"10"},"\n";
    
   print "\nB:Acct:    ",\%Account,"\t",\$Account{"0"},
                       "\t",\$Account{"1"},
                       "\t",\$Account{"10"},"\n";
   {  
       #### this does nothing!!! #####
       #### except hide the previous %TAccount
       my %TAccount = %{ $Account{"$i"} 
   };
   
   print "A:TAcct2:  ",\%TAccount,"\t",\$TAccount{"0"},
         "\t",\$TAccount{"1"},
         "\t",\$TAccount{"10"},"\n";
[download]

Hi Marshall,

The code was a part of an answer to a previous post, and was only the updated part of the program.

Sorry for the confusion.

Thank you

"Well done is better than well said." - Benjamin Franklin

No problem.

This node is confusing enough that I am attempting a kind of "mini-tut" re: cloning - might help somebody sometime. Probably redundant with other stuff, but perhaps with a bit of a different twist.

The reason that the first code benchmark ran so apparently fast was that it didn't actually make a full copy of the structure, it only copied references, essentially just the pointers to the original copies of sub-parts. This is known as a "shallow copy". A "deep copy" is different and is known as a "clone". A "clone" is an exact and independent copy of the original. Once a structure has been cloned, the original can be modified without affecting the clone. If only references are copied (as in a "shallow copy"), then changes to the original will also affect the "copy" because there is still a "connection" between the copy and the original via references.

Perl can make a clone with the "=" operator for any fundamental data type. $A = $B; means that $A is an exact and independent copy of $B, likewise @A = @B;, array A is an exact and now independent copy of B, %A = %B. However, that won't work with more complex data types because references are involved - if I copy a reference, that doesn't copy "the thing" just a "pointer to that thing".

In the code below: I show a structure. I clone it. Then I change the original and then show that the clone didn't change.

In Perl, the easiest "complex" structure to clone is the Array of Array. I show one called amazingly enough "@AoA". This is an array of references to arrays. To "clone" this, I use a map{}. Each reference to an array becomes $_ inside the map{}. Then that array reference is de-referenced via @$_ to become the complete array again. The square brackets mean to allocate new memory for that copy of the array and then a reference is returned for that memory to go to the left side.

I show a couple of lines that change the original and then print statements to show that the clone didn't change. Next up is the HoH, Hash of Hash.

This is more complicated because there isn't any fancy map{} trick that will do the job. But the "formula" is still the same as above. Each key in the HoH represents a reference to another hash. So, $HoH{$key} is a hash reference. That is de-referenced to get the complete hash, then the curly braces cause new memory to be allocated for that "completely copied" hash and a reference to that memory is set to the clone's corresponding hash key. Use curly braces to allocate new anon memory for a hash and use square brackets to allocate new anon memory for an array.

Cloning a particular sub-hash of a HoHoH is actually a bit easier. This can be de-referenced to a simple hash and Perl can copy that into an independent variable.

Maybe this is as clear as mud, but I tried. Code is below.

#!/usr/bin/perl -w
use strict;
use Data::Dumper;

my @AoA = ( [1,2,3],
            [4,5,6],
          );
          
my @cloneAoA = map{[@$_]}@AoA;  

$AoA[0][1]   = 99;
$AoA[1]->[2] = 88;

print Dumper \@AoA;   
print "the cloneAoA is still the same, but AoA changed!\n";
print Dumper \@cloneAoA;
print "-------- now HoH ----------------\n";

my %HoH = ( 'a' => { 'x' => 1,
                     'y' => 2,
                   },
            'b' => { 'xx' => 3,
                     'yy' => 4,
                   },
          );
           
my %cloneHoH;
foreach my $key (keys (%HoH))
{
   $cloneHoH{$key} = { %{$HoH{$key}} };
}

$HoH{'a'}{'x'}  = 88;
$HoH{'b'}{'yy'} = 99;

print Dumper \%HoH;
print "the clone is still the same, although %HoH changed!\n";
print Dumper \%cloneHoH;
print "========= now HoHoH ==============\n";

my %HoHoH  = ('x' => { 'ao' =>  { 'mx' => 1,
                                  'my' => 2,
                                  'mz' => 3,
                                },
                       'ap' =>  { 'nx' => 4,
                                  'ny' => 5,
                                },
                     },
              'y' => { 'bq' =>  { 'bx' => 6,
                                  'by' => 7,
                                },
                     },
             );

#to clone the $HoHoH{'x'}{'ap'} sub-hash...

my %xapClone = %{$HoHoH{'x'}{'ap'}};

$HoHoH{'x'}{'ap'}{'nx'} = 99;
$HoHoH{'x'}{'ap'}{'ny'} = 88;

print Dumper \%HoHoH;
print "the %xapClone still has nx => 4 and ny => 5\n";
print Dumper \%xapClone;

__END__
#output shown below.... in <readmore> section
[download]

Read more... (2 kB)