Package de.monticore.grammar.grammar._ast

Class ASTMCGrammar

java.lang.Object
de.monticore.ast.ASTCNode
de.monticore.grammar.grammar._ast.ASTMCGrammar
All Implemented Interfaces:
de.monticore.ast.ASTNode, ASTGrammarNode, Cloneable
public class ASTMCGrammar extends de.monticore.ast.ASTCNode implements ASTGrammarNode

  • Field Details

  • Constructor Details

    • ASTMCGrammar

      protected ASTMCGrammar()

  • Method Details

    • deepEquals

      public boolean deepEquals(Object o)
      Specified by:
      deepEquals in interface de.monticore.ast.ASTNode

    • deepEquals

      public boolean deepEquals(Object o, boolean forceSameOrder)
      Specified by:
      deepEquals in interface de.monticore.ast.ASTNode

    • deepEqualsWithComments

      public boolean deepEqualsWithComments(Object o)
      Specified by:
      deepEqualsWithComments in interface de.monticore.ast.ASTNode

    • deepEqualsWithComments

      public boolean deepEqualsWithComments(Object o, boolean forceSameOrder)
      Specified by:
      deepEqualsWithComments in interface de.monticore.ast.ASTNode

    • equalAttributes

      public boolean equalAttributes(Object o)
      Specified by:
      equalAttributes in interface de.monticore.ast.ASTNode

    • equalsWithComments

      public boolean equalsWithComments(Object o)
      Specified by:
      equalsWithComments in interface de.monticore.ast.ASTNode

    • deepClone

      public ASTMCGrammar deepClone()
      Specified by:
      deepClone in interface de.monticore.ast.ASTNode
      Specified by:
      deepClone in class de.monticore.ast.ASTCNode

    • deepClone

      public ASTMCGrammar deepClone(ASTMCGrammar result)

    • getGrammarOption

      public ASTGrammarOption getGrammarOption()

    • isPresentGrammarOption

      public boolean isPresentGrammarOption()

    • getStartRule

      public ASTStartRule getStartRule()

    • isPresentStartRule

      public boolean isPresentStartRule()

    • getScopeRule

      public ASTScopeRule getScopeRule()

    • isPresentScopeRule

      public boolean isPresentScopeRule()

    • containsPackage

      public boolean containsPackage(Object element)

    • containsAllPackage

      public boolean containsAllPackage(Collection<?> collection)

    • isEmptyPackage

      public boolean isEmptyPackage()

    • iteratorPackage

      public Iterator<String> iteratorPackage()

    • sizePackage

      public int sizePackage()

    • toArrayPackage

      public String[] toArrayPackage(String[] array)

    • toArrayPackage

      public Object[] toArrayPackage()

    • spliteratorPackage

      public Spliterator<String> spliteratorPackage()

    • streamPackage

      public Stream<String> streamPackage()

    • parallelStreamPackage

      public Stream<String> parallelStreamPackage()

    • getPackage

      public String getPackage(int index)

    • indexOfPackage

      public int indexOfPackage(Object element)

    • lastIndexOfPackage

      public int lastIndexOfPackage(Object element)

    • equalsPackage

      public boolean equalsPackage(Object o)

    • hashCodePackage

      public int hashCodePackage()

    • listIteratorPackage

      public ListIterator<String> listIteratorPackage()

    • listIteratorPackage

      public ListIterator<String> listIteratorPackage(int index)

    • subListPackage

      public List<String> subListPackage(int start, int end)

    • getPackageList

      public List<String> getPackageList()

    • containsImportStatement

      public boolean containsImportStatement(Object element)

    • containsAllImportStatement

      public boolean containsAllImportStatement(Collection<?> collection)

    • isEmptyImportStatement

      public boolean isEmptyImportStatement()

    • iteratorImportStatement

      public Iterator<ASTMCImportStatement> iteratorImportStatement()

    • sizeImportStatement

      public int sizeImportStatement()

    • toArrayImportStatement

      public ASTMCImportStatement[] toArrayImportStatement(ASTMCImportStatement[] array)

    • toArrayImportStatement

      public Object[] toArrayImportStatement()

    • spliteratorImportStatement

      public Spliterator<ASTMCImportStatement> spliteratorImportStatement()

    • streamImportStatement

      public Stream<ASTMCImportStatement> streamImportStatement()

    • parallelStreamImportStatement

      public Stream<ASTMCImportStatement> parallelStreamImportStatement()

    • getImportStatement

      public ASTMCImportStatement getImportStatement(int index)

    • indexOfImportStatement

      public int indexOfImportStatement(Object element)

    • lastIndexOfImportStatement

      public int lastIndexOfImportStatement(Object element)

    • equalsImportStatement

      public boolean equalsImportStatement(Object o)

    • hashCodeImportStatement

      public int hashCodeImportStatement()

    • listIteratorImportStatement

      public ListIterator<ASTMCImportStatement> listIteratorImportStatement()

    • listIteratorImportStatement

      public ListIterator<ASTMCImportStatement> listIteratorImportStatement(int index)

    • subListImportStatement

      public List<ASTMCImportStatement> subListImportStatement(int start, int end)

    • getImportStatementList

      public List<ASTMCImportStatement> getImportStatementList()

    • getGrammarAnnotation

      public ASTGrammarAnnotation getGrammarAnnotation()

    • isPresentGrammarAnnotation

      public boolean isPresentGrammarAnnotation()

    • getName

      public String getName()

    • containsSupergrammar

      public boolean containsSupergrammar(Object element)

    • containsAllSupergrammar

      public boolean containsAllSupergrammar(Collection<?> collection)

    • isEmptySupergrammar

      public boolean isEmptySupergrammar()

    • iteratorSupergrammar

      public Iterator<ASTGrammarReference> iteratorSupergrammar()

    • sizeSupergrammar

      public int sizeSupergrammar()

    • toArraySupergrammar

      public ASTGrammarReference[] toArraySupergrammar(ASTGrammarReference[] array)

    • toArraySupergrammar

      public Object[] toArraySupergrammar()

    • spliteratorSupergrammar

      public Spliterator<ASTGrammarReference> spliteratorSupergrammar()

    • streamSupergrammar

      public Stream<ASTGrammarReference> streamSupergrammar()

    • parallelStreamSupergrammar

      public Stream<ASTGrammarReference> parallelStreamSupergrammar()

    • getSupergrammar

      public ASTGrammarReference getSupergrammar(int index)

    • indexOfSupergrammar

      public int indexOfSupergrammar(Object element)

    • lastIndexOfSupergrammar

      public int lastIndexOfSupergrammar(Object element)

    • equalsSupergrammar

      public boolean equalsSupergrammar(Object o)

    • hashCodeSupergrammar

      public int hashCodeSupergrammar()

    • listIteratorSupergrammar

      public ListIterator<ASTGrammarReference> listIteratorSupergrammar()

    • listIteratorSupergrammar

      public ListIterator<ASTGrammarReference> listIteratorSupergrammar(int index)

    • subListSupergrammar

      public List<ASTGrammarReference> subListSupergrammar(int start, int end)

    • getSupergrammarList

      public List<ASTGrammarReference> getSupergrammarList()

    • containsLexProd

      public boolean containsLexProd(Object element)

    • containsAllLexProds

      public boolean containsAllLexProds(Collection<?> collection)

    • isEmptyLexProds

      public boolean isEmptyLexProds()

    • iteratorLexProds

      public Iterator<ASTLexProd> iteratorLexProds()

    • sizeLexProds

      public int sizeLexProds()

    • toArrayLexProds

      public ASTLexProd[] toArrayLexProds(ASTLexProd[] array)

    • toArrayLexProds

      public Object[] toArrayLexProds()

    • spliteratorLexProds

      public Spliterator<ASTLexProd> spliteratorLexProds()

    • streamLexProds

      public Stream<ASTLexProd> streamLexProds()

    • parallelStreamLexProds

      public Stream<ASTLexProd> parallelStreamLexProds()

    • getLexProd

      public ASTLexProd getLexProd(int index)

    • indexOfLexProd

      public int indexOfLexProd(Object element)

    • lastIndexOfLexProd

      public int lastIndexOfLexProd(Object element)

    • equalsLexProds

      public boolean equalsLexProds(Object o)

    • hashCodeLexProds

      public int hashCodeLexProds()

    • listIteratorLexProds

      public ListIterator<ASTLexProd> listIteratorLexProds()

    • listIteratorLexProds

      public ListIterator<ASTLexProd> listIteratorLexProds(int index)

    • subListLexProds

      public List<ASTLexProd> subListLexProds(int start, int end)

    • getLexProdList

      public List<ASTLexProd> getLexProdList()

    • containsClassProd

      public boolean containsClassProd(Object element)

    • containsAllClassProds

      public boolean containsAllClassProds(Collection<?> collection)

    • isEmptyClassProds

      public boolean isEmptyClassProds()

    • iteratorClassProds

      public Iterator<ASTClassProd> iteratorClassProds()

    • sizeClassProds

      public int sizeClassProds()

    • toArrayClassProds

      public ASTClassProd[] toArrayClassProds(ASTClassProd[] array)

    • toArrayClassProds

      public Object[] toArrayClassProds()

    • spliteratorClassProds

      public Spliterator<ASTClassProd> spliteratorClassProds()

    • streamClassProds

      public Stream<ASTClassProd> streamClassProds()

    • parallelStreamClassProds

      public Stream<ASTClassProd> parallelStreamClassProds()

    • getClassProd

      public ASTClassProd getClassProd(int index)

    • indexOfClassProd

      public int indexOfClassProd(Object element)

    • lastIndexOfClassProd

      public int lastIndexOfClassProd(Object element)

    • equalsClassProds

      public boolean equalsClassProds(Object o)

    • hashCodeClassProds

      public int hashCodeClassProds()

    • listIteratorClassProds

      public ListIterator<ASTClassProd> listIteratorClassProds()

    • listIteratorClassProds

      public ListIterator<ASTClassProd> listIteratorClassProds(int index)

    • subListClassProds

      public List<ASTClassProd> subListClassProds(int start, int end)

    • getClassProdList

      public List<ASTClassProd> getClassProdList()

    • containsEnumProd

      public boolean containsEnumProd(Object element)

    • containsAllEnumProds

      public boolean containsAllEnumProds(Collection<?> collection)

    • isEmptyEnumProds

      public boolean isEmptyEnumProds()

    • iteratorEnumProds

      public Iterator<ASTEnumProd> iteratorEnumProds()

    • sizeEnumProds

      public int sizeEnumProds()

    • toArrayEnumProds

      public ASTEnumProd[] toArrayEnumProds(ASTEnumProd[] array)

    • toArrayEnumProds

      public Object[] toArrayEnumProds()

    • spliteratorEnumProds

      public Spliterator<ASTEnumProd> spliteratorEnumProds()

    • streamEnumProds

      public Stream<ASTEnumProd> streamEnumProds()

    • parallelStreamEnumProds

      public Stream<ASTEnumProd> parallelStreamEnumProds()

    • getEnumProd

      public ASTEnumProd getEnumProd(int index)

    • indexOfEnumProd

      public int indexOfEnumProd(Object element)

    • lastIndexOfEnumProd

      public int lastIndexOfEnumProd(Object element)

    • equalsEnumProds

      public boolean equalsEnumProds(Object o)

    • hashCodeEnumProds

      public int hashCodeEnumProds()

    • listIteratorEnumProds

      public ListIterator<ASTEnumProd> listIteratorEnumProds()

    • listIteratorEnumProds

      public ListIterator<ASTEnumProd> listIteratorEnumProds(int index)

    • subListEnumProds

      public List<ASTEnumProd> subListEnumProds(int start, int end)

    • getEnumProdList

      public List<ASTEnumProd> getEnumProdList()

    • containsExternalProd

      public boolean containsExternalProd(Object element)

    • containsAllExternalProds

      public boolean containsAllExternalProds(Collection<?> collection)

    • isEmptyExternalProds

      public boolean isEmptyExternalProds()

    • iteratorExternalProds

      public Iterator<ASTExternalProd> iteratorExternalProds()

    • sizeExternalProds

      public int sizeExternalProds()

    • toArrayExternalProds

      public ASTExternalProd[] toArrayExternalProds(ASTExternalProd[] array)

    • toArrayExternalProds

      public Object[] toArrayExternalProds()

    • spliteratorExternalProds

      public Spliterator<ASTExternalProd> spliteratorExternalProds()

    • streamExternalProds

      public Stream<ASTExternalProd> streamExternalProds()

    • parallelStreamExternalProds

      public Stream<ASTExternalProd> parallelStreamExternalProds()

    • getExternalProd

      public ASTExternalProd getExternalProd(int index)

    • indexOfExternalProd

      public int indexOfExternalProd(Object element)

    • lastIndexOfExternalProd

      public int lastIndexOfExternalProd(Object element)

    • equalsExternalProds

      public boolean equalsExternalProds(Object o)

    • hashCodeExternalProds

      public int hashCodeExternalProds()

    • listIteratorExternalProds

      public ListIterator<ASTExternalProd> listIteratorExternalProds()

    • listIteratorExternalProds

      public ListIterator<ASTExternalProd> listIteratorExternalProds(int index)

    • subListExternalProds

      public List<ASTExternalProd> subListExternalProds(int start, int end)

    • getExternalProdList

      public List<ASTExternalProd> getExternalProdList()

    • containsInterfaceProd

      public boolean containsInterfaceProd(Object element)

    • containsAllInterfaceProds

      public boolean containsAllInterfaceProds(Collection<?> collection)

    • isEmptyInterfaceProds

      public boolean isEmptyInterfaceProds()

    • iteratorInterfaceProds

      public Iterator<ASTInterfaceProd> iteratorInterfaceProds()

    • sizeInterfaceProds

      public int sizeInterfaceProds()

    • toArrayInterfaceProds

      public ASTInterfaceProd[] toArrayInterfaceProds(ASTInterfaceProd[] array)

    • toArrayInterfaceProds

      public Object[] toArrayInterfaceProds()

    • spliteratorInterfaceProds

      public Spliterator<ASTInterfaceProd> spliteratorInterfaceProds()

    • streamInterfaceProds

      public Stream<ASTInterfaceProd> streamInterfaceProds()

    • parallelStreamInterfaceProds

      public Stream<ASTInterfaceProd> parallelStreamInterfaceProds()

    • getInterfaceProd

      public ASTInterfaceProd getInterfaceProd(int index)

    • indexOfInterfaceProd

      public int indexOfInterfaceProd(Object element)

    • lastIndexOfInterfaceProd

      public int lastIndexOfInterfaceProd(Object element)

    • equalsInterfaceProds

      public boolean equalsInterfaceProds(Object o)

    • hashCodeInterfaceProds

      public int hashCodeInterfaceProds()

    • listIteratorInterfaceProds

      public ListIterator<ASTInterfaceProd> listIteratorInterfaceProds()

    • listIteratorInterfaceProds

      public ListIterator<ASTInterfaceProd> listIteratorInterfaceProds(int index)

    • subListInterfaceProds

      public List<ASTInterfaceProd> subListInterfaceProds(int start, int end)

    • getInterfaceProdList

      public List<ASTInterfaceProd> getInterfaceProdList()

    • containsAbstractProd

      public boolean containsAbstractProd(Object element)

    • containsAllAbstractProds

      public boolean containsAllAbstractProds(Collection<?> collection)

    • isEmptyAbstractProds

      public boolean isEmptyAbstractProds()

    • iteratorAbstractProds

      public Iterator<ASTAbstractProd> iteratorAbstractProds()

    • sizeAbstractProds

      public int sizeAbstractProds()

    • toArrayAbstractProds

      public ASTAbstractProd[] toArrayAbstractProds(ASTAbstractProd[] array)

    • toArrayAbstractProds

      public Object[] toArrayAbstractProds()

    • spliteratorAbstractProds

      public Spliterator<ASTAbstractProd> spliteratorAbstractProds()

    • streamAbstractProds

      public Stream<ASTAbstractProd> streamAbstractProds()

    • parallelStreamAbstractProds

      public Stream<ASTAbstractProd> parallelStreamAbstractProds()

    • getAbstractProd

      public ASTAbstractProd getAbstractProd(int index)

    • indexOfAbstractProd

      public int indexOfAbstractProd(Object element)

    • lastIndexOfAbstractProd

      public int lastIndexOfAbstractProd(Object element)

    • equalsAbstractProds

      public boolean equalsAbstractProds(Object o)

    • hashCodeAbstractProds

      public int hashCodeAbstractProds()

    • listIteratorAbstractProds

      public ListIterator<ASTAbstractProd> listIteratorAbstractProds()

    • listIteratorAbstractProds

      public ListIterator<ASTAbstractProd> listIteratorAbstractProds(int index)

    • subListAbstractProds

      public List<ASTAbstractProd> subListAbstractProds(int start, int end)

    • getAbstractProdList

      public List<ASTAbstractProd> getAbstractProdList()

    • containsASTRule

      public boolean containsASTRule(Object element)

    • containsAllASTRules

      public boolean containsAllASTRules(Collection<?> collection)

    • isEmptyASTRules

      public boolean isEmptyASTRules()

    • iteratorASTRules

      public Iterator<ASTASTRule> iteratorASTRules()

    • sizeASTRules

      public int sizeASTRules()

    • toArrayASTRules

      public ASTASTRule[] toArrayASTRules(ASTASTRule[] array)

    • toArrayASTRules

      public Object[] toArrayASTRules()

    • spliteratorASTRules

      public Spliterator<ASTASTRule> spliteratorASTRules()

    • streamASTRules

      public Stream<ASTASTRule> streamASTRules()

    • parallelStreamASTRules

      public Stream<ASTASTRule> parallelStreamASTRules()

    • getASTRule

      public ASTASTRule getASTRule(int index)

    • indexOfASTRule

      public int indexOfASTRule(Object element)

    • lastIndexOfASTRule

      public int lastIndexOfASTRule(Object element)

    • equalsASTRules

      public boolean equalsASTRules(Object o)

    • hashCodeASTRules

      public int hashCodeASTRules()

    • listIteratorASTRules

      public ListIterator<ASTASTRule> listIteratorASTRules()

    • listIteratorASTRules

      public ListIterator<ASTASTRule> listIteratorASTRules(int index)

    • subListASTRules

      public List<ASTASTRule> subListASTRules(int start, int end)

    • getASTRuleList

      public List<ASTASTRule> getASTRuleList()

    • containsSymbolRule

      public boolean containsSymbolRule(Object element)

    • containsAllSymbolRules

      public boolean containsAllSymbolRules(Collection<?> collection)

    • isEmptySymbolRules

      public boolean isEmptySymbolRules()

    • iteratorSymbolRules

      public Iterator<ASTSymbolRule> iteratorSymbolRules()

    • sizeSymbolRules

      public int sizeSymbolRules()

    • toArraySymbolRules

      public ASTSymbolRule[] toArraySymbolRules(ASTSymbolRule[] array)

    • toArraySymbolRules

      public Object[] toArraySymbolRules()

    • spliteratorSymbolRules

      public Spliterator<ASTSymbolRule> spliteratorSymbolRules()

    • streamSymbolRules

      public Stream<ASTSymbolRule> streamSymbolRules()

    • parallelStreamSymbolRules

      public Stream<ASTSymbolRule> parallelStreamSymbolRules()

    • getSymbolRule

      public ASTSymbolRule getSymbolRule(int index)

    • indexOfSymbolRule

      public int indexOfSymbolRule(Object element)

    • lastIndexOfSymbolRule

      public int lastIndexOfSymbolRule(Object element)

    • equalsSymbolRules

      public boolean equalsSymbolRules(Object o)

    • hashCodeSymbolRules

      public int hashCodeSymbolRules()

    • listIteratorSymbolRules

      public ListIterator<ASTSymbolRule> listIteratorSymbolRules()

    • listIteratorSymbolRules

      public ListIterator<ASTSymbolRule> listIteratorSymbolRules(int index)

    • subListSymbolRules

      public List<ASTSymbolRule> subListSymbolRules(int start, int end)

    • getSymbolRuleList

      public List<ASTSymbolRule> getSymbolRuleList()

    • containsConcept

      public boolean containsConcept(Object element)

    • containsAllConcepts

      public boolean containsAllConcepts(Collection<?> collection)

    • isEmptyConcepts

      public boolean isEmptyConcepts()

    • iteratorConcepts

      public Iterator<ASTConcept> iteratorConcepts()

    • sizeConcepts

      public int sizeConcepts()

    • toArrayConcepts

      public ASTConcept[] toArrayConcepts(ASTConcept[] array)

    • toArrayConcepts

      public Object[] toArrayConcepts()

    • spliteratorConcepts

      public Spliterator<ASTConcept> spliteratorConcepts()

    • streamConcepts

      public Stream<ASTConcept> streamConcepts()

    • parallelStreamConcepts

      public Stream<ASTConcept> parallelStreamConcepts()

    • getConcept

      public ASTConcept getConcept(int index)

    • indexOfConcept

      public int indexOfConcept(Object element)

    • lastIndexOfConcept

      public int lastIndexOfConcept(Object element)

    • equalsConcepts

      public boolean equalsConcepts(Object o)

    • hashCodeConcepts

      public int hashCodeConcepts()

    • listIteratorConcepts

      public ListIterator<ASTConcept> listIteratorConcepts()

    • listIteratorConcepts

      public ListIterator<ASTConcept> listIteratorConcepts(int index)

    • subListConcepts

      public List<ASTConcept> subListConcepts(int start, int end)

    • getConceptList

      public List<ASTConcept> getConceptList()

    • containsSplitRule

      public boolean containsSplitRule(Object element)

    • containsAllSplitRules

      public boolean containsAllSplitRules(Collection<?> collection)

    • isEmptySplitRules

      public boolean isEmptySplitRules()

    • iteratorSplitRules

      public Iterator<ASTSplitRule> iteratorSplitRules()

    • sizeSplitRules

      public int sizeSplitRules()

    • toArraySplitRules

      public ASTSplitRule[] toArraySplitRules(ASTSplitRule[] array)

    • toArraySplitRules

      public Object[] toArraySplitRules()

    • spliteratorSplitRules

      public Spliterator<ASTSplitRule> spliteratorSplitRules()

    • streamSplitRules

      public Stream<ASTSplitRule> streamSplitRules()

    • parallelStreamSplitRules

      public Stream<ASTSplitRule> parallelStreamSplitRules()

    • getSplitRule

      public ASTSplitRule getSplitRule(int index)

    • indexOfSplitRule

      public int indexOfSplitRule(Object element)

    • lastIndexOfSplitRule

      public int lastIndexOfSplitRule(Object element)

    • equalsSplitRules

      public boolean equalsSplitRules(Object o)

    • hashCodeSplitRules

      public int hashCodeSplitRules()

    • listIteratorSplitRules

      public ListIterator<ASTSplitRule> listIteratorSplitRules()

    • listIteratorSplitRules

      public ListIterator<ASTSplitRule> listIteratorSplitRules(int index)

    • subListSplitRules

      public List<ASTSplitRule> subListSplitRules(int start, int end)

    • getSplitRuleList

      public List<ASTSplitRule> getSplitRuleList()

    • containsKeywordRule

      public boolean containsKeywordRule(Object element)

    • containsAllKeywordRules

      public boolean containsAllKeywordRules(Collection<?> collection)

    • isEmptyKeywordRules

      public boolean isEmptyKeywordRules()

    • iteratorKeywordRules

      public Iterator<ASTKeywordRule> iteratorKeywordRules()

    • sizeKeywordRules

      public int sizeKeywordRules()

    • toArrayKeywordRules

      public ASTKeywordRule[] toArrayKeywordRules(ASTKeywordRule[] array)

    • toArrayKeywordRules

      public Object[] toArrayKeywordRules()

    • spliteratorKeywordRules

      public Spliterator<ASTKeywordRule> spliteratorKeywordRules()

    • streamKeywordRules

      public Stream<ASTKeywordRule> streamKeywordRules()

    • parallelStreamKeywordRules

      public Stream<ASTKeywordRule> parallelStreamKeywordRules()

    • getKeywordRule

      public ASTKeywordRule getKeywordRule(int index)

    • indexOfKeywordRule

      public int indexOfKeywordRule(Object element)

    • lastIndexOfKeywordRule

      public int lastIndexOfKeywordRule(Object element)

    • equalsKeywordRules

      public boolean equalsKeywordRules(Object o)

    • hashCodeKeywordRules

      public int hashCodeKeywordRules()

    • listIteratorKeywordRules

      public ListIterator<ASTKeywordRule> listIteratorKeywordRules()

    • listIteratorKeywordRules

      public ListIterator<ASTKeywordRule> listIteratorKeywordRules(int index)

    • subListKeywordRules

      public List<ASTKeywordRule> subListKeywordRules(int start, int end)

    • getKeywordRuleList

      public List<ASTKeywordRule> getKeywordRuleList()

    • containsReplaceRule

      public boolean containsReplaceRule(Object element)

    • containsAllReplaceRules

      public boolean containsAllReplaceRules(Collection<?> collection)

    • isEmptyReplaceRules

      public boolean isEmptyReplaceRules()

    • iteratorReplaceRules

      public Iterator<ASTReplaceRule> iteratorReplaceRules()

    • sizeReplaceRules

      public int sizeReplaceRules()

    • toArrayReplaceRules

      public ASTReplaceRule[] toArrayReplaceRules(ASTReplaceRule[] array)

    • toArrayReplaceRules

      public Object[] toArrayReplaceRules()

    • spliteratorReplaceRules

      public Spliterator<ASTReplaceRule> spliteratorReplaceRules()

    • streamReplaceRules

      public Stream<ASTReplaceRule> streamReplaceRules()

    • parallelStreamReplaceRules

      public Stream<ASTReplaceRule> parallelStreamReplaceRules()

    • getReplaceRule

      public ASTReplaceRule getReplaceRule(int index)

    • indexOfReplaceRule

      public int indexOfReplaceRule(Object element)

    • lastIndexOfReplaceRule

      public int lastIndexOfReplaceRule(Object element)

    • equalsReplaceRules

      public boolean equalsReplaceRules(Object o)

    • hashCodeReplaceRules

      public int hashCodeReplaceRules()

    • listIteratorReplaceRules

      public ListIterator<ASTReplaceRule> listIteratorReplaceRules()

    • listIteratorReplaceRules

      public ListIterator<ASTReplaceRule> listIteratorReplaceRules(int index)

    • subListReplaceRules

      public List<ASTReplaceRule> subListReplaceRules(int start, int end)

    • getReplaceRuleList

      public List<ASTReplaceRule> getReplaceRuleList()

    • isComponent

      public boolean isComponent()

    • setGrammarOption

      public void setGrammarOption(ASTGrammarOption grammarOption)

    • setGrammarOptionAbsent

      public void setGrammarOptionAbsent()

    • setStartRule

      public void setStartRule(ASTStartRule startRule)

    • setStartRuleAbsent

      public void setStartRuleAbsent()

    • setScopeRule

      public void setScopeRule(ASTScopeRule scopeRule)

    • setScopeRuleAbsent

      public void setScopeRuleAbsent()

    • clearPackage

      public void clearPackage()

    • addPackage

      public boolean addPackage(String element)

    • addAllPackage

      public boolean addAllPackage(Collection<? extends String> collection)

    • removePackage

      public boolean removePackage(Object element)

    • removeAllPackage

      public boolean removeAllPackage(Collection<?> collection)

    • retainAllPackage

      public boolean retainAllPackage(Collection<?> collection)

    • removeIfPackage

      public boolean removeIfPackage(Predicate<? super String> filter)

    • forEachPackage

      public void forEachPackage(Consumer<? super String> action)

    • addPackage

      public void addPackage(int index, String element)

    • addAllPackage

      public boolean addAllPackage(int index, Collection<? extends String> collection)

    • removePackage

      public String removePackage(int index)

    • setPackage

      public String setPackage(int index, String element)

    • replaceAllPackage

      public void replaceAllPackage(UnaryOperator<String> operator)

    • sortPackage

      public void sortPackage(Comparator<? super String> comparator)

    • setPackageList

      public void setPackageList(List<String> r__package)

    • clearImportStatement

      public void clearImportStatement()

    • addImportStatement

      public boolean addImportStatement(ASTMCImportStatement element)

    • addAllImportStatement

      public boolean addAllImportStatement(Collection<? extends ASTMCImportStatement> collection)

    • removeImportStatement

      public boolean removeImportStatement(Object element)

    • removeAllImportStatement

      public boolean removeAllImportStatement(Collection<?> collection)

    • retainAllImportStatement

      public boolean retainAllImportStatement(Collection<?> collection)

    • removeIfImportStatement

      public boolean removeIfImportStatement(Predicate<? super ASTMCImportStatement> filter)

    • forEachImportStatement

      public void forEachImportStatement(Consumer<? super ASTMCImportStatement> action)

    • addImportStatement

      public void addImportStatement(int index, ASTMCImportStatement element)

    • addAllImportStatement

      public boolean addAllImportStatement(int index, Collection<? extends ASTMCImportStatement> collection)

    • removeImportStatement

      public ASTMCImportStatement removeImportStatement(int index)

    • setImportStatement

      public ASTMCImportStatement setImportStatement(int index, ASTMCImportStatement element)

    • replaceAllImportStatement

      public void replaceAllImportStatement(UnaryOperator<ASTMCImportStatement> operator)

    • sortImportStatement

      public void sortImportStatement(Comparator<? super ASTMCImportStatement> comparator)

    • setImportStatementList

      public void setImportStatementList(List<ASTMCImportStatement> importStatement)

    • setGrammarAnnotation

      public void setGrammarAnnotation(ASTGrammarAnnotation grammarAnnotation)

    • setGrammarAnnotationAbsent

      public void setGrammarAnnotationAbsent()

    • setName

      public void setName(String name)

    • clearSupergrammar

      public void clearSupergrammar()

    • addSupergrammar

      public boolean addSupergrammar(ASTGrammarReference element)

    • addAllSupergrammar

      public boolean addAllSupergrammar(Collection<? extends ASTGrammarReference> collection)

    • removeSupergrammar

      public boolean removeSupergrammar(Object element)

    • removeAllSupergrammar

      public boolean removeAllSupergrammar(Collection<?> collection)

    • retainAllSupergrammar

      public boolean retainAllSupergrammar(Collection<?> collection)

    • removeIfSupergrammar

      public boolean removeIfSupergrammar(Predicate<? super ASTGrammarReference> filter)

    • forEachSupergrammar

      public void forEachSupergrammar(Consumer<? super ASTGrammarReference> action)

    • addSupergrammar

      public void addSupergrammar(int index, ASTGrammarReference element)

    • addAllSupergrammar

      public boolean addAllSupergrammar(int index, Collection<? extends ASTGrammarReference> collection)

    • removeSupergrammar

      public ASTGrammarReference removeSupergrammar(int index)

    • setSupergrammar

      public ASTGrammarReference setSupergrammar(int index, ASTGrammarReference element)

    • replaceAllSupergrammar

      public void replaceAllSupergrammar(UnaryOperator<ASTGrammarReference> operator)

    • sortSupergrammar

      public void sortSupergrammar(Comparator<? super ASTGrammarReference> comparator)

    • setSupergrammarList

      public void setSupergrammarList(List<ASTGrammarReference> supergrammar)

    • clearLexProds

      public void clearLexProds()

    • addLexProd

      public boolean addLexProd(ASTLexProd element)

    • addAllLexProds

      public boolean addAllLexProds(Collection<? extends ASTLexProd> collection)

    • removeLexProd

      public boolean removeLexProd(Object element)

    • removeAllLexProds

      public boolean removeAllLexProds(Collection<?> collection)

    • retainAllLexProds

      public boolean retainAllLexProds(Collection<?> collection)

    • removeIfLexProd

      public boolean removeIfLexProd(Predicate<? super ASTLexProd> filter)

    • forEachLexProds

      public void forEachLexProds(Consumer<? super ASTLexProd> action)

    • addLexProd

      public void addLexProd(int index, ASTLexProd element)

    • addAllLexProds

      public boolean addAllLexProds(int index, Collection<? extends ASTLexProd> collection)

    • removeLexProd

      public ASTLexProd removeLexProd(int index)

    • setLexProd

      public ASTLexProd setLexProd(int index, ASTLexProd element)

    • replaceAllLexProds

      public void replaceAllLexProds(UnaryOperator<ASTLexProd> operator)

    • sortLexProds

      public void sortLexProds(Comparator<? super ASTLexProd> comparator)

    • setLexProdList

      public void setLexProdList(List<ASTLexProd> lexProds)

    • clearClassProds

      public void clearClassProds()

    • addClassProd

      public boolean addClassProd(ASTClassProd element)

    • addAllClassProds

      public boolean addAllClassProds(Collection<? extends ASTClassProd> collection)

    • removeClassProd

      public boolean removeClassProd(Object element)

    • removeAllClassProds

      public boolean removeAllClassProds(Collection<?> collection)

    • retainAllClassProds

      public boolean retainAllClassProds(Collection<?> collection)

    • removeIfClassProd

      public boolean removeIfClassProd(Predicate<? super ASTClassProd> filter)

    • forEachClassProds

      public void forEachClassProds(Consumer<? super ASTClassProd> action)

    • addClassProd

      public void addClassProd(int index, ASTClassProd element)

    • addAllClassProds

      public boolean addAllClassProds(int index, Collection<? extends ASTClassProd> collection)

    • removeClassProd

      public ASTClassProd removeClassProd(int index)

    • setClassProd

      public ASTClassProd setClassProd(int index, ASTClassProd element)

    • replaceAllClassProds

      public void replaceAllClassProds(UnaryOperator<ASTClassProd> operator)

    • sortClassProds

      public void sortClassProds(Comparator<? super ASTClassProd> comparator)

    • setClassProdList

      public void setClassProdList(List<ASTClassProd> classProds)

    • clearEnumProds

      public void clearEnumProds()

    • addEnumProd

      public boolean addEnumProd(ASTEnumProd element)

    • addAllEnumProds

      public boolean addAllEnumProds(Collection<? extends ASTEnumProd> collection)

    • removeEnumProd

      public boolean removeEnumProd(Object element)

    • removeAllEnumProds

      public boolean removeAllEnumProds(Collection<?> collection)

    • retainAllEnumProds

      public boolean retainAllEnumProds(Collection<?> collection)

    • removeIfEnumProd

      public boolean removeIfEnumProd(Predicate<? super ASTEnumProd> filter)

    • forEachEnumProds

      public void forEachEnumProds(Consumer<? super ASTEnumProd> action)

    • addEnumProd

      public void addEnumProd(int index, ASTEnumProd element)

    • addAllEnumProds

      public boolean addAllEnumProds(int index, Collection<? extends ASTEnumProd> collection)

    • removeEnumProd

      public ASTEnumProd removeEnumProd(int index)

    • setEnumProd

      public ASTEnumProd setEnumProd(int index, ASTEnumProd element)

    • replaceAllEnumProds

      public void replaceAllEnumProds(UnaryOperator<ASTEnumProd> operator)

    • sortEnumProds

      public void sortEnumProds(Comparator<? super ASTEnumProd> comparator)

    • setEnumProdList

      public void setEnumProdList(List<ASTEnumProd> enumProds)

    • clearExternalProds

      public void clearExternalProds()

    • addExternalProd

      public boolean addExternalProd(ASTExternalProd element)

    • addAllExternalProds

      public boolean addAllExternalProds(Collection<? extends ASTExternalProd> collection)

    • removeExternalProd

      public boolean removeExternalProd(Object element)

    • removeAllExternalProds

      public boolean removeAllExternalProds(Collection<?> collection)

    • retainAllExternalProds

      public boolean retainAllExternalProds(Collection<?> collection)

    • removeIfExternalProd

      public boolean removeIfExternalProd(Predicate<? super ASTExternalProd> filter)

    • forEachExternalProds

      public void forEachExternalProds(Consumer<? super ASTExternalProd> action)

    • addExternalProd

      public void addExternalProd(int index, ASTExternalProd element)

    • addAllExternalProds

      public boolean addAllExternalProds(int index, Collection<? extends ASTExternalProd> collection)

    • removeExternalProd

      public ASTExternalProd removeExternalProd(int index)

    • setExternalProd

      public ASTExternalProd setExternalProd(int index, ASTExternalProd element)

    • replaceAllExternalProds

      public void replaceAllExternalProds(UnaryOperator<ASTExternalProd> operator)

    • sortExternalProds

      public void sortExternalProds(Comparator<? super ASTExternalProd> comparator)

    • setExternalProdList

      public void setExternalProdList(List<ASTExternalProd> externalProds)

    • clearInterfaceProds

      public void clearInterfaceProds()

    • addInterfaceProd

      public boolean addInterfaceProd(ASTInterfaceProd element)

    • addAllInterfaceProds

      public boolean addAllInterfaceProds(Collection<? extends ASTInterfaceProd> collection)

    • removeInterfaceProd

      public boolean removeInterfaceProd(Object element)

    • removeAllInterfaceProds

      public boolean removeAllInterfaceProds(Collection<?> collection)

    • retainAllInterfaceProds

      public boolean retainAllInterfaceProds(Collection<?> collection)

    • removeIfInterfaceProd

      public boolean removeIfInterfaceProd(Predicate<? super ASTInterfaceProd> filter)

    • forEachInterfaceProds

      public void forEachInterfaceProds(Consumer<? super ASTInterfaceProd> action)

    • addInterfaceProd

      public void addInterfaceProd(int index, ASTInterfaceProd element)

    • addAllInterfaceProds

      public boolean addAllInterfaceProds(int index, Collection<? extends ASTInterfaceProd> collection)

    • removeInterfaceProd

      public ASTInterfaceProd removeInterfaceProd(int index)

    • setInterfaceProd

      public ASTInterfaceProd setInterfaceProd(int index, ASTInterfaceProd element)

    • replaceAllInterfaceProds

      public void replaceAllInterfaceProds(UnaryOperator<ASTInterfaceProd> operator)

    • sortInterfaceProds

      public void sortInterfaceProds(Comparator<? super ASTInterfaceProd> comparator)

    • setInterfaceProdList

      public void setInterfaceProdList(List<ASTInterfaceProd> interfaceProds)

    • clearAbstractProds

      public void clearAbstractProds()

    • addAbstractProd

      public boolean addAbstractProd(ASTAbstractProd element)

    • addAllAbstractProds

      public boolean addAllAbstractProds(Collection<? extends ASTAbstractProd> collection)

    • removeAbstractProd

      public boolean removeAbstractProd(Object element)

    • removeAllAbstractProds

      public boolean removeAllAbstractProds(Collection<?> collection)

    • retainAllAbstractProds

      public boolean retainAllAbstractProds(Collection<?> collection)

    • removeIfAbstractProd

      public boolean removeIfAbstractProd(Predicate<? super ASTAbstractProd> filter)

    • forEachAbstractProds

      public void forEachAbstractProds(Consumer<? super ASTAbstractProd> action)

    • addAbstractProd

      public void addAbstractProd(int index, ASTAbstractProd element)

    • addAllAbstractProds

      public boolean addAllAbstractProds(int index, Collection<? extends ASTAbstractProd> collection)

    • removeAbstractProd

      public ASTAbstractProd removeAbstractProd(int index)

    • setAbstractProd

      public ASTAbstractProd setAbstractProd(int index, ASTAbstractProd element)

    • replaceAllAbstractProds

      public void replaceAllAbstractProds(UnaryOperator<ASTAbstractProd> operator)

    • sortAbstractProds

      public void sortAbstractProds(Comparator<? super ASTAbstractProd> comparator)

    • setAbstractProdList

      public void setAbstractProdList(List<ASTAbstractProd> abstractProds)

    • clearASTRules

      public void clearASTRules()

    • addASTRule

      public boolean addASTRule(ASTASTRule element)

    • addAllASTRules

      public boolean addAllASTRules(Collection<? extends ASTASTRule> collection)

    • removeASTRule

      public boolean removeASTRule(Object element)

    • removeAllASTRules

      public boolean removeAllASTRules(Collection<?> collection)

    • retainAllASTRules

      public boolean retainAllASTRules(Collection<?> collection)

    • removeIfASTRule

      public boolean removeIfASTRule(Predicate<? super ASTASTRule> filter)

    • forEachASTRules

      public void forEachASTRules(Consumer<? super ASTASTRule> action)

    • addASTRule

      public void addASTRule(int index, ASTASTRule element)

    • addAllASTRules

      public boolean addAllASTRules(int index, Collection<? extends ASTASTRule> collection)

    • removeASTRule

      public ASTASTRule removeASTRule(int index)

    • setASTRule

      public ASTASTRule setASTRule(int index, ASTASTRule element)

    • replaceAllASTRules

      public void replaceAllASTRules(UnaryOperator<ASTASTRule> operator)

    • sortASTRules

      public void sortASTRules(Comparator<? super ASTASTRule> comparator)

    • setASTRuleList

      public void setASTRuleList(List<ASTASTRule> aSTRules)

    • clearSymbolRules

      public void clearSymbolRules()

    • addSymbolRule

      public boolean addSymbolRule(ASTSymbolRule element)

    • addAllSymbolRules

      public boolean addAllSymbolRules(Collection<? extends ASTSymbolRule> collection)

    • removeSymbolRule

      public boolean removeSymbolRule(Object element)

    • removeAllSymbolRules

      public boolean removeAllSymbolRules(Collection<?> collection)

    • retainAllSymbolRules

      public boolean retainAllSymbolRules(Collection<?> collection)

    • removeIfSymbolRule

      public boolean removeIfSymbolRule(Predicate<? super ASTSymbolRule> filter)

    • forEachSymbolRules

      public void forEachSymbolRules(Consumer<? super ASTSymbolRule> action)

    • addSymbolRule

      public void addSymbolRule(int index, ASTSymbolRule element)

    • addAllSymbolRules

      public boolean addAllSymbolRules(int index, Collection<? extends ASTSymbolRule> collection)

    • removeSymbolRule

      public ASTSymbolRule removeSymbolRule(int index)

    • setSymbolRule

      public ASTSymbolRule setSymbolRule(int index, ASTSymbolRule element)

    • replaceAllSymbolRules

      public void replaceAllSymbolRules(UnaryOperator<ASTSymbolRule> operator)

    • sortSymbolRules

      public void sortSymbolRules(Comparator<? super ASTSymbolRule> comparator)

    • setSymbolRuleList

      public void setSymbolRuleList(List<ASTSymbolRule> symbolRules)

    • clearConcepts

      public void clearConcepts()

    • addConcept

      public boolean addConcept(ASTConcept element)

    • addAllConcepts

      public boolean addAllConcepts(Collection<? extends ASTConcept> collection)

    • removeConcept

      public boolean removeConcept(Object element)

    • removeAllConcepts

      public boolean removeAllConcepts(Collection<?> collection)

    • retainAllConcepts

      public boolean retainAllConcepts(Collection<?> collection)

    • removeIfConcept

      public boolean removeIfConcept(Predicate<? super ASTConcept> filter)

    • forEachConcepts

      public void forEachConcepts(Consumer<? super ASTConcept> action)

    • addConcept

      public void addConcept(int index, ASTConcept element)

    • addAllConcepts

      public boolean addAllConcepts(int index, Collection<? extends ASTConcept> collection)

    • removeConcept

      public ASTConcept removeConcept(int index)

    • setConcept

      public ASTConcept setConcept(int index, ASTConcept element)

    • replaceAllConcepts

      public void replaceAllConcepts(UnaryOperator<ASTConcept> operator)

    • sortConcepts

      public void sortConcepts(Comparator<? super ASTConcept> comparator)

    • setConceptList

      public void setConceptList(List<ASTConcept> concepts)

    • clearSplitRules

      public void clearSplitRules()

    • addSplitRule

      public boolean addSplitRule(ASTSplitRule element)

    • addAllSplitRules

      public boolean addAllSplitRules(Collection<? extends ASTSplitRule> collection)

    • removeSplitRule

      public boolean removeSplitRule(Object element)

    • removeAllSplitRules

      public boolean removeAllSplitRules(Collection<?> collection)

    • retainAllSplitRules

      public boolean retainAllSplitRules(Collection<?> collection)

    • removeIfSplitRule

      public boolean removeIfSplitRule(Predicate<? super ASTSplitRule> filter)

    • forEachSplitRules

      public void forEachSplitRules(Consumer<? super ASTSplitRule> action)

    • addSplitRule

      public void addSplitRule(int index, ASTSplitRule element)

    • addAllSplitRules

      public boolean addAllSplitRules(int index, Collection<? extends ASTSplitRule> collection)

    • removeSplitRule

      public ASTSplitRule removeSplitRule(int index)

    • setSplitRule

      public ASTSplitRule setSplitRule(int index, ASTSplitRule element)

    • replaceAllSplitRules

      public void replaceAllSplitRules(UnaryOperator<ASTSplitRule> operator)

    • sortSplitRules

      public void sortSplitRules(Comparator<? super ASTSplitRule> comparator)

    • setSplitRuleList

      public void setSplitRuleList(List<ASTSplitRule> splitRules)

    • clearKeywordRules

      public void clearKeywordRules()

    • addKeywordRule

      public boolean addKeywordRule(ASTKeywordRule element)

    • addAllKeywordRules

      public boolean addAllKeywordRules(Collection<? extends ASTKeywordRule> collection)

    • removeKeywordRule

      public boolean removeKeywordRule(Object element)

    • removeAllKeywordRules

      public boolean removeAllKeywordRules(Collection<?> collection)

    • retainAllKeywordRules

      public boolean retainAllKeywordRules(Collection<?> collection)

    • removeIfKeywordRule

      public boolean removeIfKeywordRule(Predicate<? super ASTKeywordRule> filter)

    • forEachKeywordRules

      public void forEachKeywordRules(Consumer<? super ASTKeywordRule> action)

    • addKeywordRule

      public void addKeywordRule(int index, ASTKeywordRule element)

    • addAllKeywordRules

      public boolean addAllKeywordRules(int index, Collection<? extends ASTKeywordRule> collection)

    • removeKeywordRule

      public ASTKeywordRule removeKeywordRule(int index)

    • setKeywordRule

      public ASTKeywordRule setKeywordRule(int index, ASTKeywordRule element)

    • replaceAllKeywordRules

      public void replaceAllKeywordRules(UnaryOperator<ASTKeywordRule> operator)

    • sortKeywordRules

      public void sortKeywordRules(Comparator<? super ASTKeywordRule> comparator)

    • setKeywordRuleList

      public void setKeywordRuleList(List<ASTKeywordRule> keywordRules)

    • clearReplaceRules

      public void clearReplaceRules()

    • addReplaceRule

      public boolean addReplaceRule(ASTReplaceRule element)

    • addAllReplaceRules

      public boolean addAllReplaceRules(Collection<? extends ASTReplaceRule> collection)

    • removeReplaceRule

      public boolean removeReplaceRule(Object element)

    • removeAllReplaceRules

      public boolean removeAllReplaceRules(Collection<?> collection)

    • retainAllReplaceRules

      public boolean retainAllReplaceRules(Collection<?> collection)

    • removeIfReplaceRule

      public boolean removeIfReplaceRule(Predicate<? super ASTReplaceRule> filter)

    • forEachReplaceRules

      public void forEachReplaceRules(Consumer<? super ASTReplaceRule> action)

    • addReplaceRule

      public void addReplaceRule(int index, ASTReplaceRule element)

    • addAllReplaceRules

      public boolean addAllReplaceRules(int index, Collection<? extends ASTReplaceRule> collection)

    • removeReplaceRule

      public ASTReplaceRule removeReplaceRule(int index)

    • setReplaceRule

      public ASTReplaceRule setReplaceRule(int index, ASTReplaceRule element)

    • replaceAllReplaceRules

      public void replaceAllReplaceRules(UnaryOperator<ASTReplaceRule> operator)

    • sortReplaceRules

      public void sortReplaceRules(Comparator<? super ASTReplaceRule> comparator)

    • setReplaceRuleList

      public void setReplaceRuleList(List<ASTReplaceRule> replaceRules)

    • setComponent

      public void setComponent(boolean component)

    • accept

      public void accept(GrammarTraverser visitor)
      Entry point for the Visitor pattern. Cf. MontiCore handbook chapter 8.
      Specified by:
      accept in interface ASTGrammarNode
      Parameters:
      visitor - the visitor to dispatch to

    • accept

      public void accept(MCCommonLiteralsTraverser visitor)
      Entry point for the Visitor pattern. Cf. MontiCore handbook chapter 8.
      Parameters:
      visitor - the visitor to dispatch to

    • accept

      public void accept(MCSimpleGenericTypesTraverser visitor)
      Entry point for the Visitor pattern. Cf. MontiCore handbook chapter 8.
      Parameters:
      visitor - the visitor to dispatch to

    • accept

      public void accept(MCBasicsTraverser visitor)
      Entry point for the Visitor pattern. Cf. MontiCore handbook chapter 8.
      Parameters:
      visitor - the visitor to dispatch to

    • accept

      public void accept(MCLiteralsBasisTraverser visitor)
      Entry point for the Visitor pattern. Cf. MontiCore handbook chapter 8.
      Parameters:
      visitor - the visitor to dispatch to

    • accept

      public void accept(MCCollectionTypesTraverser visitor)
      Entry point for the Visitor pattern. Cf. MontiCore handbook chapter 8.
      Parameters:
      visitor - the visitor to dispatch to

    • accept

      public void accept(MCBasicTypesTraverser visitor)
      Entry point for the Visitor pattern. Cf. MontiCore handbook chapter 8.
      Parameters:
      visitor - the visitor to dispatch to

    • accept

      public void accept(de.monticore.visitor.ITraverser visitor)
      Entry point for the Visitor pattern. Cf. MontiCore handbook chapter 8.
      Specified by:
      accept in interface de.monticore.ast.ASTNode
      Parameters:
      visitor - the visitor to dispatch to

    • _construct

      protected ASTMCGrammar _construct()

    • getSymbol

      public MCGrammarSymbol getSymbol()

    • isPresentSymbol

      public boolean isPresentSymbol()

    • setSymbol

      public void setSymbol(MCGrammarSymbol symbol)

    • setSymbolAbsent

      public void setSymbolAbsent()

    • getSpannedScope

      public IGrammarScope getSpannedScope()

    • setSpannedScope

      public void setSpannedScope(IGrammarScope spannedScope)

    • getEnclosingScope

      public IGrammarScope getEnclosingScope()
      Specified by:
      getEnclosingScope in interface de.monticore.ast.ASTNode

    • setEnclosingScope

      public void setEnclosingScope(IGrammarScope enclosingScope)

    • setEnclosingScope

      public void setEnclosingScope(IMCCommonLiteralsScope enclosingScope)

    • setEnclosingScope

      public void setEnclosingScope(IMCSimpleGenericTypesScope enclosingScope)

    • setEnclosingScope

      public void setEnclosingScope(IMCBasicsScope enclosingScope)

    • setEnclosingScope

      public void setEnclosingScope(IMCLiteralsBasisScope enclosingScope)

    • setEnclosingScope

      public void setEnclosingScope(IMCCollectionTypesScope enclosingScope)

    • setEnclosingScope

      public void setEnclosingScope(IMCBasicTypesScope enclosingScope)

    • evaluate

      public de.monticore.interpreter.Value evaluate(IGrammarInterpreter interpreter)

    • evaluate

      public de.monticore.interpreter.Value evaluate(de.monticore.interpreter.ModelInterpreter interpreter)
      Specified by:
      evaluate in interface de.monticore.ast.ASTNode