You've really got to figure out a way of knowing which columns in this CSV file are 'fields' and which are 'titles'. The following snippet assumes you've already figured that part of the problem out. It assumes that you've dumped the CSV row into @columns, and furthermore, that you know that the number of 'fields' is four.

Given that part of the equation being already resolved, here is one way to build up a hash when the number of 'titiles' (number of levels of nested hashes) is unknown. My strategy builds the hash in reverse, starting at the deepest level and working upward. This is the same technique often used to build linked lists in Perl.

use strict;
use warnings;
use Data::Dumper;

my @columns = qw/ title1 title2 title3 title4 
                  field1 field2 field3 field4 /;

my $struct_ref = [ @columns[4..7] ]; # place the 'fields' into an arra
+y ref.

$#columns = 3; # truncate the original CSV row array, @columns.

foreach my $col ( reverse @columns ) {
    $struct_ref = { $col => $struct_ref };
}

print Dumper $struct_ref;
[download]

HTH.

Then, you need to figure out how to differentiate titles from other fields. It isn't apparent from your post, so I cannot help you there.

Finally, populate the hash. A most simple-minded solution would be to create a case structure:

my @titles = ...; 
if (@titles == 1) {
   $BIGLIST{$title[0]} = [ @RESTOFFIELDS ];
}
elsif (@titles == 2) {
   $BIGLIST{$title[0]}{$titles[1]} = [ @RESTOFFIELDS ];
}
...etc.
[download]

my @titles = ...; 
my $ref = \%BIGLIST;
while (@titles > 1) {
   my $title = shift @titles;
   $ref = \($ref->{$title});
}
$ref->{$title[0]} =  [ @RESTOFFIELDS ];
[download]

As far as becoming familiar with hash (and other) references, see perldoc perlreftut.

But lets say that you REALLY want a tree structure for this kind of thing:

sub add_line {
   my ($tree,@line) = @_;
   my $first_element = shift @line;
   if (is_a_folder_title($first_element)) { # TODO: implement is_a_fol
+der_title()
     $tree->{$first_element} ||= {}; # create empty hashref if none ex
+ists, yet
     add_line($tree->{$first_element},@line);
   }
   else {
     $tree = [ $first_element, @line ];
   }
}
[download]

To get the values out again:

sub get_elements {
   my ($tree,@folder_names) = @_;
   return $tree unless @folder_names;
   my $subtree  = $tree->{shift(@folder_names)};
   return get_elements($subtree,@folder_names);
}
[download]

$directories{ join("/",@folder_names } = \@fields;

my @fields = @{ $directory{ join("/",@folder_names) } };
[download]

The first question to answer is how do you know the difference between a title and a field?

I wish I could claim that I came up with the "build it in reverse" technique myself. I saw it first in a great book published by O'Reilly & Associates, "Mastering Algorithms with Perl". The book discusses (among many other topics) building linked lists, and one method is surprisingly similar to the solution I provided to your problem. Your situation was a little different, but being familiar with the Algorithms book provided me with the basic concept. I highly recommend the book.

You can also learn a great deal about complex datastructures and Perl's references from the following POD's:

• perlreftut - Tutorial on references.
• perllol - Tutorial on building and manipulating lists of lists, and other similar datastructures using references.
• perldsc - Perl Datastructure Cookbook... good stuff.
• perlref - Of course, the definitive source.

Happy hunting...




Dave

The core loop to do something like this is actually pretty simple. Let's say you have an array of level names, a target value and hash to start from:

#! /usr/bin/perl -w
# Set up some stuff for this example
use strict;
use Data::Dumper;
my %hash;
my @levels = qw(a b c);
my $value = 5;

# The next three lines are the essence:
my $work = \\%hash;
$work = \$$work->{$_} for @levels;
$$work = $value;

# Show that it worked
print Dumper(\%hash);
[download]

If the number of levels can be 0, the top level assign can be a scalar one, so you'd need to start with a scalar instead of a hash:

my $hash;

my $work = \$hash;
$work = \$$work->{$_} for @levels;
$$work = $value;
[download]

The advantage of this forward walking way of doing things is that you can apply it several times to put multiple level/value sets in there (as long as you take care that a value doesn't block a subtree)

However, if there is some character that cannot appear in the titles, it's probably easier to just join all titles using that character as separator and use that as hash key. You can use split if you need to split up such a key into titles again. This leads to a much easier to use and understand datastructure (if there is no such character, you can still get this idea working with some form of escaping or counted packs, but it gets a bit trickier and maybe not worth it anymore), e.g.:

$hash{join(",", @levels)} = $value;
[download]