• var: passed into XML_PullParser for its $child_tags array

Either one of two defined constants: eXcavator_STRING or eXcavator_FILE

This is the result array, created in _setDATA as conditions are evaluated as TRUE

Used by eXcavator_getFormattedText

• var: reference to XML_PullParser instance

AND's expressions in $condition; loops through each expression in AND-ed sequence and returns false at first one to be found false, otherwise true

SYNTAX:
The syntax of _AND_ and _OR has two formats. One format applies if all the expressions in the condition are descendents of the context element to the left of the brackets and are of the same type:

• vehicle[[@year>=2004 @make=Honda]]

But both _AND_ and _OR have a more comprehensive syntax, which allows for mixing of types and for the introduction of additional contexts into the condition. Here are the rules which govern the expanded syntax:

1. Every AND-ed expression to the right of the _AND_ after the initial expression must use this syntax:
   target-element relational-expression
   For instance vehicle[[color CDATA=green]], which can be shortened to vehicle[[color=green]]
2. The initial expression, i.e.the expression to the left of the first _AND_, can use the standard syntax for conditions, with one exception: it cannot use the shortcut for equality, as in color[geen] but must use the full expression: CDATA = green. On the other hand, it can also use the expanded syntax.

1. vehicle[[dealer/avenue => CDATA < < Waverly _AND_ color = green _AND_ carfax @buyback=no]]
   
2. first_name[[CDATA < < Douglas _AND_ first_name @middle_init=J]]
   
3. owner[[ first_name < < Douglas _AND_ first_name @middle_init=J]]
   
   

All the elements being searched must appear in the tokenized array $token, which is passed in as a parameter. That is, all of the items being evaluated must be descendents of a governing context-element. They don't have to be first-generation children, only descendents.

• integer $save_type: either ATTR or CDATA, not currently used by method
• string $condition
• mixed $xml: either string if cdata or associative array if attribute, i.e. attribute_name=>value
• array $token: the XML_PullParser tokenized array in which the current search is being conducted

Gets formatted text based on a template

The template format is:
optional-text {selector} optional-text {selector} . . .

The optional text will be reproduced verbatim from the template. The selectors locate and identify data.

The basic selector consists of an element name:
{first_name}
or of the element name followed by a semi-colon and the name of an attribute:
{first_name;middle_init}

If there is more than one element of the same name in a context, it can be addressed using an indirect addressing mode:
{ owner=>city[1] } This selects the first city element in the owner element.

Text formatting is fully treated in the Manual.

• return: text formatted in accordance with $pattern

• integer $which: result index
• $string $element: name of element for display
• string $pattern: template for formatted text

Returns a copy of the raw result array eXcavator_result_array

Deprecated

This is an internal function

• see: eXcavator::_getResultAsDataStruct()

Converts result from eXcavator_getResultAsString to

well-formed XML string

OR's condition

loops through each expression in Or-ed sequence and returns true at first one to be found true, otherwise false

For details on how to use this method see eXcavator_AND. What is said there applies to eXcavator_OR, except for the fact that this method OR's instead of AND's the conditions.

• integer $save_type: either ATTR or CDATA, not currently used by method
• string $condition
• mixed $xml: either string if cdata or associative array if attribute, i.e. attribute_name=>value
• array $token: the XML_PullParser tokenized array in which the current search is being conducted

Constructor for eXcavator

• string $query

An informational facility. Designed for use when creating patterns for eXcavator_getFormattedText.

It returns an array that is mapped to the requested element structure, showing the the elements it holds and their contents, both character data and attributes. In the output, duplicate element names are indexed using a triple underscore followed the its number, as in:

             ___1

The numbering begins with the second element, which is element___1. The first element found does not have an index attached to it.

This is the indexing that is used for direct addressing by eXcavator_getFormattedText.

This method returns only the first element named $element. If there is more than one element of the same name, for which a result is desired, then each subsequent element of that name must be addressed with its numeric index. If, for instance, an element named book has three authors, a request for book will return an array that includes author, author___1, and author___2. But if the request is for author, then only the first author element, with its children, will be returned. Separate requests would have to be made for author___1 and author___2.

• return: consists of elements in $eXcavator_user_result_array[$which][$element]
• see: eXcavator::$eXcavator_user_result_array

• integer $which: result index
• $string $element: name of element for display

• $which
• $parent

Parses the condition and determines the value of query

Determines operator type, type of condition (CDATA, ATTR), extracts the relevant children of $token and routes them to the proper operator method, collects each child that satisfies the condition in a result array and puts that in &$found_array or else if testing for the values of a descendent, it puts the ancestor array, which is extracted from $token, into &$found_array

main method variables:

1. $save_type -- value passed to _setDATA in r_test(), either of two defines: CDATA or ATTR
2. $op -- value of match operator: _NOT_, _GT_, etc

• return: returns to r_test an array of sub conditions if it finds more than one condition in $condition; otherwise it returns the $save_type, which will be passed to _setDAta(), and by refence, the parameter &$found_array, which is the XML_PullParser_childXCL version of the result, which has been pulled from the parameter $token. r_test() sends this to _setData(), where it is saved in an array that conforms to the array type created by XML_PullParser_getChildren.

• string $condition
• string $element: name of target element
• array $token: XML_PullParser tokenized array
• array &$found_array: XML_PullParser tokenized array

Determines if there is an element which matches the element in the condition

• return: Returns either the condition which matched the element or Null if not found

• mixed $element: either a token or the name of anelement $conditions mixed $conditions either a single condition or any array of conditions
• $conditions

Creates a key for each result element, which is a treated as a branch; called by _setUserResultArray to create the array needed by eXcavator_getFormattedText

What this method does, in effect, is to create an associative array of associative arrays, in which each element that has descendents is a separate associative array branching off the top level array. The associative array of descendents elements in turn holds the data in sets of associative arrays as described below.

This method works on a result array returned by _getResultAsDataStruct which creates a key for each element and if necessary numbers them and then sets each key to an array which holds the data for attributes and cdata:

   [element]=> array
             (
               [cdata] => string value
               [attr]  => semi-colon separated
                      string attributes: name="value";name="value"
            )

• array $data: copy of array returned by _getResultAsDataStruct

Determines whether a relation is TRUE or FALSE

• integer $op: constant defined relational operator
• string $left: left side of operator, extracted from XML
• string $right: right side of operator, user supplied value

Converts XML_PullParser tokenized array to string

Called by eXcavator_getResultAsString which loops through the result array one result at a time, sending it here for string-izing

• boolean $html: returns string suitable for display in browser if True

Does work of creating arrays for eXcavator_result_array

Converts array returned by _getResultAsDataStruct()

to form suitable for use by eXcavator_getFormattedText