org.jaxen.saxpath.SAXPathException Java Examples

public void startNameStep(int axis, String nameSpace, String localName) throws SAXPathException
{
    switch (axis)
    {
    case Axis.CHILD:
        if (isAbsolutePath)
        {
            // addAbsolute(nameSpace, localName);
            // we can always do relative stuff
            addRelative(nameSpace, localName);
        }
        else
        {
            addRelative(nameSpace, localName);
        }
        break;
    default:
        throw new UnsupportedOperationException();
    }

}
 

public void startAllNodeStep(int axis) throws SAXPathException
{
    switch (axis)
    {
    case Axis.CHILD:
        if (isAbsolutePath)
        {
            // addAbsolute(null, null);
            // We can always do relative stuff
            addRelative(null, null);
        }
        else
        {
            addRelative(null, null);
        }
        break;
    case Axis.DESCENDANT_OR_SELF:
        query.appendQuery(getArrayList(new DescendantAndSelfStructuredFieldPosition(), new DescendantAndSelfStructuredFieldPosition()));
        break;
    case Axis.SELF:
        query.appendQuery(getArrayList(new SelfAxisStructuredFieldPosition(), new SelfAxisStructuredFieldPosition()));
        break;
    default:
        throw new UnsupportedOperationException();
    }
}
 

static Query getPathQuery(String path) throws SAXPathException
{
    ApplicationContext ac = ApplicationContextHelper.getApplicationContext();
    XPathReader reader = new XPathReader();
    LuceneXPathHandler handler = new LuceneXPathHandler();
    handler.setNamespacePrefixResolver((NamespaceService) ac.getBean("namespaceService"));
    handler.setDictionaryService((DictionaryService) ac.getBean("dictionaryService"));
    reader.setXPathHandler(handler);
    reader.parse(path);
    PathQuery pathQuery = handler.getQuery();
    pathQuery.setRepeats(false);
    return pathQuery;
}
 

public void startAbsoluteLocationPath() throws SAXPathException
{
    if (!isAbsolutePath)
    {
        throw new IllegalStateException();
    }

}
 

public void endRelationalExpr(int op) throws SAXPathException
{
    switch (op)
    {
    case Operator.NO_OP:
        break;
    case Operator.GREATER_THAN:
    case Operator.GREATER_THAN_EQUALS:
    case Operator.LESS_THAN:
    case Operator.LESS_THAN_EQUALS:
        throw new UnsupportedOperationException();
    default:
        throw new UnsupportedOperationException("Unknown operation " + op);
    }
}
 

public void endUnionExpr(boolean create) throws SAXPathException
{
    if (create)
    {
        throw new UnsupportedOperationException();
    }
}
 

public void endUnaryExpr(int op) throws SAXPathException
{
    switch (op)
    {
    case Operator.NO_OP:
        break;
    case Operator.NEGATIVE:
        throw new UnsupportedOperationException();
    default:
        throw new UnsupportedOperationException("Unknown operation " + op);
    }
}
 

public void endOrExpr(boolean create) throws SAXPathException
{
    if (create)
    {
        throw new UnsupportedOperationException();
    }
}
 

public void endMultiplicativeExpr(int op) throws SAXPathException
{
    switch (op)
    {
    case Operator.NO_OP:
        break;
    case Operator.MULTIPLY:
    case Operator.DIV:
    case Operator.MOD:
        throw new UnsupportedOperationException();
    default:
        throw new UnsupportedOperationException("Unknown operation " + op);
    }
}
 

public void endEqualityExpr(int op) throws SAXPathException
{
    switch (op)
    {
    case Operator.NO_OP:
        break;
    case Operator.EQUALS:
    case Operator.NOT_EQUALS:
        throw new UnsupportedOperationException();
    default:
        throw new UnsupportedOperationException("Unknown operation " + op);
    }
}
 

public void endAndExpr(boolean create) throws SAXPathException
{
    if (create)
    {
        throw new UnsupportedOperationException();
    }
}
 

public void endAdditiveExpr(int op) throws SAXPathException
{
    switch (op)
    {
    case Operator.NO_OP:
        break;
    case Operator.ADD:
    case Operator.SUBTRACT:
        throw new UnsupportedOperationException();
    default:
        throw new UnsupportedOperationException("Unknown operation " + op);
    }
}
 

/**
 * @param args String[]
 * @throws SAXPathException
 */
public static void main(String[] args) throws SAXPathException
{
    XPathReader reader = new XPathReader();
    reader.setXPathHandler(new DebugXPathHandler());
    reader
            .parse("/ns:one[@woof='dog']/two/./../two[functionTest(@a, @b, $woof:woof)]/three/*/four//*/five/six[@exists1 and @exists2]");
}
 

public void startAdditiveExpr() throws SAXPathException
{
    // Do nothing at the moment
}
 

public void startUnaryExpr() throws SAXPathException
{
    // Do nothing for now
}
 

public void endFilterExpr() throws SAXPathException
{
    // TODO Auto-generated method stub
    throw new UnsupportedOperationException();
}
 

public void endXPath() throws SAXPathException
{
    // Do nothing at the moment
}
 

public void startEqualityExpr() throws SAXPathException
{
    // Do nothing
}
 

public void endCommentNodeStep() throws SAXPathException
{
    // TODO Auto-generated method stub
    throw new UnsupportedOperationException();
}
 

public void startRelationalExpr() throws SAXPathException
{
    // Do nothing at the moment
}
 

public void endAllNodeStep() throws SAXPathException
{
    // Nothing to do
    // Todo: Predicates
}
 

public void startFunction(String arg0, String arg1) throws SAXPathException
{
    // TODO Auto-generated method stub
    throw new UnsupportedOperationException();
}
 

public void endAbsoluteLocationPath() throws SAXPathException
{
    // No action
}
 

public void startMultiplicativeExpr() throws SAXPathException
{
    // Do nothing at the moment
}
 

public void variableReference(String arg0, String arg1) throws SAXPathException
{
    System.out.println("Variable Reference arg0 = < " + arg0 + " > arg1 = < " + arg1);
}
 

public void startXPath() throws SAXPathException
{
    System.out.println("Start XPath");
}
 

public void startUnionExpr() throws SAXPathException
{
    System.out.println("Start Union Expression");
}
 

public void startUnaryExpr() throws SAXPathException
{
    System.out.println("Start Unary Expression");
}
 

public void startPathExpr() throws SAXPathException
{
    // Just need one!
}
 

public void startTextNodeStep(int arg0) throws SAXPathException
{
    // TODO Auto-generated method stub
    throw new UnsupportedOperationException();
}