In the conditional of lines 24-26, and again in 28-30, you're testing for the presence of a hash key, then populating that level as an array. Your Dumper output confirms that the array treatment wins. You don't push onto a hash, you assign. Since you have an array, the hash key never exists and each $policy seen goes into the array, duplicate or not.

Aside from that, I'm unsure what you're asking.

After Compline,
Zaxo

Thanks for your reply! I'm sorry, I wasn't as clear as I could have been

if ( ! exists ( $status{$client}{'policy'}{$policy} )) {
push  @{$status{$client}{'policy'}} , $policy ;
  }
[download]

I'm building a Hash of Hashes of Arrays. In this example, %status is a hash, whose keys are also hashes named $client. Each key "$client" is a hash of arrays. In the above example, there is one key (array) named "policy". "policy" should contain a list of, well, policies.

Ultimately, I'm trying to create something like:

%STATUS {
      Client1,
           Policy,
             [ policy1,
               policy2,
               policy3
             ]
           ID
             [ id1,
               id2,
               id3
             ]

        }
[download]

$id = $1  if $key =~ /^(copy_\d_frag_\d_id)$/;
[download]

For the second question, this is a hash, so you add a key-value pair, rather than push onto an array:

$status{$client}{'tapes'}{$id} = 1;
[download]

Update: corrected a bug in the code.

-Mark

You don't indicate how big your %images hash is likely to be, but if it will be more than a few 10s of entries, doing a linear search each time using grep and a regex to test if the elements you are after exists is going to become time consuming.

If your keys will always have a consistant format (as indicated by your first two) of "copy_n_frag_n_id", then most of that information is redundantly duplicated. The only valuable information are the two numbers. Normally, when tables are index by numbers I would think of an array, or in this case an AoAs, but the test for existance suggests that your data is probably sparse. In this case, using a HoHs, with numeric keys allows you to build a sparse data structure whilst retaining the ability to go straight to the entry of choice avoiding the linear search.

By way of demonstration.

#! perl -slw
use strict;
use Data::Dumper;

my %images;
$images{$1}{$2} = undef while <DATA> =~ m[copy_(\d+)_frag_(\d+)_id];
print Dumper \%images;

for my $copy ( 1 .. 9 ) {
    for my $frag ( 1 .. 9 ) {
        $images{$copy}{$frag} = int rand 100000
            if  exists $images{$copy}
            and exists $images{$copy}{$frag};
    }
}

print Dumper \%images;

__DATA__
copy_1_frag_1_id
copy_1_frag_2_id
copy_1_frag_3_id
copy_1_frag_4_id
copy_1_frag_5_id
copy_1_frag_6_id
copy_1_frag_7_id
copy_1_frag_8_id
copy_1_frag_9_id
copy_2_frag_3_id
copy_2_frag_5_id
copy_2_frag_7_id
copy_2_frag_9_id
[download]

Output