Java Context.getNodeSet方法代码示例

import org.jaxen.Context; //导入方法依赖的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.Context; //导入方法依赖的package包/类
public Object evaluate(Context context) throws JaxenException
{
    List nodeSet = context.getNodeSet();
    List contextNodeSet = new ArrayList(nodeSet);
    ContextSupport support = context.getContextSupport();
    Context stepContext = new Context(support);
    Iterator stepIter = getSteps().iterator();
    while ( stepIter.hasNext() )
    {
        Step eachStep = (Step) stepIter.next();
        stepContext.setNodeSet(contextNodeSet);
        contextNodeSet = eachStep.evaluate(stepContext);
        // now we need to reverse the list if this is a reverse axis
        if (isReverseAxis(eachStep)) {
            Collections.reverse(contextNodeSet);
        }
    }
    
    if (getSteps().size() > 1 || nodeSet.size() > 1) {
        Collections.sort(contextNodeSet, new NodeComparator(support.getNavigator()));
    }
    
    return contextNodeSet;
}
 

import org.jaxen.Context; //导入方法依赖的package包/类
public static List evaluate (Context context, Object arg)
    throws FunctionCallException
{
    List contextNodes = context.getNodeSet();
    
    if (contextNodes.size() == 0)
        return Collections.EMPTY_LIST;
  
    Navigator nav = context.getNavigator();

    String xpathString;
    if ( arg instanceof String )
        xpathString = (String)arg;
    else
        xpathString = StringFunction.evaluate(arg, nav);

    try {
        XPath xpath = nav.parseXPath(xpathString);
        ContextSupport support = context.getContextSupport();
        xpath.setVariableContext( support.getVariableContext() );
        xpath.setFunctionContext( support.getFunctionContext() );
        xpath.setNamespaceContext( support.getNamespaceContext() );
        return xpath.selectNodes( context.duplicate() );
    }
    catch ( org.jaxen.saxpath.SAXPathException e ) {
        throw new FunctionCallException(e.toString());
    }
}
 

import org.jaxen.Context; //导入方法依赖的package包/类
/** Returns true if the current filter matches at least one of the context nodes
 */
public boolean asBoolean(Context context) throws JaxenException 
{
    Object results = null;
    if ( expr != null ) 
    {
        results = expr.evaluate( context );
    }
    else
    {
        List nodeSet = context.getNodeSet();
        ArrayList list = new ArrayList(nodeSet.size());
        list.addAll( nodeSet );
        results = list;
    }
    
    if ( results instanceof Boolean ) 
    {
        Boolean b = (Boolean) results;
        return b.booleanValue();
    }
    if ( results instanceof List )
    {
        return getPredicateSet().evaluateAsBoolean( 
            (List) results, context.getContextSupport() 
        );
    }
    
    return false;
}
 

import org.jaxen.Context; //导入方法依赖的package包/类
public List evaluate(final Context context) throws JaxenException
{
    final List contextNodeSet  = context.getNodeSet();
    final IdentitySet unique = new IdentitySet();
    final int contextSize = contextNodeSet.size();

    // ???? try linked lists instead?
    // ???? initial size for these?
    final ArrayList interimSet = new ArrayList();
    final ArrayList newNodeSet = new ArrayList();
    final ContextSupport support = context.getContextSupport();
        
    // ???? use iterator instead
    for ( int i = 0 ; i < contextSize ; ++i )
    {
        Object eachContextNode = contextNodeSet.get( i );


            /* See jaxen-106. Might be able to optimize this by doing
             * specific matching for individual axes. For instance on namespace axis
             * we should only get namespace nodes and on attribute axes we only get 
             * attribute nodes. Self and parent axes have single members.
             * Children, descendant, ancestor, and sibling axes never 
             * see any attributes or namespaces
             */
        Iterator axisNodeIter = axis.iterator(eachContextNode, support);
        while ( axisNodeIter.hasNext() )
        {
            Object eachAxisNode = axisNodeIter.next();
            if ( ! unique.contains( eachAxisNode ) )
            {
                if ( matches( eachAxisNode, support ) )
                {
                    unique.add( eachAxisNode );
                    interimSet.add( eachAxisNode );
                }
            }
        }
        newNodeSet.addAll(getPredicateSet().evaluatePredicates(
                          interimSet, support ));
        interimSet.clear();
    }
    return newNodeSet;
}
 

import org.jaxen.Context; //导入方法依赖的package包/类
public void testDuplicate()
{
    Context original = new Context( this.support );

    original.setNodeSet( this.nodeSet );

    original.setSize( 4 );
    original.setPosition( 2 );

    Context dupe = original.duplicate();

    assertEquals(2, dupe.getPosition());
    assertEquals(4, dupe.getSize());
    
    assertTrue( original != dupe );

    List dupeNodeSet = dupe.getNodeSet();

    assertTrue( original.getNodeSet() != dupe.getNodeSet() );

    dupeNodeSet.clear();

    assertSame( dupeNodeSet,
                dupe.getNodeSet() );

    assertEquals( 0,
                  dupe.getNodeSet().size() );


    assertEquals( 4,
                  original.getNodeSet().size() );

    dupe.setSize( 0 );
    dupe.setPosition( 0 );

    assertEquals( 0,
                  dupe.getSize() );

    assertEquals( 0,
                  dupe.getPosition() );

    assertEquals( 4,
                  original.getSize() );

    assertEquals( 2,
                  original.getPosition() );
}