my @list (field1, field2);
my @subList (subField1, subField2, subField3, subField4);
[download]

What are those lines doing? For me they don't even compile. Is this some pseudocode notation I should be privy to?

Yes this is pseudo code. The data stream that feeds the tree is proprietary.

The lines you've highlighted are used to control the outer and inner loops. The list elements are also used to identify the nodes in the structs.

So basically it will look something like this:



self =>
  Field1 => {
    subField1 => 'thingy1'
    subField2 => 'thingy2'
    subField3 => 'thingy3'
    subField4 => 'thingy4'
  }
  Field2 => {
    subField1 => 'thingy1'
    subField2 => 'thingy2'
    subField3 => 'thingy3'
    subField4 => 'thingy4'
  }
}
[download]

I can get this to work when I don't have subfields, but the XML is more granular for the module I'm now building.

When you use the Data::Dumper module, does your overall structure look like you think it should? For example, do you get the expected output when you say:

print Dumper $tree;
[download]




Dave

While you're fixing up spelling mistakes, "struckt subField"? "struck Field"?

Have you considered verifying whether $tree->{level1}->{level2}->{$item} and $tree->{level1}->{level2}->{$item}->{subItem} exist, before accessing them?

If $self is a reference to a hash, what is $self->$item, $self->$item->$subItem? A subroutine, I guess, since it's invoked and passed $tree->{level1}->{level2}->{$item}->{subItem}.

Definetly dumped the $tree once I started having problems.

I'm also using 'use strict', so spelling isn't an issue with the code.

I copied/pasted the tree output into the source in case I had mis-spelled a field name or list item.

I've exashed my O'Reilly cookbook for every example that I could canibalize, plus what I could find off CPAN examples.

I've scrubed the code and I can send it to you to pour over. It's not very big, just over 100 lines, mostly for clarity.

Sorry I didn't awnser the other half of your question.

$self is a ref to the Field structure. $self->$item is a ref to one of the keys in Field, dependant on the looping. $self->$item->$subItem is a ref to one of the keys in SubField for Field, again depending on the iteration of the loops.

This is a ref to the value in the tree at $subItem for $item for Level2 for Level1.

$tree->{Level1}->{Level2}->{$item}->{$subItem}

This is supose to act as a setter for $self. $self->$item->$subItem ( ) ;

Simply put, you get $subItem from tree and place it into $subItem of $self.

My 1 line answer to anything XML is use XML::Simple

Heres why: you probably have some xml files lying around, these provide good fodder for parsing into data structures, you can DataDump these and see what happens! By simply redirecting the output to a file, you can then go backwards.

Theres a very good chance that XML::Simple will be the only tool you need. If not, it will get you a long way b4 you run out of gas.

to get you started

#!/usr/local/bin/perl -w

use XML::Simple;
use Data::Dumper;
$Data::Dumper::Indent=1;
use Getopt::Std;

getopts('w') or die "bad args";
foreach $file (@ARGV) {
    if ($file =~ /.xml$/) {
	$data = XMLin($file, suppressempty=>1);
	if ($opt_w) {
	    $file =~ s|.*/(.*)\.xml|$1|;
	    open (STDOUT, "> $file.pm");
	}
	print "# xml as data\n", Dumper $data;
    }
    else {
	$data = do $file;
	# print "data: ", Dumper $data;
	if ($opt_w) {
	    $file =~ s|.*/(.*)\.xml|$1|;
	    open (STDOUT, "> $file.xml");
	}
	print "\n", XMLout($data);
    }
}

use XML::Simple;

my $xs   = XML::Simple->new( ForceArray => 1,suppressempty => '' );
my @href = $xs->XMLin(shift);
print Dumper(@href);
[download]

Or simpler

use XML::Simple;

my @href = XMLin(shift, ForceArray => 1, suppressempty => '' );
print Dumper @href;
[download]

and then as a oneliner

perl -MXML::Simple -e'print Dumper XMLin(shift, ForceArray => 1, suppr
+essempty => "" )' foo.xml
[download]

Makeshifts last the longest.