/ 
XML-Compile-0.13
River stage two • 39 direct dependents • 66 total dependents
/ XML::Compile::Schema::XmlReader

NAME

XML::Compile::Schema::XmlReader - bricks to translate XML to HASH

SYNOPSIS

my $schema = XML::Compile::Schema->new(...);
my $code   = $schema->compile(READER => ...);

DESCRIPTION

The translator understands schema's, but does not encode that into actions. This module implements those actions to translate from XML into a (nested) Perl HASH structure.

DETAILS

Processing Wildcards

If you want to collect information from the XML structure, which is permitted by any and anyAttribute specifications in the schema, you have to implement that yourself. The problem is XML::Compile has less knowledge than you about the possible data.

anyAttribute

By default, the anyAttribute specification is ignored. When TAKE_ALL is given, all attributes which are fulfilling the name-space requirement added to the returned data-structure. As key, the absolute element name will be used, with as value the related unparsed XML element.

In the current implementation, if an explicit attribute is also covered by the name-spaces permitted by the anyAttribute definition, then it will also appear in that list (and hence the handler will be called as well).

Use XML::Compile::Schema::compile(anyAttribute) to write your own handler, to influence the behavior. The handler will be called for each attribute, and you must return list of pairs of derived information. When the returned is empty, the attribute data is lost. The value may be a complex structure.

Example: anyAttribute in XmlReader

Say your schema looks like this:

<schema targetNamespace="http://mine"
   xmlns:me="http://mine" ...>
  <element name="el">
    <complexType>
      <attribute name="a" type="xs:int" />
      <anyAttribute namespace="##targetNamespace"
         processContents="lax">
    </complexType>
  </element>
  <simpleType name="non-empty">
    <restriction base="xs:NCName" />
  </simpleType>
</schema>

Then, in an application, you write:

my $r = $schema->compile(READER => '{http://mine}el'
 , anyAttribute => 'ALL'
 );

my $h = $r->( <<'__XML' );
  <el xmlns:me="http://mine">
    <a>42</a>
    <b type="me:non-empty">
       everything
    </b>
  </el>
__XML

use Data::Dumper 'Dumper';
print Dumper $h;
__XML__

The output is something like

$VAR1 =
 { a => 42
 , '{http://mine}a' => ... # XML::LibXML::Node with <a>42</a>
 , '{http://mine}b' => ... # XML::LibXML::Node with <b>everything</b>
 };

You can improve the reader with a callback. When you know that the extra attribute is always of type non-empty, then you can do

my $read = $schema->compile
 ( READER => '{http://mine}el'
 , anyAttribute => \&filter
 );

my $anyAttRead = $schema->compile
 ( READER => '{http://mine}non-empty'
 );

sub filter($$$$)
{   my ($fqn, $xml, $path, $translator) = @_;
    return () if $fqn ne '{http://mine}b';
    (b => $anyAttRead->($xml));
}

my $h = $r->( see above );
print Dumper $h;

Which will result in

$VAR1 =
 { a => 42
 , b => 'everything'
 };

The filter will be called twice, but return nothing in the first case. You can implement any kind of complex processing in the filter.

any element

By default, the any definition in a schema will ignore all elements from the container which are not used.

SEE ALSO

This module is part of XML-Compile distribution version 0.13, built on January 29, 2007. Website: http://perl.overmeer.net/xml-compile/

LICENSE

Copyrights 2006-2007 by Mark Overmeer.For other contributors see ChangeLog.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See http://www.perl.com/perl/misc/Artistic.html