Java 类org.eclipse.xtext.nodemodel.impl.NodeModelBuilder 实例源码

protected IParseResult doParse(String ruleName, CharStream in, NodeModelBuilder nodeModelBuilder, int initialLookAhead) {
    TokenSource tokenSource = createLexer(in);
    XtextTokenStream tokenStream = createTokenStream(tokenSource);
    tokenStream.initCurrentLookAhead(initialLookAhead);
    setInitialHiddenTokens(tokenStream);
    AbstractInternalAntlrParser parser = createParser(tokenStream);
    parser.setTokenTypeMap(getTokenDefProvider().getTokenDefMap());
    parser.setSyntaxErrorProvider(getSyntaxErrorProvider());
    parser.setNodeModelBuilder(nodeModelBuilder);
    parser.setSemanticModelBuilder(getElementFactory());
    IUnorderedGroupHelper helper = getUnorderedGroupHelper().get();
    parser.setUnorderedGroupHelper(helper);
    helper.initializeWith(parser);
    try {
        if(ruleName != null)
            return parser.parse(ruleName);
        return parser.parse();
    } catch (Exception re) {
        throw new ParseException(re.getMessage(),re);
    }
}

@Before
public void setUp() throws Exception {
    nodes = new INode[NUM_NODES];
    NodeModelBuilder builder = new NodeModelBuilder();
    nodes[0] = new CompositeNode();
    nodes[1] = new CompositeNode();
    nodes[2] = new HiddenLeafNode();
    nodes[3] = new LeafNode();
    nodes[4] = new HiddenLeafNode();
    nodes[5] = new CompositeNode();
    nodes[6] = new LeafNode();
    nodes[7] = new CompositeNode();
    nodes[8] = new HiddenLeafNode();
    nodes[9] = new LeafNode();

    builder.addChild((ICompositeNode)nodes[0], (AbstractNode)nodes[1]);
    builder.addChild((ICompositeNode)nodes[0], (AbstractNode)nodes[5]);
    builder.addChild((ICompositeNode)nodes[0], (AbstractNode)nodes[7]);
    builder.addChild((ICompositeNode)nodes[0], (AbstractNode)nodes[9]);
    builder.addChild((ICompositeNode)nodes[1], (AbstractNode)nodes[2]);
    builder.addChild((ICompositeNode)nodes[1], (AbstractNode)nodes[3]);
    builder.addChild((ICompositeNode)nodes[1], (AbstractNode)nodes[4]);
    builder.addChild((ICompositeNode)nodes[5], (AbstractNode)nodes[6]);
    builder.addChild((ICompositeNode)nodes[7], (AbstractNode)nodes[8]);
}

@Test public void testNodePath() throws Exception {
    NodeModelBuilder builder = new NodeModelBuilder();
    ICompositeNode n = new CompositeNode();
    ICompositeNode n1 = new CompositeNode();
    builder.addChild(n, (AbstractNode) n1);
    ICompositeNode n2 = new CompositeNode();
    builder.addChild(n, (AbstractNode) n2);
    ILeafNode l1 = new LeafNode();
    builder.addChild(n2, (AbstractNode) l1);
    ILeafNode l2 = new LeafNode();
    builder.addChild(n2, (AbstractNode) l2);

    assertEquals(n, find(n,n));
    assertEquals(n1, find(n,n1));
    assertEquals(n2, find(n,n2));
    assertEquals(l1, find(n,l1));
    assertEquals(l2, find(n,l2));
}

@Override
public IParseResult parse(RuleCall ruleCall, Reader reader, int initialLookAhead) {
    try {
        NodeModelBuilder builder = nodeModelBuilder.get();
        builder.setForcedFirstGrammarElement(ruleCall);
        IParseResult parseResult = doParse(ruleCall.getRule().getName(), new ANTLRReaderStream(reader), builder, initialLookAhead);
        return parseResult;
    } catch (IOException e) {
        throw new WrappedException(e);
    }
}

@Before
public void setUp() throws Exception {
    NodeModelBuilder builder = new NodeModelBuilder();
    nodes = new INode[NUM_NODES];
    nodes[0] = new CompositeNode();
    nodes[1] = new LeafNode();
    nodes[2] = new CompositeNode();
    nodes[3] = new CompositeNode();
    nodes[4] = new LeafNode();
    nodes[5] = new LeafNode();
    nodes[6] = new LeafNode();
    nodes[7] = new CompositeNode();
    nodes[8] = new LeafNode();
    nodes[9] = new LeafNode();
    nodes[10]= new CompositeNode();

    builder.addChild((ICompositeNode)nodes[0], (AbstractNode)nodes[1]);
    builder.addChild((ICompositeNode)nodes[0], (AbstractNode)nodes[2]);
    builder.addChild((ICompositeNode)nodes[2], (AbstractNode)nodes[3]);
    builder.addChild((ICompositeNode)nodes[3], (AbstractNode)nodes[4]);
    builder.addChild((ICompositeNode)nodes[3], (AbstractNode)nodes[5]);
    builder.addChild((ICompositeNode)nodes[2], (AbstractNode)nodes[6]);
    builder.addChild((ICompositeNode)nodes[2], (AbstractNode)nodes[7]);
    builder.addChild((ICompositeNode)nodes[2], (AbstractNode)nodes[8]);
    builder.addChild((ICompositeNode)nodes[0], (AbstractNode)nodes[9]);
    builder.addChild((ICompositeNode)nodes[0], (AbstractNode)nodes[10]);
}

private ICompositeNode newSimpleNodeAdapter(final INode... nodes) {
    NodeModelBuilder builder = new NodeModelBuilder();
    ICompositeNode result = new CompositeNodeWithSemanticElement();
    for(INode node: nodes) {
        builder.addChild(result, (AbstractNode) node);
    }
    return result;
}

/**
 * @since 2.9
 */
public Class<? extends NodeModelBuilder> bindNodeModelBuilder() {
    return LookAheadPreservingNodeModelBuilder.class;
}

/**
 * @since 2.5
 */
protected NodeModelBuilder createNodeModelBuilder() {
    return nodeModelBuilder.get();
}

public void setNodeModelBuilder(NodeModelBuilder nodeModelBuilder) {
    this.nodeBuilder = nodeModelBuilder;
}

public NodeModelBuilder getNodeModelBuilder() {
    return nodeBuilder;
}

@Before
public void setUp() throws Exception {
    builder = new NodeModelBuilder();
}

@Before
public void setUp() throws Exception {
    this.mutator = new NodeModelBuilder();
}