Congratulations! You've completed the first level! Are you ready to play level two? XML::LibXML.

You appear to have outgrown the facilities that XML::Simple offers. You may wish to read Stepping up from XML::Simple to XML::LibXML.

use 5.010;
use XML::LibXML 1.94;

my $xml = XML::LibXML->load_xml(IO =>\*DATA);

foreach my $element ($xml->findnodes("/a/*"))
{
    say "Got ", $element->tagName;
    if ($element->tagName eq 'b')
    {
        say "  type is ", $element->{type};
    }
}

__DATA__
<a>
    <b type="1"/>
    <b type="2"/>
    <c/>
    <b type="3"/>
</a>
[download]

Output is...

Got b
  type is 1
Got b
  type is 2
Got c
Got b
  type is 3

Thanks for the reply! I've taken the time between posting and your response to dive much deeper into XML than I have before. What I think I want can be accomplished with XPath. I believe your solution does something similar.

Here's what I came up with so far. Please chime in on my approach. First, though, I have to clarify that my original XML file example was not 100% representative of my structure. It looks more like this

<a>
    <b id='id1' type="1"/>
    <b id='id2' type="1.5"/>
    <b id='id3' type="2"/>
    <c id='id4'/>
    <b id='id5' type="3"/>
</a>
[download]

Then, I can use XML::XPath to get what I want using the following

use warnings;
use strict;
use XML::XPath;
use XML::XPath::XMLParser;

my $xmlFile = "try.xml";

# create an object to parse the file and field XPath queries
my $xpath = XML::XPath->new(filename => $xmlFile) || die "Problem: $!\
+n";

# look for the preceding sibling node to the one in question
my $nodeset = $xpath->find('//*[@id=' . "'id4']/preceding-sibling::*[1
+]");
foreach my $node ( $nodeset->get_nodelist ) {
    print XML::XPath::XMLParser::as_string( $node ) . "\n";
}
[download]

According to the "My element order is getting jumbled up" section of XML::Simple::FAQ, the short answer is no. (see excerpt below)

If your application really is sensitive to element order, don't use XML::Simple (and don't put order-sensitive values in attributes).

Since XML::Simple is the only XML parsing module that I personally have used so far, I really can't suggest an alternative.

XML::Rules, its XML::Simple on steriods, if you need array-o-hash type structures

#!/usr/bin/perl --
use strict; use warnings;
use XML::Rules;
use Data::Dump qw/ dd /;

my $ta = XML::Rules->new(
    qw/ stripspaces 8 /,
    rules => [
        _default => 'raw',
    ],
);

my $da = XML::Rules->new(
    qw/ stripspaces 8 /,
    rules => [
        a        => 'content',
        _default => 'raw',
    ],
);

dd $ta->parse(  q(<a><b type="1"/><b type="2"/><c/><b type="3"/></a>) 
+);
dd $da->parse(  q(<a><b type="1"/><b type="2"/><c/><b type="3"/></a>) 
+);
dd $da->parse(  q(<a><b type="1"/><b type="2"/><c/><b type="3">tada</b
+></a>) );
__END__
[
  "a",
  {
    _content => [
      ["b", { type => 1 }],
      ["b", { type => 2 }],
      ["c", {}],
      ["b", { type => 3 }],
    ],
  },
]
{
  a => [
         ["b", { type => 1 }],
         ["b", { type => 2 }],
         ["c", {}],
         ["b", { type => 3 }],
       ],
}
{
  a => [
         ["b", { type => 1 }],
         ["b", { type => 2 }],
         ["c", {}],
         ["b", { _content => "tada", type => 3 }],
       ],
}
[download]

And xsh is a step further

$ xsh -q
$scratch/> open pm981718.xml
/> ls /
<?xml version="1.0"?>
<a>
  <b type="1"/>
  <b type="2"/>
  <c/>
  <b type="3">tada</b>
</a>

/> for /a/* { pwd }
/a/b[1]
/a/b[2]
/a/c
/a/b[3]
/> for /a/* { pwd; print @type; }
/a/b[1]
1
/a/b[2]
2
/a/c

/a/b[3]
3
/> for /a/* { pwd; for(@*){ echo xsh:path(.) " = " xsh:current(); }; }
+;
/a/b[1]
/a/b[1]/@type  =  1
/a/b[2]
/a/b[2]/@type  =  2
/a/c
/a/b[3]
/a/b[3]/@type  =  3
/>
/> quit
saving .../.xsh2_history
done
[download]