public <E, T> Iterable<E> getChildren(Production<E, T> production, E element) { Iterable<E> result; if ((result = production.getSequentialChildren(element)) != null) return result; if ((result = production.getAlternativeChildren(element)) != null) return result; if ((result = production.getUnorderedChildren(element)) != null) return result; return null; }
@Override public T apply(E from) { return production.getToken(from); }
protected String getCardinality(Production<ELEMENT, TOKEN> adapter, ELEMENT ele) { return adapter.isMany(ele) ? adapter.isOptional(ele) ? "*" : "+" : adapter.isOptional(ele) ? "?" : null; }
public <S, D, T> D clone(Production<S, T> production, S ele, ProductionFactory<D, T> factory) { boolean many = production.isMany(ele); boolean optional = production.isOptional(ele); T token = production.getToken(ele); if (token != null) return factory.createForToken(many, optional, token); Iterable<S> alternative = production.getAlternativeChildren(ele); if (alternative != null) return factory.createForAlternativeChildren(many, optional, clone(production, alternative, factory)); Iterable<S> group = production.getSequentialChildren(ele); if (group != null) return factory.createForSequentialChildren(many, optional, clone(production, group, factory)); Iterable<S> unorderedgroup = production.getUnorderedChildren(ele); if (unorderedgroup != null) return factory.createForUnordertedChildren(many, optional, clone(production, unorderedgroup, factory)); return factory.createForToken(many, optional, null); }
public String format(Production<ELEMENT, TOKEN> adapter, ELEMENT grammarElement, boolean needParenthesis) { TOKEN token = adapter.getToken(grammarElement); if (token != null) { String cardinality = getCardinality(adapter, grammarElement); if (cardinality == null) return tokenToString.apply(token); return tokenToString.apply(token) + cardinality; } Iterable<ELEMENT> alternative = adapter.getAlternativeChildren(grammarElement); if (alternative != null) return format(adapter, grammarElement, alternative, " | ", false, needParenthesis, 5); Iterable<ELEMENT> group = adapter.getSequentialChildren(grammarElement); if (group != null) return format(adapter, grammarElement, group, " ", false, needParenthesis, 5); Iterable<ELEMENT> ungroup = adapter.getUnorderedChildren(grammarElement); if (ungroup != null) return format(adapter, grammarElement, ungroup, " & ", false, needParenthesis, 5); return "<unknown>"; }
protected void collectChildren(E element, Set<E> result, Set<E> visited) { Iterable<E> children; if ((children = production.getSequentialChildren(element)) != null) collectChildrenSequence(element, children, result, visited); else if ((children = production.getAlternativeChildren(element)) != null) collectChildrenAlternative(element, children, result, visited); else if ((children = production.getUnorderedChildren(element)) != null) switch (unorderedStrategy) { case SEQUENCE: collectChildrenSequence(element, children, result, visited); break; case MULIT_ALTERNATIVE: collectChildrenUnorderedAlt(element, children, result, visited); break; } else { if (production.isMany(element) /* && filter(element) */) collectElement(element, result, visited); collectByParent(element, result, visited); } }
protected void collectByParent(E element, Set<E> result, Set<E> visited) { E container = production.getParent(element); Iterable<E> children; if (container == null) result.add(null); else if ((children = production.getSequentialChildren(container)) != null) collectByParentSequence(element, container, children, result, visited); else if ((children = production.getUnorderedChildren(container)) != null) switch (unorderedStrategy) { case SEQUENCE: collectByParentSequence(element, container, children, result, visited); break; case MULIT_ALTERNATIVE: collectElement(container, result, visited); collectByParent(container, result, visited); break; } else { if (production.isMany(container)) collectElement(container, result, visited); collectByParent(container, result, visited); } }
public String format(Production<ELEMENT, TOKEN> adapter) { return format(adapter, adapter.getRoot()); }
public Iterable<E> getStarts(E root) { if (root == null) throw new NullPointerException(); Set<E> outgoing = Sets.newLinkedHashSet(); if (filter(root)) { outgoing.add(root); if (production.isOptional(root)) outgoing.add(null); } else collectChildren(root, outgoing, Sets.<E> newHashSet()); return outgoing; }
public <S, D, T> D clone(Production<S, T> production, S ele, ProductionFactory<D, T> factory) { boolean many = production.isMany(ele); boolean optional = production.isOptional(ele); T token = production.getToken(ele); if (token != null) return factory.createForToken(many, optional, token); Iterable<S> alternative = production.getAlternativeChildren(ele); if (alternative != null) return factory.createForAlternativeChildren(many, optional, clone(production, alternative, factory)); Iterable<S> group = production.getSequentialChildren(ele); if (group != null) return factory.createForSequentialChildren(many, optional, clone(production, group, factory)); Iterable<S> unorderedgroup = production.getUnorderedChildren(ele); if (unorderedgroup != null) return factory.createForUnordertedChildren(many, optional, clone(production, unorderedgroup, factory)); return factory.createForToken(many, optional, null); }
public String format(Production<ELEMENT, TOKEN> adapter, ELEMENT grammarElement, boolean needParenthesis) { TOKEN token = adapter.getToken(grammarElement); if (token != null) { String cardinality = getCardinality(adapter, grammarElement); if (cardinality == null) return tokenToString.apply(token); return tokenToString.apply(token) + cardinality; } Iterable<ELEMENT> alternative = adapter.getAlternativeChildren(grammarElement); if (alternative != null) return format(adapter, grammarElement, alternative, " | ", false, needParenthesis); Iterable<ELEMENT> group = adapter.getSequentialChildren(grammarElement); if (group != null) return format(adapter, grammarElement, group, " ", false, needParenthesis); Iterable<ELEMENT> ungroup = adapter.getUnorderedChildren(grammarElement); if (ungroup != null) return format(adapter, grammarElement, ungroup, " & ", false, needParenthesis); return "<unknown>"; }
protected void collectChildren(E element, Set<E> result, Set<E> visited) { Iterable<E> children; if ((children = production.getSequentialChildren(element)) != null) collectChildrenSequence(element, children, result, visited); else if ((children = production.getAlternativeChildren(element)) != null) collectChildrenAlternative(element, children, result, visited); else if ((children = production.getUnorderedChildren(element)) != null) switch (unorderedStrategy) { case SEQUENCE: collectChildrenSequence(element, children, result, visited); break; case MULIT_ALTERNATIVE: collectChildrenUnorderedAlt(element, children, result, visited); break; } else { if (production.isMany(element) /* && filter(element) */) collectElement(element, result, visited); collectByParent(element, result, visited); } }
protected void collectByParent(E element, Set<E> result, Set<E> visited) { E container = production.getParent(element); Iterable<E> children; if (container == null) result.add(null); else if ((children = production.getSequentialChildren(container)) != null) collectByParentSequence(element, container, children, result, visited); else if ((children = production.getUnorderedChildren(container)) != null) switch (unorderedStrategy) { case SEQUENCE: collectByParentSequence(element, container, children, result, visited); break; case MULIT_ALTERNATIVE: collectElement(container, result, visited); collectByParent(container, result, visited); break; } else { if (production.isMany(container)) collectElement(container, result, visited); collectByParent(container, result, visited); } }
protected String getCardinality(Production<ELEMENT, TOKEN> adapter, ELEMENT ele) { return adapter.isMany(ele) ? adapter.isOptional(ele) ? "*" : "+" : adapter.isOptional(ele) ? "?" : null; }
public <E, T> E findByToken(final Production<E, T> production, final Predicate<T> matches) { return findByToken(production, production.getRoot(), matches); }
@Override public Iterable<E> getStarts(E root) { if (root == null) throw new NullPointerException(); Set<E> outgoing = Sets.newLinkedHashSet(); if (filter(root)) { outgoing.add(root); if (production.isOptional(root)) outgoing.add(null); } else collectChildren(root, outgoing, Sets.<E> newHashSet()); return outgoing; }
public <E, T> Iterable<E> getChildren(Production<E, T> production, E element) { Iterable<E> result; if ((result = production.getSequentialChildren(element)) != null) return result; if ((result = production.getAlternativeChildren(element)) != null) return result; if ((result = production.getUnorderedChildren(element)) != null) return result; return null; }
protected void collectByParentSequence(E element, E container, Iterable<E> children, Set<E> result, Set<E> visited) { List<E> sequentialChildren = orderedList(children); int i = sequentialChildren.indexOf(element) + 1; while (i < sequentialChildren.size()) { E next = sequentialChildren.get(i); collectElement(next, result, visited); if (production.isOptional(next)) i++; else break; } if (i >= sequentialChildren.size()) { if (production.isMany(container)) collectElement(container, result, visited); collectByParent(container, result, visited); } }
public <E, T> E findByToken(final Production<E, T> production, final Predicate<T> matches) { return findByToken(production, production.getRoot(), matches); }