NAME
   XML::LibXML::XPathContext - Perl interface to libxml2's xmlXPathContext

SYNOPSIS
       use XML::LibXML::XPathContext;

       my $xc = XML::LibXML::XPathContext->new;
       my $xc = XML::LibXML::XPathContext->new($node);

       my $node = $xc->getContextNode;
       $xc->setContextNode($node);

       my $position = $xc->getContextPosition;
       $xc->setContextPosition($position);
       my $size = $xc->getContextSize;
       $xc->setContextSize($size);

       $xc->registerNs($prefix, $namespace_uri);
       $xc->unregisterNs($prefix);
       my $namespace_uri = $xc->lookupNs($prefix);

       $xc->registerFunction($name, sub { ... });
       $xc->registerFunctionNS($name, $namespace_uri, sub { ... });
       $xc->unregisterFunction($name);
       $xc->unregisterFunctionNS($name, $namespace_uri);

       $xc->registerVarLookupFunc(sub { ... }, $data);
       $xc->unregisterVarLookupFunc($name);
       $data = $xc->getVarLookupData();
       $sub = $xc->getVarLookupFunc();

       my @nodes = $xc->findnodes($xpath);
       my @nodes = $xc->findnodes($xpath, $context_node);
       my $nodelist = $xc->findnodes($xpath);
       my $nodelist = $xc->findnodes($xpath, $context_node);
       my $result = $xc->find($xpath);
       my $result = $xc->find($xpath, $context_node);
       my $value = $xc->findvalue($xpath);
       my $value = $xc->findvalue($xpath, $context_node);

DESCRIPTION
   This module augments XML::LibXML by providing Perl interface to
   libxml2's xmlXPathContext structure. Besides just performing xpath
   statements on XML::LibXML's node trees it allows redefining certaint
   aspects of XPath engine. This modules allows

   1   registering namespace prefixes,

   2   defining XPath functions in Perl,

   3   defining variable lookup functions in Perl.

   3   cheating the context about current proximity position and context
       size

EXAMPLES
 Find all paragraph nodes in XHTML document
   This example demonstrates *registerNs()* usage:

       my $xc = XML::LibXML::XPathContext->new($xhtml_doc);
       $xc->registerNs('xhtml', 'http://www.w3.org/1999/xhtml');
       my @nodes = $xc->findnodes('//xhtml:p');

 Find all nodes whose names match a Perl regular expression
   This example demonstrates *registerFunction()* usage:

       my $perlmatch = sub {
           die "Not a nodelist"
               unless $_[0]->isa('XML::LibXML::NodeList');
           die "Missing a regular expression"
               unless defined $_[1];

           my $nodelist = XML::LibXML::NodeList->new;
           my $i = 0;
           while(my $node = $_[0]->get_node($i)) {
               $nodelist->push($node) if $node->nodeName =~ $_[1];
               $i ++;
           }

           return $nodelist;
       };

       my $xc = XML::LibXML::XPathContext->new($node);
       $xc->registerFunction('perlmatch', $perlmatch);
       my @nodes = $xc->findnodes('perlmatch(//*, "foo|bar")');

 Use XPath variables to recycle results of previous evaluations
   This example demonstrates *registerVarLookup()* usage:

       sub var_lookup {
         my ($varname,$ns,$data)=@_;
         return $data->{$varname};
       }

       my $areas = XML::LibXML->new->parse_file('areas.xml');
       my $empl = XML::LibXML->new->parse_file('employees.xml');

       my $xc = XML::LibXML::XPathContext->new($empl);

       my %results =
         (
          A => $xc->find('/employees/employee[@salary>10000]'),
          B => $areas->find('/areas/area[district='Brooklyn']/street'),
         );

       # get names of employees from $A woring in an area listed in $B
       $xc->registerVarLookupFunc(\&var_lookup, \%results);
       my @nodes = $xc->findnodes('$A[work_area/street = $B]/name');

METHODS
   new Creates a new XML::LibXML::XPathContext object without a context
       node.

   new($node)
       Creates a new XML::LibXML::XPathContext object with the context node
       set to *$node*.

   registerNs($prefix, $namespace_uri)
       Registers namespace *$prefix* to *$namespace_uri*.

   unregisterNs($prefix)
       Unregisters namespace *$prefix*.

   lookupNs($prefix)
       Returns namespace URI registered with *$prefix*. If *$prefix* is not
       registered to any namespace URI returns "undef".

   registerVarLookupFunc($callback, $data)
       Registers variable lookup function *$prefix*. The registered
       function is executed by the XPath engine each time an XPath variable
       is evaluated. It takes three arguments: *$data*, variable name, and
       variable ns-URI and must return one value: a number or string or any
       XML::LibXML object that can be a result of findnodes: Boolean,
       Literal, Number, Node (e.g. Document, Element, etc.), or NodeList.
       For convenience, simple (non-blessed) array references containing
       only XML::LibXML::Node objects can be used instead of a
       XML::LibXML::NodeList.

   getVarLookupData()
       Returns the data that have been associated with a variable lookup
       function during a previous call to *registerVarLookupFunc*.

   unregisterVarLookupFunc()
       Unregisters variable lookup function and the associated lookup data.

   registerFunctionNS($name, $uri, $callback)
       Registers an extension function *$name* in *$uri* namespace.
       *$callback* must be a CODE reference. The arguments of the callback
       function are either simple scalars or XML::LibXML::NodeList objects
       depending on the XPath argument types. The function is responsible
       for checking the argument number and types. Result of the callback
       code must be a single value of the following types: a simple scalar
       (number,string) or an arbitrary XML::LibXML object that can be a
       result of findnodes: Boolean, Literal, Number, Node (e.g. Document,
       Element, etc.), or NodeList. For convenience, simple (non-blessed)
       array references containing only XML::LibXML::Node objects can be
       used instead of a XML::LibXML::NodeList.

   unregisterFunctionNS($name, $uri)
       Unregisters extension function *$name* in *$uri* namespace. Has the
       same effect as passing "undef" as *$callback* to registerFunctionNS.

   registerFunction($name, $callback)
       Same as *registerFunctionNS* but without a namespace.

   unregisterFunction($name)
       Same as *unregisterFunctionNS* but without a namespace.

   findnodes($xpath, [ $context_node ])
       Performs the xpath statement on the current node and returns the
       result as an array. In scalar context returns a
       XML::LibXML::NodeList object. Optionally, a node may be passed as a
       second argument to set the context node for the query.

   find($xpath, [ $context_node ])
       Performs the xpath expression using the current node as the context
       of the expression, and returns the result depending on what type of
       result the XPath expression had. For example, the XPath "1 * 3 + 52"
       results in a XML::LibXML::Number object being returned. Other
       expressions might return a XML::LibXML::Boolean object, or a
       XML::LibXML::Literal object (a string). Each of those objects uses
       Perl's overload feature to "do the right thing" in different
       contexts. Optionally, a node may be passed as a second argument to
       set the context node for the query.

   findvalue($xpath, [ $context_node ])
       Is exactly equivalent to:

           $node->find( $xpath )->to_literal;

       That is, it returns the literal value of the results. This enables
       you to ensure that you get a string back from your search, allowing
       certain shortcuts. This could be used as the equivalent of
       <xsl:value-of select="some_xpath"/>. Optionally, a node may be
       passed in the second argument to set the context node for the query.

   getContextNode()
       Get the current context node.

   setContextNode($node)
       Set the current context node.

   setContextPosition($position)
       Set the current proximity position. By default, this value is -1
       (and evaluating XPath function position() in the initial context
       raises an XPath error), but can be set to any value up to context
       size. This usually only serves to cheat the XPath engine to return
       given position when position() XPath function is called. Setting
       this value to -1 restores the default behavior.

   getContextPosition()
       Get the current proximity position.

   setContextSize($size)
       Set the current size. By default, this value is -1 (and evaluating
       XPath function last() in the initial context raises an XPath error),
       but can be set to any non-negative value. This usually only serves
       to cheat the XPath engine to return the given value when last()
       XPath function is called. If context size is set to 0, position is
       automatically also set to 0. If context size is positive, position
       is automatically set to 1. Setting context size to -1 restores the
       default behavior.

   getContextPosition()
       Get the current proximity position.

   setContextNode($node)
       Set the current context node.

BUGS AND CAVEATS
   From version 0.06, XML::LibXML::XPathContext objects are reentrant,
   meaning that you can call methods of an XML::LibXML::XPathContext even
   from XPath extension functions registered with the same object or from a
   variable lookup function. On the other hand, you should rather avoid
   registering new extension functions, namespaces and a variable lookup
   function from within extension functions and a variable lookup function,
   unless you want to experience untested behavior.

AUTHORS
   Based on XML::LibXML and XML::XSLT code by Matt Sergeant and Christian
   Glahn.

   Maintained by Ilya Martynov and Petr Pajas.

   Copyright 2001-2003 AxKit.com Ltd, All rights reserved.

SUPPORT
   For suggestions, bugreports etc. you may contact the maintainers
   directly ([email protected] and [email protected])

   XML::LibXML::XPathContext issues can be discussed among other things on
   the perl XML mailing list ([email protected]).

SEE ALSO
   XML::LibXML, XML::XSLT

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.