SaxonC 12.5
Saxon Processor library for C/C++, PHP and Python
Loading...
Searching...
No Matches
Public Member Functions | List of all members
XPathProcessor Class Reference

#include <XPathProcessor.h>

Public Member Functions

 XPathProcessor ()
 Default constructor.
 
 XPathProcessor (SaxonProcessor *proc, std::string cwd="")
 Constructor with the SaxonProcessor supplied.
 
 XPathProcessor (const XPathProcessor &other)
 
void setBaseURI (const char *uriStr)
 
const char * getBaseURI ()
 
XdmValueevaluate (const char *xpathStr, const char *encoding=nullptr)
 Compile and evaluate an XPath expression.
 
XdmItemevaluateSingle (const char *xpathStr, const char *encoding=nullptr)
 
void setContextItem (XdmItem *item)
 
void setcwd (const char *cwd)
 
void setContextFile (const char *filename)
 
bool effectiveBooleanValue (const char *xpathStr, const char *encoding=nullptr)
 
void setParameter (const char *name, XdmValue *value, bool withParam=true)
 
bool removeParameter (const char *name)
 
void setProperty (const char *name, const char *value)
 Set a property specific to the processor in use.
 
void declareNamespace (const char *prefix, const char *uri)
 
void declareVariable (const char *name)
 
void setLanguageVersion (const char *version)
 
void setBackwardsCompatible (bool option)
 Say whether XPath 1.0 backwards compatibility mode is to be used.
 
void setCaching (bool caching)
 Say whether the compiler should maintain a cache of compiled expressions.
 
void setUnprefixedElementMatchingPolicy (UnprefixedElementMatchingPolicy policy)
 Set the policy for matching unprefixed element names in XPath expressions.
 
UnprefixedElementMatchingPolicy convertEnumPolicy (int n)
 
UnprefixedElementMatchingPolicy getUnprefixedElementMatchingPolicy ()
 ! Get the policy for matching unprefixed element names in XPath expressions
 
void importSchemaNamespace (const char *uri)
 Import a schema namespace.
 
XdmValuegetParameter (const char *name, bool withParam=true)
 
std::map< std::string, XdmValue * > & getParameters ()
 
std::map< std::string, std::string > & getProperties ()
 
void clearParameters (bool deleteValues=false)
 
void clearProperties ()
 
bool exceptionOccurred ()
 
void exceptionClear ()
 Clear any exception thrown.
 
const char * getErrorMessage ()
 Get the first error message if there are any errors.
 
const char * getErrorCode ()
 Get the first error code if there are any errors.
 
SaxonApiExceptiongetException ()
 Get the SaxonApiException object created when we have an error.
 

Detailed Description

An XPathProcessor represents a factory to compile, load and execute XPath expressions.

Constructor & Destructor Documentation

◆ XPathProcessor() [1/3]

XPathProcessor::XPathProcessor ( )

Default constructor.

Creates a Saxon-HE XPath product

◆ XPathProcessor() [2/3]

XPathProcessor::XPathProcessor ( SaxonProcessor * proc,
std::string cwd = "" )

Constructor with the SaxonProcessor supplied.

Parameters
proc- Pointer to the SaxonProcessor object
cwd- The current working directory
Exceptions
SaxonApiException

◆ XPathProcessor() [3/3]

XPathProcessor::XPathProcessor ( const XPathProcessor & other)

XPathProcessor copy constructor.

Parameters
other- XPathProcessor

Member Function Documentation

◆ clearParameters()

void XPathProcessor::clearParameters ( bool deleteValues = false)

Clear parameter values set. Default behaviour (false) is to leave XdmValues in memory. Individual pointers to XdmValue objects have to be deleted in the calling program.

Parameters
deleteValues- if true then XdmValues are deleted

◆ clearProperties()

void XPathProcessor::clearProperties ( )

Clear property values set

◆ convertEnumPolicy()

UnprefixedElementMatchingPolicy XPathProcessor::convertEnumPolicy ( int n)
inline

Convert an int into an UnprefixedElementMatchingPolicy

Parameters
n- the int representing the policy

◆ declareNamespace()

void XPathProcessor::declareNamespace ( const char * prefix,
const char * uri )

Declare a namespace binding as part of the static context for XPath expressions compiled using this XPathCompiler

Parameters
prefixThe namespace prefix. If the value is a zero-length string, this method sets the default namespace for elements and types.
uriThe namespace URI. It is possible to specify a zero-length string to "undeclare" a namespace; in this case the prefix will not be available for use, except in the case where the prefix is also a zero length string, in which case the absence of a prefix implies that the name is in no namespace. Assume the prefix or uri is nullptr.

◆ declareVariable()

void XPathProcessor::declareVariable ( const char * name)

Declare a variable as part of the static context for XPath expressions compiled using this XPathCompiler. It is an error for the XPath expression to refer to a variable unless it has been declared. This method declares the existence of the variable, but it does not bind any value to the variable; that is done later, when the XPath expression is evaluated. The variable is allowed to have any type (that is, the required type is item()*).

Parameters
nameThe name of the variable, expressions as a clark name string

◆ effectiveBooleanValue()

bool XPathProcessor::effectiveBooleanValue ( const char * xpathStr,
const char * encoding = nullptr )

Evaluate the XPath expression, returning the effective boolean value of the result.

Parameters
xpathStr- supplied as a character string
encoding- the encoding of the string. If not specified then the platform default encoding is used.
Returns
bool
Exceptions
SaxonApiException

◆ evaluate()

XdmValue * XPathProcessor::evaluate ( const char * xpathStr,
const char * encoding = nullptr )

Compile and evaluate an XPath expression.

Parameters
xpathStr- supplied as a character string
encoding- the encoding of the string. If not specified then the platform default encoding is used.
Returns
XdmValue - representing the results of the expression.
Exceptions
SaxonApiException

◆ evaluateSingle()

XdmItem * XPathProcessor::evaluateSingle ( const char * xpathStr,
const char * encoding = nullptr )

Compile and evaluate an XPath expression. The result is expected to be a single XdmItem or nullptr

Parameters
xpathStr- supplied as a character string
encoding- the encoding of the string. If not specified then the platform default encoding is used.
Returns
XdmItem - XdmItem object or nullptr if the expression returns an empty sequence. If the expression returns a sequence of more than one item, any items after the first are ignored.
Exceptions
SaxonApiException

◆ exceptionOccurred()

bool XPathProcessor::exceptionOccurred ( )

Checks for pending exceptions without creating a local reference to the exception object

Returns
bool - true when there is a pending exception; otherwise return false Checks for pending exceptions without creating a local reference to the exception object
bool - true when there is a pending exception; otherwise return false

◆ getBaseURI()

const char * XPathProcessor::getBaseURI ( )

Get the static base URI for XPath expressions compiled using this XPathCompiler.

Returns
base URI as string of the xPathProcessor

◆ getErrorCode()

const char * XPathProcessor::getErrorCode ( )

Get the first error code if there are any errors.

After the execution of the XPath expression there may be a number of errors reported against it.

Returns
char* - The error code of the exception.

◆ getErrorMessage()

const char * XPathProcessor::getErrorMessage ( )

Get the first error message if there are any errors.

An XPath expression may have a number of errors reported against it.

Returns
char* - The message of the exception

◆ getException()

SaxonApiException * XPathProcessor::getException ( )

Get the SaxonApiException object created when we have an error.

After the execution of the processor if there is an error, then a SaxonApiException is created. NULL returned if there is no error.

Returns
SaxonApiException object of the exception thrown.

◆ getParameter()

XdmValue * XPathProcessor::getParameter ( const char * name,
bool withParam = true )

Get a parameter value by name

Parameters
name- Specified parameter name to get
withParamInternal use only
Returns
XdmValue

◆ getParameters()

std::map< std::string, XdmValue * > & XPathProcessor::getParameters ( )

Get all parameters as a std::map

◆ getProperties()

std::map< std::string, std::string > & XPathProcessor::getProperties ( )

Get all properties as a std::map

◆ getUnprefixedElementMatchingPolicy()

UnprefixedElementMatchingPolicy XPathProcessor::getUnprefixedElementMatchingPolicy ( )

! Get the policy for matching unprefixed element names in XPath expressions

Returns
the policy being used

◆ importSchemaNamespace()

void XPathProcessor::importSchemaNamespace ( const char * uri)

Import a schema namespace.

Here we add the element and attribute declarations and type definitions contained in a given namespace to the static context for the XPath expression.

This method will not cause the schema to be loaded. This method will not fail if the schema has not been loaded (but in that case the set of declarations and definitions made available to the XPath expression is empty). The schema document for the specified namespace may be loaded before or after this method is called.

This method does not bind a prefix to the namespace. That must be done separately, using the declareNamespace(String, String) method.

Parameters
uriThe schema namespace to be imported. To import declarations in a no-namespace schema, supply a zero-length string.

◆ removeParameter()

bool XPathProcessor::removeParameter ( const char * name)

Remove a parameter (name, value) pair

Parameters
nameof the parameter
Returns
bool - outcome of the removal

◆ setBackwardsCompatible()

void XPathProcessor::setBackwardsCompatible ( bool option)

Say whether XPath 1.0 backwards compatibility mode is to be used.

In backwards compatibility mode, more implicit type conversions are allowed in XPath expressions, for example it is possible to compare a number with a string. The default is false (backwards compatibility mode is off).

Parameters
optiontrue if XPath 1.0 backwards compatibility is to be enabled, false if it is to be disabled.

◆ setBaseURI()

void XPathProcessor::setBaseURI ( const char * uriStr)

Set the static base URI for XPath expressions compiled using this XPathCompiler. The base URI is part of the static context, and is used to resolve any relative URIs appearing within an XPath expression, for example a relative URI passed as an argument to the doc() function. If no static base URI is supplied, then the current working directory is used.

Parameters
uriStr

◆ setCaching()

void XPathProcessor::setCaching ( bool caching)

Say whether the compiler should maintain a cache of compiled expressions.

Parameters
cachingif set to true, caching of compiled expressions is enabled. If set to false, any existing cache is cleared, and future compiled expressions will not be cached until caching is re-enabled. The cache is also cleared (but without disabling future caching) if any method is called that changes the static context for compiling expressions, for example declareVariable(QName) or declareNamespace(String, String).

◆ setContextFile()

void XPathProcessor::setContextFile ( const char * filename)

Set the context item from file

◆ setContextItem()

void XPathProcessor::setContextItem ( XdmItem * item)

Set the context item

◆ setcwd()

void XPathProcessor::setcwd ( const char * cwd)

set the current working directory

◆ setLanguageVersion()

void XPathProcessor::setLanguageVersion ( const char * version)

Say whether an XPath 2.0, XPath 3.0, XPath 3.1 or XPath 4.0 processor is required. Set the language version for the XPath compiler.

Parameters
versionOne of the values 1.0, 2.0, 3.0, 3.05, 3.1, 4.0. Setting the option to 1.0 requests an XPath 2.0 processor running in 1.0 compatibility mode; this is equivalent to setting the language version to 2.0 and backwards compatibility mode to true. Requesting "3.05" gives XPath 3.0 plus the extensions defined in the XSLT 3.0 specification (map types and map constructors).

◆ setParameter()

void XPathProcessor::setParameter ( const char * name,
XdmValue * value,
bool withParam = true )

Set a parameter value used in the query

Parameters
nameof the parameter, as a string. For namespaced parameter use the JAXP solution i.e. "{uri}name"
valueof the query parameter, or nullptr to clear a previously set value
withParamInternal use only

◆ setProperty()

void XPathProcessor::setProperty ( const char * name,
const char * value )

Set a property specific to the processor in use.

XPathProcessor: set serialization properties (names start with '!' i.e. name "!method" -> "xml") 'o':outfile name, 's': context item supplied as file name

Parameters
nameof the property
valueof the property

◆ setUnprefixedElementMatchingPolicy()

void XPathProcessor::setUnprefixedElementMatchingPolicy ( UnprefixedElementMatchingPolicy policy)

Set the policy for matching unprefixed element names in XPath expressions.

Parameters
policythe policy to be used, possible values: DEFAULT_NAMESPACE = 0, ANY_NAMESPACE = 1 or DEFAULT_NAMESPACE_OR_NONE = 2

The documentation for this class was generated from the following files: