First off, take a look at a module our co-monk japhy wrote: Tie::Autotie. It'll automatically tie deeper hashes also. If you then would assign the values one by one, it would already work:

use Tie::Autotie 'Tie::IxHash';
tie %hash_ref, 'Tie::IxHash';  # yuck, that variable's name!
$hash_ref{MAIN}{ZOP}{Dev} = undef;
$hash_ref{MAIN}{ZOP}{Con} = undef;
... # etc
[download]

You might not like the required syntax — though for reading from a data file, it'd probably work fine. I'm thinking of an alternative to anonymous hashes: tied hash references. I don't know if any module already implements them, but you can build them by hand:

sub ixhash {
     tie my(%hash), 'Tie::IxHash';
     %hash = @_;
     return \%hash;
}
[download]

use Tie::IxHash;
tie %hash_ref, 'Tie::IxHash';

%hash_ref = (
             'MAIN' => ixhash(
                        'ZOP' => 
                            ixhash(
                                'Dev', undef, 
                                'Con', undef, 
                                'Test', undef, 
                                'Exit', undef, 
                                'New', undef ),
                        'AP' => 
                            ixhash(
                                'Dev', undef, 
                                'Con', undef, 
                                'Test', undef, 
                                'Exit', undef, 
                                'New', undef ), 
                        'Exit' => undef,                             
                    )
             );
[download]

update n.b. You don't need to use Tie::Autotie if you use the latter suggestion, make sure to replace every anonymous hash with a call to ixhash(), and never rely on autovivification.

p.s. You can use Tie::Hash::Indexed as a plug-in replacement for Tie::IxHash. The former is written in XS, the latter in Pure Perl, so it should be faster. I haven't run a benchmark, though.

I think your suggestion will perfectly suit my requirement but it seems that Autotie will only for perl version 5.8.3 or more. Unfortunately, I have only 5.6.1 and don't have authorization to update perl version in my system.

Is there a workaround to use this somehow?

Appreciate your help...

$hnr{'MAIN'}        = { %list1 };
$hnr{'MAIN'}{'ZOP'} = { %list2 };
$hnr{'MAIN'}{'AP'}  = { %list2 };
[download]

$hnr{'MAIN'}        = \%list1;
$hnr{'MAIN'}{'ZOP'} = \%list2;
$hnr{'MAIN'}{'AP'}  = \%list3;
[download]

{ %tied } creates a new (unordered) hash with a copy of %tied contents. That's not what you want,

Update: Alternatively, I think tying anon hashes is perfectly fine:

use Data::Dumper qw( Dumper );
use Tie::IxHash  ();

tie my %hnr, 'Tie::IxHash';

%hnr = (
   ZOP  => {},
   AP   => {},
   Exit => undef
);

tie %{$hnr{'MAIN'}{'ZOP'}}, 'Tie::IxHash';
tie %{$hnr{'MAIN'}{'AP'} }, 'Tie::IxHash';

my @zop_and_ap_init = (
   Dev  => undef,
   Con  => undef,
   Test => undef,
   Exit => undef,
   New  => undef,
);

%{$hnr{'MAIN'}{'ZOP'}} = @zop_and_ap_init;
%{$hnr{'MAIN'}{'AP'} } = @zop_and_ap_init;

print Dumper(\%hnr);
[download]

Ok, the question is why do you want to use Tie::IxHash. If you want to build an ordered structure why dont you use something like nested arrays of name=>value pairs.

       $var=[
             'MAIN' => [
                        'ZOP' => 
                                ['Dev', undef, 
                                'Con', undef, 
                                'Test', undef, 
                                'Exit', undef, 
                                'New', undef ],
                        'AP' => 
                                ['Dev', undef, 
                                'Con', undef, 
                                'Test', undef, 
                                'Exit', undef, 
                                'New', undef ], 
                         'Exit' => undef,                             
+  
          
                    ]
             ];
[download]

Unless you have some call to address these things by their names you dont need to use a hash at all. You can iterate over such a structure pretty much as as easily as with a HoH, and preserving the order read ceases to be an issue.

Er, quite, but that is why the OP is using Tie::IxHash which does give a guaranteed order.

/J\