You should consider XML::Twig, XML::TreeBuilder, XML::LibXML and other among the very many modules in CPAN's XML name space.

XML::Simple seems to generate as many questions here as any other single module and most of the answers recommend a different XML module. XML::Simple is simple for a very small range of tasks that are a good match for its default behavior. After that it tends to become XML::Warty.

It's better to give XML::Simple a few hints so that it creates a datastructure that's consistent and fine to work with.

use strict;
use warnings;
use XML::Simple;

my $xml_raw = <<XML_RAW;
<survey>
...
</survey>
XML_RAW

my $data = XMLin($xml_raw, ForceArray => [qw(river fish)], KeyAttr => 
+[]);

foreach my $Animal (@{$data->{animals}{fish}}) {
    print <<"*END*";
[ Survey information for: $Animal->{name} ]:

Saltwater:$Animal->{saltwater}
Freshwater:$Animal->{freshwater}
Rivers covered in survey:

*END*
    for (@{$Animal->{river}}) {
        print $_, "\n";
    }
    print "\n";
}
[download]

use strict;
use warnings;
use XML::Rules;

my $xml_raw = <<XML_RAW;
<survey>
...
</survey>
XML_RAW

my $parser = XML::Rules->new(
    stripspaces => 7,
    rules => {
        _default => '',
        river => 'content array',
        fish => sub {
            print <<"*END*";
[ Survey information for: $_[1]->{name} ]:

Saltwater:$_[1]->{saltwater}
Freshwater:$_[1]->{freshwater}
Rivers covered in survey:

*END*
            for (@{$_[1]->{river}}) {
                print $_, "\n";
            }
            print "\n";
        },
    }
);
$parser->parse($xml_raw);
[download]

my $parser = XML::Rules->new(
    stripspaces => 7,
    rules => {
        _default => '',
        river => sub {'.river' => "$_[1]->{_content}\n"},
        fish => sub {
            print <<"*END*";
[ Survey information for: $_[1]->{name} ]:

Saltwater:$_[1]->{saltwater}
Freshwater:$_[1]->{freshwater}
Rivers covered in survey:

$_[1]->{river}
*END*
        },
    }
);
$parser->parse($xml_raw);
[download]

And you should probably consider using XML::XSLT because XSLT is the specific language created to handle XML. It's a language only a mother could love, but it's designed for the purpose. Not that perl isn't a perfectly good tool for this job, but XSLT is a tool designed to do nothing else but this job.

I guess he means XML documents with a flexible structure. E.g. a value is missing, there is one value or there are several values. I agree that XML::Simple is only good for simple stuff - expescially the stability gets pretty bad when the structure is very flexible and not static.

At one point or another you are going to need to know the structure of the XML you are going to work with anyway. The fact that DOM or some other maze-of-objects-based XML parser let's you get away with assuming a single occurance of some tag even though it may be repeated, while XML::Simple would cause your script to bomb out, is not always a good thing. I'd rather if my stuff failed noisily than if it'd produce incorrect results.

You can of course split the XML processing into two, completely unrelated phases. First, that knows nothing whatsoever about what the structure of the XML is and what data are you after and just blindly parses (well, it's not much more then lexing actually this way) the file into some kind of data/object structure. And second that does know where are the data you wanted and has to navigate the structure to get them. In my humble opinion this is often unnecessarily hard and inefficient.

Jenda


Support Denmark! Defend the free world!