Java ValueStack类代码示例

import org.parboiled.support.ValueStack; //导入依赖的package包/类
@Override
public boolean run(Context<CfgElement> context) {
    final ValueStack<CfgElement> stack = context.getValueStack();
    if (!context.hasError()) {
        int size = stack.size();
        switch (size) {
            case 1:
                CfgElement elemKey = stack.pop();
                parsedProps.setProperty(unescape(elemKey.getText()), "");
                cfgFile.getElements().add(new PairElement(elemKey));
                break;
            case 2:
                // NOTE: stack popping order below is important!
                final CfgElement elemValue = stack.pop();
                elemKey = stack.pop();
                parsedProps.setProperty(unescape(elemKey.getText()), unescape(elemValue.getText()));
                cfgFile.getElements().add(new PairElement(elemKey, elemValue));
                break;
            default:
                throw new IllegalStateException(String.format("Cannot manage %d values on the parsing stack", size));
        }
    } else {
        stack.clear();
    }
    return true;
}
 

import org.parboiled.support.ValueStack; //导入依赖的package包/类
public static List<Node> parse(String query, ParserConfig config) {
    QueryParser expressionParser = Parboiled.createParser(QueryParser.class, config);
    ValueStack<Object> nodes = parse(query, expressionParser.Query());
    List<Node> nodeList = new LinkedList<>();

    for (Object node : nodes) {
        if (node instanceof Node) {
            nodeList.add((Node) node);
        }
    }
    return nodeList;
}
 

import org.parboiled.support.ValueStack; //导入依赖的package包/类
private void testOrderOperation(String query, List<OrderNode.OrderSpecifier> expected) {
    QueryParser expressionParser = Parboiled.createParser(QueryParser.class);

    ValueStack<Object> nodes = ExpressionParserUtils.parse(query, expressionParser.Query());
    for (Object node : nodes) {
        if (node instanceof OrderNode) {
            assertOrders((OrderNode) node, expected);
            return;
        }
    }
    Assert.fail("Order node not found");
}
 

import org.parboiled.support.ValueStack; //导入依赖的package包/类
public static ValueStack<Object> parse(String expression, Rule ruleTree) {
    ReportingParseRunner<Object> runner = new ReportingParseRunner<>(ruleTree);
    ParsingResult<Object> result = runner.run(expression);

    if (!result.matched || result.hasErrors()) {
        throw new IllegalArgumentException("Invalid query: " + printParseErrors(result));
    }

    return result.valueStack;
}
 

import org.parboiled.support.ValueStack; //导入依赖的package包/类
private void testProjectionOperation(String query, List<String> expected) {
    QueryParser expressionParser = Parboiled.createParser(QueryParser.class);

    ValueStack<Object> nodes = ExpressionParserUtils.parse(query, expressionParser.Query());
    for (Object node : nodes) {
        if (node instanceof ProjectionNode) {
            assertProjections((ProjectionNode) node, expected);
            return;
        }
    }
    Assert.fail("Projection node not found");
}
 

import org.parboiled.support.ValueStack; //导入依赖的package包/类
@Test
public void sequence() {
    DomainParserGrammar.DomainGrammar parser = Parboiled.createParser(DomainParserGrammar.DomainGrammar.class);
    ReportingParseRunner<?> runner = new ReportingParseRunner(parser.Domain());
    ParsingResult<?> result = runner.run("R(-1.0:2.0),R(1.0:2.0)");

    ValueStack<Real> s = (ValueStack<Real>) result.valueStack;

    Assert.assertThat(s.size(), equalTo(2));
    Assert.assertThat(s.peek().getBounds().getLowerBound(), equalTo(1.0));
    s.pop();
    Assert.assertThat(s.peek().getBounds().getLowerBound(), equalTo(-1.0));
}
 

import org.parboiled.support.ValueStack; //导入依赖的package包/类
@Test
public void boundless() {
    DomainParserGrammar.DomainGrammar parser = Parboiled.createParser(DomainParserGrammar.DomainGrammar.class);
    ReportingParseRunner<?> runner = new ReportingParseRunner(parser.Domain());
    ParsingResult<?> result = runner.run("Z");

    ValueStack<?> s = result.valueStack;

    Assert.assertThat(s.size(), equalTo(1));
}
 

import org.parboiled.support.ValueStack; //导入依赖的package包/类
public static void linkNodes(ValueStack<AstNode> stack) {
    AstNode prev = null;
    while (!stack.isEmpty()) {
        AstNode node = stack.pop();
        if (prev != null) {
            AstNode parent = prev;
            while (!(node.getStartIndex() <= parent.getEndIndex()
                    && node.getStartIndex() >= parent.getStartIndex())) {
                parent = parent.getParent();
            }
            //System.out.println("Tying "+node+" to parent: "+parent);
            int index = -1;
            List<AstNode> children = parent.getChildren();
            if( ! children.isEmpty())
            {
                for(int i=0; i!=children.size(); i++)
                {
                    if(node.getStartIndex() > children.get(i).getStartIndex())
                    {
                        index = i;
                        break;
                    }
                }
            }
            parent.addChildAt(node, index+1);
            node.setParent(parent);
        }
        prev = node;
    }

}
 

import org.parboiled.support.ValueStack; //导入依赖的package包/类
private void testQuery(String query,
                       List<String> projections,
                       Object filterValue,
                       List<OrderNode.OrderSpecifier> orders,
                       LimitNode limit) {

    QueryParser expressionParser = Parboiled.createParser(QueryParser.class);
    ValueStack<Object> nodes = ExpressionParserUtils.parse(query, expressionParser.Query());

    boolean projectionTestOk = false;
    boolean filterTestOk = false;
    boolean orderTestOk = false;
    boolean limitTestOk = false;

    for (Object node : nodes) {
        if (node instanceof ProjectionNode) {
            if (projections == null || projections.isEmpty()) {
                Assert.fail("Projection selectors was not expected");
            }
            ProjectionOperationTest.assertProjections((ProjectionNode) node, projections);
            projectionTestOk = true;
            continue;
        }
        if (node instanceof LimitNode) {
            if (limit == null) {
                Assert.fail("Limit node was not expected");
            }
            Assert.assertEquals(limit, node);
            limitTestOk = true;
            continue;
        }
        if (node instanceof OrderNode) {
            if (orders == null || orders.isEmpty()) {
                Assert.fail("Order node was not expected");
            }
            OrderOperationTest.assertOrders((OrderNode) node, orders);
            orderTestOk = true;
            continue;
        }
        if (node instanceof FilterNode) {
            if (filterValue == null) {
                Assert.fail("Filter node was not expected");
            }
            Assert.assertEquals(filterValue, ((FilterNode) node).getArgs().get(0));
            filterTestOk = true;
            continue;
        }
        Assert.fail("Node type " + node.getClass() + " was not expected");
    }

    if (!projectionTestOk && projections != null) {
        Assert.fail("Projection node was not found");
    }
    if (!filterTestOk && filterValue != null) {
        Assert.fail("Filter node was not found");
    }
    if (!limitTestOk && limit != null) {
        Assert.fail("Limit node was not found");
    }
    if (!orderTestOk && orders != null) {
        Assert.fail("Order node was not found");
    }
}
 

import org.parboiled.support.ValueStack; //导入依赖的package包/类
public ParseRunner<V>withValueStack(ValueStack<V> valueStack) {
    this.valueStack = checkArgNotNull(valueStack, "valueStack");
    this.initialValueStackSnapshot = valueStack.takeSnapshot();
    return this;
}
 

import org.parboiled.support.ValueStack; //导入依赖的package包/类
public ValueStack<V> getValueStack() {
    if (valueStack == null) {
        withValueStack(new DefaultValueStack<V>());
    }
    return valueStack;
}
 

import org.parboiled.support.ValueStack; //导入依赖的package包/类
/**
 * Returns the value stack instance used during this parsing run.
 *
 * @return the value stack
 */
ValueStack<V> getValueStack();
 

import org.parboiled.support.ValueStack; //导入依赖的package包/类
/**
 * Initializes the parse runner with the given ValueStack instance.
 *
 * @param valueStack the ValueStack to use
 * @return this instance
 */
ParseRunner<V> withValueStack(ValueStack<V> valueStack);