import org.jaxen.Navigator; //导入依赖的package包/类
public Object evaluate(Object attributeName, Object pattern, Navigator nav)
{
    List<Object> answer = new ArrayList<Object>();
    String attributeValue = StringFunction.evaluate(attributeName, nav);
    String patternValue = StringFunction.evaluate(pattern, nav);

    // TODO: Ignore the pattern for now
    // Should do a type pattern test
    if ((attributeValue != null) && (attributeValue.length() > 0))
    {
        DocumentNavigator dNav = (DocumentNavigator) nav;
        NodeRef nodeRef = new NodeRef(attributeValue);
        if (patternValue.equals("*"))
        {
            answer.add(dNav.getNode(nodeRef));
        }
        else
        {
            QNamePattern qNamePattern = new JCRPatternMatch(patternValue, dNav.getNamespacePrefixResolver());
            answer.addAll(dNav.getNode(nodeRef, qNamePattern));
        }

    }
    return answer;

}
 

import org.jaxen.Navigator; //导入依赖的package包/类
@Override
public Object evaluate(final Context context) throws JaxenException {
    final Object lhsValue = getLHS().evaluate(context);
    final Object rhsValue = getRHS().evaluate(context);
    final Navigator nav = context.getNavigator();

    if (bothAreSets(lhsValue, rhsValue)) {
        return evaluateSetSet((List) lhsValue, (List) rhsValue, nav);
    }

    if (eitherIsSet(lhsValue, rhsValue)) {
        if (isSet(lhsValue)) {
            return evaluateSetSet((List) lhsValue, convertToList(rhsValue), nav);
        } else {
            return evaluateSetSet(convertToList(lhsValue), (List) rhsValue, nav);
        }
    }

    return evaluateObjectObject(lhsValue, rhsValue, nav) ? Boolean.TRUE : Boolean.FALSE;
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
private Object evaluateSetSet(final List lhsSet, final List rhsSet, final Navigator nav) {
    if (setIsEmpty(lhsSet) || setIsEmpty(rhsSet)) // return false if either is null or empty
    {
        return Boolean.FALSE;
    }

    for (final Iterator lhsIterator = lhsSet.iterator(); lhsIterator.hasNext();) {
        final Object lhs = lhsIterator.next();

        for (final Iterator rhsIterator = rhsSet.iterator(); rhsIterator.hasNext();) {
            final Object rhs = rhsIterator.next();

            if (evaluateObjectObject(lhs, rhs, nav)) {
                return Boolean.TRUE;
            }
        }
    }

    return Boolean.FALSE;
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
/** @return true if the pattern matches the given node
  */
public boolean matches( Object node, Context context ) 
{
    Navigator navigator = context.getNavigator();
    String uri = getURI( node, context );
    
    if ( nodeType == Pattern.ELEMENT_NODE ) 
    {
        return navigator.isElement( node ) 
            && uri.equals( navigator.getElementNamespaceUri( node ) );
    }
    else if ( nodeType == Pattern.ATTRIBUTE_NODE ) 
    {
        return navigator.isAttribute( node )
            && uri.equals( navigator.getAttributeNamespaceUri( node ) );
    }
    return false;
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
public Object call(Context context,
                   List args) throws FunctionCallException
{
    if (args.size() == 1)
    {
        Navigator nav = context.getNavigator();

        String    url = StringFunction.evaluate( args.get( 0 ),
                                                 nav );

        return evaluate( url,
                         nav );
    }

    throw new FunctionCallException( "document() requires one argument." );
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
/** 
 * <p>Returns true if the first string contains the second string; false otherwise.
 * If necessary one or both arguments are converted to a string as if by the XPath
 * <code>string()</code> function.
 * </p>
 * 
 * @param strArg the containing string
 * @param matchArg the contained string
 * @param nav used to calculate the string-values of the first two arguments
 * 
 * @return <code>Boolean.TRUE</code> if true if the first string contains 
 *     the second string; <code>Boolean.FALSE</code> otherwise.
 */
public static Boolean evaluate(Object strArg,
                               Object matchArg,
                               Navigator nav) 
{
    String str   = StringFunction.evaluate( strArg,
                                            nav );

    String match = StringFunction.evaluate( matchArg,
                                            nav );

    return ( ( str.indexOf(match) >= 0)
             ? Boolean.TRUE
             : Boolean.FALSE
             );
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
private static boolean evaluate(Object node, String lang, Navigator nav)
  throws UnsupportedAxisException
{
    
    Object element = node;
    if (! nav.isElement(element)) {
        element = nav.getParentNode(node);
    }
    while (element != null && nav.isElement(element)) 
    {
        Iterator attrs = nav.getAttributeAxisIterator(element);
        while(attrs.hasNext())
        {
            Object attr = attrs.next();
            if(LANG_LOCALNAME.equals(nav.getAttributeName(attr)) && 
               XMLNS_URI.equals(nav.getAttributeNamespaceUri(attr)))
            {
                return 
                    isSublang(nav.getAttributeStringValue(attr), lang);
            }
        }
        element = nav.getParentNode(element);
    }
    return false;
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
/** 
 * Returns true if the string-value of <code>strArg</code>
 * starts with the string-value of <code>matchArg</code>. 
 * Otherwise it returns false.
 * 
 * @param strArg the object whose string-value searched for the prefix
 * @param matchArg the object whose string-value becomes the prefix string to compare against
 * @param nav the navigator used to calculate the string-values of the arguments
 * 
 * @return <code>Boolean.TRUE</code> if the string-value of <code>strArg</code>
 *     starts with the string-value of <code>matchArg</code>;
 *     otherwise <code>Boolean.FALSE</code>
 * 
 */
public static Boolean evaluate(Object strArg,
                               Object matchArg,
                               Navigator nav)
{
    String str   = StringFunction.evaluate( strArg,
                                            nav );

    String match = StringFunction.evaluate( matchArg,
                                            nav );

    return ( str.startsWith(match)
             ? Boolean.TRUE
             : Boolean.FALSE
             );
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
/** 
 * Returns the sum of the items in a list.
 * If necessary, each item in the list is first converted to a <code>Double</code>
 * as if by the XPath <code>number()</code> function.
 * 
 * @param obj a <code>List</code> of numbers to be summed
 * @param nav ignored
 * 
 * @return the sum of the list
 * 
 * @throws FunctionCallException if <code>obj</code> is not a <code>List</code>
 */
public static Double evaluate(Object obj,
                              Navigator nav) throws FunctionCallException
{
    double sum  = 0;

    if (obj instanceof List)
    {
        Iterator nodeIter = ((List)obj).iterator();
        while ( nodeIter.hasNext() )
        {
            double term = NumberFunction.evaluate( nodeIter.next(),
                                            nav ).doubleValue();
            sum += term;
        }
    }
    else
    {
        throw new FunctionCallException("The argument to the sum function must be a node-set");
    }

    return new Double(sum);
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
/** 
 * Returns the part of <code>strArg</code> that precedes the first occurence 
 * of <code>matchArg</code>; or the empty string if the 
 * <code>strArg</code> does not contain <code>matchArg</code>
 * 
 * @param strArg the string from which the substring is extracted
 * @param matchArg the string that marks the boundary of the substring
 * @param nav the <code>Navigator</code> used to calculate the string-values of
 *     the first two arguments
 * 
 * @return a <code>String</code> containing the part of <code>strArg</code> that precedes the first occurence 
 * of <code>matchArg</code>
 * 
 */
public static String evaluate(Object strArg,
                              Object matchArg,
                              Navigator nav)
{
    String str   = StringFunction.evaluate( strArg,
                                            nav );

    String match = StringFunction.evaluate( matchArg,
                                            nav );

    int loc = str.indexOf(match);

    if ( loc < 0 )
    {
        return "";
    }

    return str.substring(0, loc);

}
 

import org.jaxen.Navigator; //导入依赖的package包/类
/** 
 * Returns the part of <code>strArg</code> that follows the first occurence 
 * of <code>matchArg</code>; or the empty string if the 
 * <code>strArg</code> does not contain <code>matchArg</code>
 * 
 * @param strArg the string from which the substring is extracted
 * @param matchArg the string that marks the boundary of the substring
 * @param nav the <code>Navigator</code> used to calculate the string-values of
 *     the first two arguments
 * 
 * @return a <code>String</code> containing
 *     the part of <code>strArg</code> that precedes the first occurence 
 *     of <code>matchArg</code>
 * 
 */
public static String evaluate(Object strArg,
                              Object matchArg,
                              Navigator nav)
{
    String str   = StringFunction.evaluate( strArg,
                                            nav );

    String match = StringFunction.evaluate( matchArg,
                                            nav );

    int loc = str.indexOf(match);

    if ( loc < 0 )
    {
        return "";
    }

    return str.substring(loc+match.length());
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
/** 
 * Attempts to convert the given function argument value 
 * into a Locale either via casting, extracting it from a List
 * or looking up the named Locale using reflection.
 *
 * @param value is either a Locale, a List containing a Locale
 *      or a String containing the name of a Locale
 *      as defined by the Locale static members.
 *
 * @return the Locale for the value or null if one could 
 *      not be deduced
 */
protected Locale getLocale(Object value, Navigator navigator) 
{
    if (value instanceof Locale)
    {
        return (Locale) value;
    }
    else if(value instanceof List)
    {
        List list = (List) value;
        if ( ! list.isEmpty() ) 
        {
            return getLocale( list.get(0), navigator );
        }
    }
    else {
        String text = StringFunction.evaluate( value, navigator );
        if (text != null && text.length() > 0) 
        {
            return findLocale( text );
        }
    }
    return null;
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
public Object call(Context context,
                   List args) throws FunctionCallException
{
    Navigator navigator = context.getNavigator();
    int size = args.size();
    if (size > 0)
    {
        Object text = args.get(0);
        Locale locale = null;
        if (size > 1)
        {  
            locale = getLocale( args.get(1), navigator );
        }
        return evaluate( text, locale, navigator );
    }
    throw new FunctionCallException( "lower-case() requires at least one argument." );
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
public Object call(Context context,
                   List args) throws FunctionCallException
{
    Navigator navigator = context.getNavigator();
    int size = args.size();
    if (size > 0)
    {
        Object text = args.get(0);
        Locale locale = null;
        if (size > 1)
        {  
            locale = getLocale( args.get(1), navigator );
        }
        return evaluate( text, locale, navigator );
    }
    throw new FunctionCallException( "upper-case() requires at least one argument." );
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
public Object evaluate(Context context) throws JaxenException
{
    ContextSupport support = context.getContextSupport();
    Navigator      nav     = support.getNavigator();
    Context absContext = new Context( support );
    List contextNodes = context.getNodeSet();

    if ( contextNodes.isEmpty() )
    {
        return Collections.EMPTY_LIST;
    }

    Object firstNode = contextNodes.get( 0 );
    Object docNode   = nav.getDocumentNode( firstNode );

    if ( docNode == null )
    {
        return Collections.EMPTY_LIST;
    }

    List list = new SingletonList(docNode);

    absContext.setNodeSet( list );

    return super.evaluate( absContext );
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
public Object evaluate(Context context) throws JaxenException
{
    Navigator nav = context.getNavigator();
    Boolean lhsValue = BooleanFunction.evaluate( getLHS().evaluate( context ), nav );

    if ( lhsValue.booleanValue() )
    {
        return Boolean.TRUE;
    }

    // Short circuits are required in XPath. "The right operand is not 
    // evaluated if the left operand evaluates to true."
    Boolean rhsValue = BooleanFunction.evaluate( getRHS().evaluate( context ), nav );

    if ( rhsValue.booleanValue() )
    {
        return Boolean.TRUE;
    }

    return Boolean.FALSE;
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
private boolean evaluateObjectObject( Object lhs, Object rhs, Navigator nav )
{
if( eitherIsBoolean( lhs, rhs ) )
  {            
  return evaluateObjectObject( BooleanFunction.evaluate( lhs, nav ),
                               BooleanFunction.evaluate( rhs, nav ) );
  }
else if( eitherIsNumber( lhs, rhs ) )
  {
  return evaluateObjectObject( NumberFunction.evaluate( lhs,
                                                        nav ),
                               NumberFunction.evaluate( rhs,
                                                        nav ) );                                              
  }
else
  {
  return evaluateObjectObject( StringFunction.evaluate( lhs,
                                                        nav ),
                               StringFunction.evaluate( rhs,
                                                        nav ) );
  }
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
public Object evaluate( Context context ) throws JaxenException
{
Object lhsValue = getLHS().evaluate( context );
Object rhsValue = getRHS().evaluate( context );
Navigator nav = context.getNavigator();

if( bothAreSets( lhsValue, rhsValue ) )
  {
  return evaluateSetSet( (List) lhsValue, (List) rhsValue, nav );
  }

if( eitherIsSet( lhsValue, rhsValue ) )
  {
  if( isSet( lhsValue ) )
    {        
    return evaluateSetSet( (List) lhsValue, convertToList( rhsValue ), nav );              
    }
  else
    {
    return evaluateSetSet( convertToList( lhsValue ), (List) rhsValue, nav );              
    }
  }

return evaluateObjectObject( lhsValue, rhsValue, nav ) ? Boolean.TRUE : Boolean.FALSE;
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
private Object evaluateSetSet( List lhsSet, List rhsSet, Navigator nav )
{
if( setIsEmpty( lhsSet ) || setIsEmpty( rhsSet ) ) // return false if either is null or empty
  {
  return Boolean.FALSE;
  }    

for( Iterator lhsIterator = lhsSet.iterator(); lhsIterator.hasNext(); )
  {
  Object lhs = lhsIterator.next();        
  
  for( Iterator rhsIterator = rhsSet.iterator(); rhsIterator.hasNext(); )
    {
    Object rhs = rhsIterator.next();
    
    if( evaluateObjectObject( lhs, rhs, nav ) )
      {
      return Boolean.TRUE;
      }
    }
  }      

return Boolean.FALSE;
}
 

import org.jaxen.Navigator; //导入依赖的package包/类
private boolean evaluateObjectObject( Object lhs, Object rhs, Navigator nav )
{
if( lhs == null || rhs == null )
  {
  return false;
  }

Double lhsNum = NumberFunction.evaluate( lhs, nav );
Double rhsNum = NumberFunction.evaluate( rhs, nav );      

if( NumberFunction.isNaN( lhsNum ) || NumberFunction.isNaN( rhsNum ) )
  {
  return false;
  }

return evaluateDoubleDouble( lhsNum, rhsNum );
}