NAME

       XML::XPath - a set of modules for parsing and evaluating XPath statements

DESCRIPTION

       This module aims to comply exactly to the XPath specification at
       http://www.w3.org/TR/xpath and yet allow extensions to be added in the form of functions.
       Modules such as XSLT and XPointer may need to do this as they support functionality beyond
       XPath.

SYNOPSIS

           use XML::XPath;
           use XML::XPath::XMLParser;

           my $xp = XML::XPath->new(filename => 'test.xhtml');

           my $nodeset = $xp->find('/html/body/p'); # find all paragraphs

           foreach my $node ($nodeset->get_nodelist) {
               print "FOUND\n\n",
                   XML::XPath::XMLParser::as_string($node),
                   "\n\n";
           }

DETAILS

       There's an awful lot to all of this, so bear with it - if you stick it out it should be
       worth it. Please get a good understanding of XPath by reading the spec before asking me
       questions. All of the classes and parts herein are named to be synonimous with the names
       in the specification, so consult that if you don't understand why I'm doing something in
       the code.

API

       The API of XML::XPath itself is extremely simple to allow you to get going almost
       immediately. The deeper API's are more complex, but you shouldn't have to touch most of
       that.

   new()
       This constructor follows the often seen named parameter method call.  Parameters you can
       use are: filename, parser, xml, ioref and context.  The filename parameter specifies an
       XML file to parse. The xml parameter specifies a string to parse, and the ioref parameter
       specifies an ioref to parse. The context option allows you to specify a context node. The
       context node has to be in the format of a node as specified in XML::XPath::XMLParser. The
       4 parameters filename, xml, ioref and context are mutually exclusive - you should only
       specify one (if you specify anything other than context, the context node is the root of
       your document).  The parser option allows you to pass in an already prepared XML::Parser
       object, to save you having to create more than one in your application (if, for example,
       you're doing more than just XPath).

           my $xp = XML::XPath->new( context => $node );

       It is very much recommended that you use only 1 XPath object throughout the life of your
       application. This is because the object (and it's sub-objects) maintain certain bits of
       state information that will be useful (such as XPath variables) to later calls to find().
       It's also a good idea because you'll use less memory this way.

   nodeset = find($path, [$context])
       The find function takes an XPath expression (a string) and returns either an
       XML::XPath::NodeSet object containing the nodes it found (or empty if no nodes matched the
       path), or one of XML::XPath::Literal (a string), XML::XPath::Number, or
       XML::XPath::Boolean. It should always return something - and you can use ->isa() to find
       out what it returned. If you need to check how many nodes it found you should check
       $nodeset->size.  See XML::XPath::NodeSet. An optional second parameter of a context node
       allows you to use this method repeatedly, for example XSLT needs to do this.

   findnodes($path, [$context])
       Returns a list of nodes found by $path, optionally in context $context.  In scalar context
       returns an XML::XPath::NodeSet object.

   findnodes_as_string($path, [$context])
       Returns the nodes found reproduced as XML. The result is not guaranteed to be valid XML
       though.

   findvalue($path, [$context])
       Returns either a "XML::XPath::Literal", a "XML::XPath::Boolean" or a "XML::XPath::Number"
       object. If the path returns a NodeSet, $nodeset->to_literal is called automatically for
       you (and thus a "XML::XPath::Literal" is returned). Note that for each of the objects
       stringification is overloaded, so you can just print the value found, or manipulate it in
       the ways you would a normal perl value (e.g. using regular expressions).

   exists($path, [$context])
       Returns true if the given path exists.

   matches($node, $path, [$context])
       Returns true if the node matches the path (optionally in context $context).

   getNodeText($path)
       Returns the text string for a particular XML node.  Returns a string, or undef if the node
       doesn't exist.

   setNodeText($path, $text)
       Sets the text string for a particular XML node.  The node can be an element or an
       attribute.  If the node to be set is an attribute, and the attribute node does not exist,
       it will be created automatically.

   createNode($path)
       Creates the node matching the path given.  If part of the path given, or all of the path
       do not exist, the necessary nodes will be created automatically.

   set_namespace($prefix, $uri)
       Sets the namespace prefix mapping to the uri.

       Normally in XML::XPath the prefixes in XPath node tests take their context from the
       current node. This means that foo:bar will always match an element <foo:bar> regardless of
       the namespace that the prefix foo is mapped to (which might even change within the
       document, resulting in unexpected results). In order to make prefixes in XPath node tests
       actually map to a real URI, you need to enable that via a call to the set_namespace method
       of your XML::XPath object.

   clear_namespaces()
       Clears all previously set namespace mappings.

   $XML::XPath::Namespaces
       Set this to 0 if you don't want namespace processing to occur. This will make everything a
       little (tiny) bit faster, but you'll suffer for it, probably.

Node Object Model

       See XML::XPath::Node, XML::XPath::Node::Element, XML::XPath::Node::Text,
       XML::XPath::Node::Comment, XML::XPath::Node::Attribute, XML::XPath::Node::Namespace, and
       XML::XPath::Node::PI.

On Garbage Collection

       XPath nodes work in a special way that allows circular references, and yet still lets
       Perl's reference counting garbage collector to clean up the nodes after use. This should
       be totally transparent to the user, with one caveat: If you free your tree before letting
       go of a sub-tree, consider that playing with fire and you may get burned. What does this
       mean to the average user? Not much. Provided you don't free (or let go out of scope)
       either the tree you passed to XML::XPath->new, or if you didn't pass a tree, and passed a
       filename or IO-ref, then provided you don't let the XML::XPath object go out of scope
       before you let results of find() and its friends go out of scope, then you'll be fine.
       Even if you do let the tree go out of scope before results, you'll probably still be fine.
       The only case where you may get stung is when the last part of your path/query is either
       an ancestor or parent axis. In that case the worst that will happen is you'll end up with
       a circular reference that won't get cleared until interpreter destruction time. You can
       get around that by explicitly calling $node->DESTROY on each of your result nodes, if you
       really need to do that.

       Mail me direct if that's not clear. Note that it's not doom and gloom. It's by no means
       perfect, but the worst that will happen is a long running process could leak memory. Most
       long running processes will therefore be able to explicitly be careful not to free the
       tree (or XML::XPath object) before freeing results. AxKit, an application that uses
       XML::XPath, does this and I didn't have to make any changes to the code - it's already
       sensible programming.

       If you really don't want all this to happen, then set the variable $XML::XPath::SafeMode,
       and call $xp->cleanup() on the XML::XPath object when you're finished, or $tree->dispose()
       if you have a tree instead.

Example

       Please see the test files in t/ for examples on how to use XPath.

Support/Author

       This module is copyright 2000 AxKit.com Ltd. This is free software, and as such comes with
       NO WARRANTY. No dates are used in this module. You may distribute this module under the
       terms of either the Gnu GPL,  or the Artistic License (the same terms as Perl itself).

       For support, please subscribe to the Perl-XML mailing list at the URL
       http://listserv.activestate.com/mailman/listinfo/perl-xml

       Matt Sergeant, matt@sergeant.org

SEE ALSO

       XML::XPath::Literal, XML::XPath::Boolean, XML::XPath::Number, XML::XPath::XMLParser,
       XML::XPath::NodeSet, XML::XPath::PerlSAX, XML::XPath::Builder.