Reversing a hash preserving Duplicate values - perl

Question

My existing hash is
my $volvg = {
'datavol' => 'oradatavg',
'archvol' => 'archvg',
'archvol1' => 'archvg',
'soevol' => 'soevg',
'redovol' => 'oradatavg'
};
I want to reverse the hash in following way
$vgvol = { 'oradatavg' => [
'datavol',
'redovol'
], 'archvg' => [
'archvol',
'archvol1
] 'soevg' => [
'soevol'
] };
Can someone help?

Answer 1

Reversing in-place is probably a bad idea, create a new hash, and then if you need assign it to the old one.
Below is one way to do it:
#!/usr/bin/perl
use strict;
use warnings;
my $volvg = {
'datavol' => 'oradatavg',
'archvol' => 'archvg',
'archvol1' => 'archvg',
'soevol' => 'soevg',
'redovol' => 'oradatavg'
};
my $reversed;
while( my( $k, $v)= each %$volvg)
{ # $reversed->{$v}||=[]; # not needed, see dgw's comment below
push #{$reversed->{$v}}, $k; # push the old key into the array
}
use DDP; p $reversed; # for checking the result
# you can also use Data::Dumper or other modules

Answer 2

What's a little unclear in Perl, is how to embed arrays into hashes. Because pretty fundamentally - you can't. There's no such thing as a hash of arrays.
But what there is, is a hash of array references. You can manipulate an array ref like this:
#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper;
my $array_ref = [ "one", "two" ];
print Dumper \$array_ref;
push ( #$array_ref, "three-ish" );
print Dumper \$array_ref;
my $hash_ref;
$hash_ref->{"carrot"} = $array_ref;
print Dumper \$hash_ref;
push ( #{$hash_ref->{"carrot"}}, "a new value" );
print Dumper \$hash_ref;
So hopefully you can see the basis of what you need for creating the data structure you're looking for. Either extract the values and keys you want, create an array ref and insert them into a hash. Or iterate, and use push.

Answer 3

Inverting a hash is a classic question/recipe from the Perl Cookbook. The solution is trivial when the values being inverted into keys are unique.
%rev_hash = reverse %hash ;
but, as you note, that's not often the case thus the explanations/solutions offered in other answers here are necessary. Once you understand references it's not too hard (++ #Sobrique for making this link).
The Cookbook and other perl resources sometimes recommend tie-ing the hash (e.g. c.f Tie::RefHash) to make working with the references easier.
If you are inverting a hash that itself contains references it can tricky if you have to go deep into the hash. Here's a simple example that should invert a hash that has an array reference as a value.
use DDP;
my $volvg = {
'datavol' => ['oradatavg', 'oradatavgpoo2'] ,
'archvol' => 'archvg',
'archvol1' => 'archvg',
'soevol' => 'soevg',
'redovol' => 'oradatavg' };
while ( ($k,$v) = each(%$volvg) ) {
if (ref $v) {
map { push #{$volvg_rev{$_}}, $k } #$v ;
}
else {
push #{$volvg_rev{$v}}, $k ;
}
}
p $volvg ;
print "----\n";
p %volvg_rev ;
Output:
\ {
archvol "archvg",
archvol1 "archvg",
datavol [
[0] "oradatavg",
[1] "oradatavgpoo2"
],
redovol "oradatavg",
soevol "soevg"
}
----
{
archvg [
[0] "archvol1",
[1] "archvol"
],
oradatavg [
[0] "redovol",
[1] "datavol"
],
oradatavgpoo2 [
[0] "datavol"
],
soevg [
[0] "soevol"
]
}
As an aside, Perl6 has some neat new methods for reverse-ing, inverting and flipping things around.