• Home
• org.eclipse.xtend
• org.eclipse.xtend.standalone
• 2.4.1
• source code
• XtextParsetreeConstructor.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.eclipse.xtext.parseTreeConstruction.XtextParsetreeConstructor Maven / Gradle / Ivy

/*
* generated by Xtext
*/
package org.eclipse.xtext.parseTreeConstruction;

import org.eclipse.emf.ecore.*;
import org.eclipse.xtext.*;
import org.eclipse.xtext.parsetree.reconstr.IEObjectConsumer;
import org.eclipse.xtext.parsetree.reconstr.impl.AbstractParseTreeConstructor;

import org.eclipse.xtext.services.XtextGrammarAccess;

import com.google.inject.Inject;

@SuppressWarnings("all")
public class XtextParsetreeConstructor extends AbstractParseTreeConstructor {
		
	@Inject
	private XtextGrammarAccess grammarAccess;
	
	@Override
	protected AbstractToken getRootToken(IEObjectConsumer inst) {
		return new ThisRootNode(inst);	
	}
	
protected class ThisRootNode extends RootToken {
	public ThisRootNode(IEObjectConsumer inst) {
		super(inst);
	}
	
	@Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_Group(this, this, 0, inst);
			case 1: return new AbstractRule_Alternatives(this, this, 1, inst);
			case 2: return new AbstractMetamodelDeclaration_Alternatives(this, this, 2, inst);
			case 3: return new GeneratedMetamodel_Group(this, this, 3, inst);
			case 4: return new ReferencedMetamodel_Group(this, this, 4, inst);
			case 5: return new ParserRule_Group(this, this, 5, inst);
			case 6: return new TypeRef_Group(this, this, 6, inst);
			case 7: return new Alternatives_Group(this, this, 7, inst);
			case 8: return new UnorderedGroup_Group(this, this, 8, inst);
			case 9: return new Group_Group(this, this, 9, inst);
			case 10: return new AbstractToken_Alternatives(this, this, 10, inst);
			case 11: return new AbstractTokenWithCardinality_Group(this, this, 11, inst);
			case 12: return new Action_Group(this, this, 12, inst);
			case 13: return new AbstractTerminal_Alternatives(this, this, 13, inst);
			case 14: return new Keyword_ValueAssignment(this, this, 14, inst);
			case 15: return new RuleCall_RuleAssignment(this, this, 15, inst);
			case 16: return new PredicatedKeyword_Group(this, this, 16, inst);
			case 17: return new PredicatedRuleCall_Group(this, this, 17, inst);
			case 18: return new Assignment_Group(this, this, 18, inst);
			case 19: return new AssignableTerminal_Alternatives(this, this, 19, inst);
			case 20: return new ParenthesizedAssignableElement_Group(this, this, 20, inst);
			case 21: return new AssignableAlternatives_Group(this, this, 21, inst);
			case 22: return new CrossReference_Group(this, this, 22, inst);
			case 23: return new CrossReferenceableTerminal_Alternatives(this, this, 23, inst);
			case 24: return new ParenthesizedElement_Group(this, this, 24, inst);
			case 25: return new PredicatedGroup_Group(this, this, 25, inst);
			case 26: return new TerminalRule_Group(this, this, 26, inst);
			case 27: return new TerminalAlternatives_Group(this, this, 27, inst);
			case 28: return new TerminalGroup_Group(this, this, 28, inst);
			case 29: return new TerminalToken_Group(this, this, 29, inst);
			case 30: return new TerminalTokenElement_Alternatives(this, this, 30, inst);
			case 31: return new ParenthesizedTerminalElement_Group(this, this, 31, inst);
			case 32: return new AbstractNegatedToken_Alternatives(this, this, 32, inst);
			case 33: return new NegatedToken_Group(this, this, 33, inst);
			case 34: return new UntilToken_Group(this, this, 34, inst);
			case 35: return new Wildcard_Group(this, this, 35, inst);
			case 36: return new EOF_Group(this, this, 36, inst);
			case 37: return new CharacterRange_Group(this, this, 37, inst);
			case 38: return new EnumRule_Group(this, this, 38, inst);
			case 39: return new EnumLiterals_Group(this, this, 39, inst);
			case 40: return new EnumLiteralDeclaration_Group(this, this, 40, inst);
			default: return null;
		}	
	}	
}
	

/************ begin Rule Grammar ****************
 *
 * Grammar:
 * 	"grammar" name=GrammarID ("with" usedGrammars+=[Grammar|GrammarID] ("," usedGrammars+=[Grammar|GrammarID])*)?
 * 	(definesHiddenTokens?="hidden" "(" (hiddenTokens+=[AbstractRule] ("," hiddenTokens+=[AbstractRule])*)? ")")?
 * 	metamodelDeclarations+=AbstractMetamodelDeclaration* rules+=AbstractRule+;
 *
 **/

// "grammar" name=GrammarID ("with" usedGrammars+=[Grammar|GrammarID] ("," usedGrammars+=[Grammar|GrammarID])*)?
// (definesHiddenTokens?="hidden" "(" (hiddenTokens+=[AbstractRule] ("," hiddenTokens+=[AbstractRule])*)? ")")?
// metamodelDeclarations+=AbstractMetamodelDeclaration* rules+=AbstractRule+
protected class Grammar_Group extends GroupToken {
	
	public Grammar_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getGrammarAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_RulesAssignment_5(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getGrammarRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "grammar"
protected class Grammar_GrammarKeyword_0 extends KeywordToken  {
	
	public Grammar_GrammarKeyword_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getGrammarAccess().getGrammarKeyword_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// name=GrammarID
protected class Grammar_NameAssignment_1 extends AssignmentToken  {
	
	public Grammar_NameAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getGrammarAccess().getNameAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_GrammarKeyword_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getGrammarAccess().getNameGrammarIDParserRuleCall_1_0(), value, null)) {
			type = AssignmentType.DATATYPE_RULE_CALL;
			element = grammarAccess.getGrammarAccess().getNameGrammarIDParserRuleCall_1_0();
			return obj;
		}
		return null;
	}

}

// ("with" usedGrammars+=[Grammar|GrammarID] ("," usedGrammars+=[Grammar|GrammarID])*)?
protected class Grammar_Group_2 extends GroupToken {
	
	public Grammar_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getGrammarAccess().getGroup_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_Group_2_2(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Grammar_UsedGrammarsAssignment_2_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// "with"
protected class Grammar_WithKeyword_2_0 extends KeywordToken  {
	
	public Grammar_WithKeyword_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getGrammarAccess().getWithKeyword_2_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_NameAssignment_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// usedGrammars+=[Grammar|GrammarID]
protected class Grammar_UsedGrammarsAssignment_2_1 extends AssignmentToken  {
	
	public Grammar_UsedGrammarsAssignment_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getGrammarAccess().getUsedGrammarsAssignment_2_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_WithKeyword_2_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("usedGrammars",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("usedGrammars");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getGrammarAccess().getUsedGrammarsGrammarCrossReference_2_1_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getGrammarAccess().getUsedGrammarsGrammarCrossReference_2_1_0(); 
				return obj;
			}
		}
		return null;
	}

}

// ("," usedGrammars+=[Grammar|GrammarID])*
protected class Grammar_Group_2_2 extends GroupToken {
	
	public Grammar_Group_2_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getGrammarAccess().getGroup_2_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_UsedGrammarsAssignment_2_2_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// ","
protected class Grammar_CommaKeyword_2_2_0 extends KeywordToken  {
	
	public Grammar_CommaKeyword_2_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getGrammarAccess().getCommaKeyword_2_2_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_Group_2_2(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Grammar_UsedGrammarsAssignment_2_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// usedGrammars+=[Grammar|GrammarID]
protected class Grammar_UsedGrammarsAssignment_2_2_1 extends AssignmentToken  {
	
	public Grammar_UsedGrammarsAssignment_2_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getGrammarAccess().getUsedGrammarsAssignment_2_2_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_CommaKeyword_2_2_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("usedGrammars",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("usedGrammars");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getGrammarAccess().getUsedGrammarsGrammarCrossReference_2_2_1_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getGrammarAccess().getUsedGrammarsGrammarCrossReference_2_2_1_0(); 
				return obj;
			}
		}
		return null;
	}

}



// (definesHiddenTokens?="hidden" "(" (hiddenTokens+=[AbstractRule] ("," hiddenTokens+=[AbstractRule])*)? ")")?
protected class Grammar_Group_3 extends GroupToken {
	
	public Grammar_Group_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getGrammarAccess().getGroup_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_RightParenthesisKeyword_3_3(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// definesHiddenTokens?="hidden"
protected class Grammar_DefinesHiddenTokensAssignment_3_0 extends AssignmentToken  {
	
	public Grammar_DefinesHiddenTokensAssignment_3_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getGrammarAccess().getDefinesHiddenTokensAssignment_3_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_Group_2(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Grammar_NameAssignment_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("definesHiddenTokens",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("definesHiddenTokens");
		if(Boolean.TRUE.equals(value)) { // org::eclipse::xtext::impl::KeywordImpl
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getGrammarAccess().getDefinesHiddenTokensHiddenKeyword_3_0_0();
			return obj;
		}
		return null;
	}

}

// "("
protected class Grammar_LeftParenthesisKeyword_3_1 extends KeywordToken  {
	
	public Grammar_LeftParenthesisKeyword_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getGrammarAccess().getLeftParenthesisKeyword_3_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_DefinesHiddenTokensAssignment_3_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// (hiddenTokens+=[AbstractRule] ("," hiddenTokens+=[AbstractRule])*)?
protected class Grammar_Group_3_2 extends GroupToken {
	
	public Grammar_Group_3_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getGrammarAccess().getGroup_3_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_Group_3_2_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Grammar_HiddenTokensAssignment_3_2_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// hiddenTokens+=[AbstractRule]
protected class Grammar_HiddenTokensAssignment_3_2_0 extends AssignmentToken  {
	
	public Grammar_HiddenTokensAssignment_3_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getGrammarAccess().getHiddenTokensAssignment_3_2_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_LeftParenthesisKeyword_3_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("hiddenTokens",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("hiddenTokens");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getGrammarAccess().getHiddenTokensAbstractRuleCrossReference_3_2_0_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getGrammarAccess().getHiddenTokensAbstractRuleCrossReference_3_2_0_0(); 
				return obj;
			}
		}
		return null;
	}

}

// ("," hiddenTokens+=[AbstractRule])*
protected class Grammar_Group_3_2_1 extends GroupToken {
	
	public Grammar_Group_3_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getGrammarAccess().getGroup_3_2_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_HiddenTokensAssignment_3_2_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// ","
protected class Grammar_CommaKeyword_3_2_1_0 extends KeywordToken  {
	
	public Grammar_CommaKeyword_3_2_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getGrammarAccess().getCommaKeyword_3_2_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_Group_3_2_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Grammar_HiddenTokensAssignment_3_2_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// hiddenTokens+=[AbstractRule]
protected class Grammar_HiddenTokensAssignment_3_2_1_1 extends AssignmentToken  {
	
	public Grammar_HiddenTokensAssignment_3_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getGrammarAccess().getHiddenTokensAssignment_3_2_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_CommaKeyword_3_2_1_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("hiddenTokens",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("hiddenTokens");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getGrammarAccess().getHiddenTokensAbstractRuleCrossReference_3_2_1_1_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getGrammarAccess().getHiddenTokensAbstractRuleCrossReference_3_2_1_1_0(); 
				return obj;
			}
		}
		return null;
	}

}



// ")"
protected class Grammar_RightParenthesisKeyword_3_3 extends KeywordToken  {
	
	public Grammar_RightParenthesisKeyword_3_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getGrammarAccess().getRightParenthesisKeyword_3_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Grammar_Group_3_2(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Grammar_LeftParenthesisKeyword_3_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}


// metamodelDeclarations+=AbstractMetamodelDeclaration*
protected class Grammar_MetamodelDeclarationsAssignment_4 extends AssignmentToken  {
	
	public Grammar_MetamodelDeclarationsAssignment_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getGrammarAccess().getMetamodelDeclarationsAssignment_4();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractMetamodelDeclaration_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("metamodelDeclarations",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("metamodelDeclarations");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getAbstractMetamodelDeclarationRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getGrammarAccess().getMetamodelDeclarationsAbstractMetamodelDeclarationParserRuleCall_4_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new Grammar_MetamodelDeclarationsAssignment_4(lastRuleCallOrigin, next, actIndex, consumed);
			case 1: return new Grammar_Group_3(lastRuleCallOrigin, next, actIndex, consumed);
			case 2: return new Grammar_Group_2(lastRuleCallOrigin, next, actIndex, consumed);
			case 3: return new Grammar_NameAssignment_1(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// rules+=AbstractRule+
protected class Grammar_RulesAssignment_5 extends AssignmentToken  {
	
	public Grammar_RulesAssignment_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getGrammarAccess().getRulesAssignment_5();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractRule_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("rules",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("rules");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getAbstractRuleRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getGrammarAccess().getRulesAbstractRuleParserRuleCall_5_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new Grammar_RulesAssignment_5(lastRuleCallOrigin, next, actIndex, consumed);
			case 1: return new Grammar_MetamodelDeclarationsAssignment_4(lastRuleCallOrigin, next, actIndex, consumed);
			case 2: return new Grammar_Group_3(lastRuleCallOrigin, next, actIndex, consumed);
			case 3: return new Grammar_Group_2(lastRuleCallOrigin, next, actIndex, consumed);
			case 4: return new Grammar_NameAssignment_1(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


/************ end Rule Grammar ****************/



/************ begin Rule AbstractRule ****************
 *
 * AbstractRule:
 * 	ParserRule | TerminalRule | EnumRule;
 *
 **/

// ParserRule | TerminalRule | EnumRule
protected class AbstractRule_Alternatives extends AlternativesToken {

	public AbstractRule_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getAbstractRuleAccess().getAlternatives();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractRule_ParserRuleParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AbstractRule_TerminalRuleParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
			case 2: return new AbstractRule_EnumRuleParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEnumRuleRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getParserRuleRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getTerminalRuleRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// ParserRule
protected class AbstractRule_ParserRuleParserRuleCall_0 extends RuleCallToken {
	
	public AbstractRule_ParserRuleParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractRuleAccess().getParserRuleParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getParserRuleRule().getType().getClassifier())
			return null;
		if(checkForRecursion(ParserRule_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// TerminalRule
protected class AbstractRule_TerminalRuleParserRuleCall_1 extends RuleCallToken {
	
	public AbstractRule_TerminalRuleParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractRuleAccess().getTerminalRuleParserRuleCall_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalRule_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getTerminalRuleRule().getType().getClassifier())
			return null;
		if(checkForRecursion(TerminalRule_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// EnumRule
protected class AbstractRule_EnumRuleParserRuleCall_2 extends RuleCallToken {
	
	public AbstractRule_EnumRuleParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractRuleAccess().getEnumRuleParserRuleCall_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumRule_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEnumRuleRule().getType().getClassifier())
			return null;
		if(checkForRecursion(EnumRule_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}


/************ end Rule AbstractRule ****************/


/************ begin Rule AbstractMetamodelDeclaration ****************
 *
 * AbstractMetamodelDeclaration:
 * 	GeneratedMetamodel | ReferencedMetamodel;
 *
 **/

// GeneratedMetamodel | ReferencedMetamodel
protected class AbstractMetamodelDeclaration_Alternatives extends AlternativesToken {

	public AbstractMetamodelDeclaration_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getAbstractMetamodelDeclarationAccess().getAlternatives();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractMetamodelDeclaration_GeneratedMetamodelParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AbstractMetamodelDeclaration_ReferencedMetamodelParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getGeneratedMetamodelRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getReferencedMetamodelRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// GeneratedMetamodel
protected class AbstractMetamodelDeclaration_GeneratedMetamodelParserRuleCall_0 extends RuleCallToken {
	
	public AbstractMetamodelDeclaration_GeneratedMetamodelParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractMetamodelDeclarationAccess().getGeneratedMetamodelParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new GeneratedMetamodel_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getGeneratedMetamodelRule().getType().getClassifier())
			return null;
		if(checkForRecursion(GeneratedMetamodel_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ReferencedMetamodel
protected class AbstractMetamodelDeclaration_ReferencedMetamodelParserRuleCall_1 extends RuleCallToken {
	
	public AbstractMetamodelDeclaration_ReferencedMetamodelParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractMetamodelDeclarationAccess().getReferencedMetamodelParserRuleCall_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ReferencedMetamodel_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getReferencedMetamodelRule().getType().getClassifier())
			return null;
		if(checkForRecursion(ReferencedMetamodel_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}


/************ end Rule AbstractMetamodelDeclaration ****************/


/************ begin Rule GeneratedMetamodel ****************
 *
 * // constraint: typeSelect(GeneratedMetamodel).size() == typeSelect(GeneratedMetamodel).alias.size()
 * // generated metamodels have to have different aliases
 * GeneratedMetamodel:
 * 	"generate" name=ID ePackage=[ecore::EPackage|STRING] ("as" alias=ID)?;
 *
 **/

// "generate" name=ID ePackage=[ecore::EPackage|STRING] ("as" alias=ID)?
protected class GeneratedMetamodel_Group extends GroupToken {
	
	public GeneratedMetamodel_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getGeneratedMetamodelAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new GeneratedMetamodel_Group_3(lastRuleCallOrigin, this, 0, inst);
			case 1: return new GeneratedMetamodel_EPackageAssignment_2(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getGeneratedMetamodelRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "generate"
protected class GeneratedMetamodel_GenerateKeyword_0 extends KeywordToken  {
	
	public GeneratedMetamodel_GenerateKeyword_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getGeneratedMetamodelAccess().getGenerateKeyword_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// name=ID
protected class GeneratedMetamodel_NameAssignment_1 extends AssignmentToken  {
	
	public GeneratedMetamodel_NameAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getGeneratedMetamodelAccess().getNameAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new GeneratedMetamodel_GenerateKeyword_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getGeneratedMetamodelAccess().getNameIDTerminalRuleCall_1_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getGeneratedMetamodelAccess().getNameIDTerminalRuleCall_1_0();
			return obj;
		}
		return null;
	}

}

// ePackage=[ecore::EPackage|STRING]
protected class GeneratedMetamodel_EPackageAssignment_2 extends AssignmentToken  {
	
	public GeneratedMetamodel_EPackageAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getGeneratedMetamodelAccess().getEPackageAssignment_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new GeneratedMetamodel_NameAssignment_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("ePackage",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("ePackage");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getGeneratedMetamodelAccess().getEPackageEPackageCrossReference_2_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getGeneratedMetamodelAccess().getEPackageEPackageCrossReference_2_0(); 
				return obj;
			}
		}
		return null;
	}

}

// ("as" alias=ID)?
protected class GeneratedMetamodel_Group_3 extends GroupToken {
	
	public GeneratedMetamodel_Group_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getGeneratedMetamodelAccess().getGroup_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new GeneratedMetamodel_AliasAssignment_3_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "as"
protected class GeneratedMetamodel_AsKeyword_3_0 extends KeywordToken  {
	
	public GeneratedMetamodel_AsKeyword_3_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getGeneratedMetamodelAccess().getAsKeyword_3_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new GeneratedMetamodel_EPackageAssignment_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// alias=ID
protected class GeneratedMetamodel_AliasAssignment_3_1 extends AssignmentToken  {
	
	public GeneratedMetamodel_AliasAssignment_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getGeneratedMetamodelAccess().getAliasAssignment_3_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new GeneratedMetamodel_AsKeyword_3_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("alias",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("alias");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getGeneratedMetamodelAccess().getAliasIDTerminalRuleCall_3_1_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getGeneratedMetamodelAccess().getAliasIDTerminalRuleCall_3_1_0();
			return obj;
		}
		return null;
	}

}



/************ end Rule GeneratedMetamodel ****************/


/************ begin Rule ReferencedMetamodel ****************
 *
 * // referenced metamodels may share aliases with other referenced metamodels
 * // and with generated metamodels
 * ReferencedMetamodel:
 * 	"import" ePackage=[ecore::EPackage|STRING] ("as" alias=ID)?;
 *
 **/

// "import" ePackage=[ecore::EPackage|STRING] ("as" alias=ID)?
protected class ReferencedMetamodel_Group extends GroupToken {
	
	public ReferencedMetamodel_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getReferencedMetamodelAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ReferencedMetamodel_Group_2(lastRuleCallOrigin, this, 0, inst);
			case 1: return new ReferencedMetamodel_EPackageAssignment_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getReferencedMetamodelRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "import"
protected class ReferencedMetamodel_ImportKeyword_0 extends KeywordToken  {
	
	public ReferencedMetamodel_ImportKeyword_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getReferencedMetamodelAccess().getImportKeyword_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// ePackage=[ecore::EPackage|STRING]
protected class ReferencedMetamodel_EPackageAssignment_1 extends AssignmentToken  {
	
	public ReferencedMetamodel_EPackageAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getReferencedMetamodelAccess().getEPackageAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ReferencedMetamodel_ImportKeyword_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("ePackage",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("ePackage");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getReferencedMetamodelAccess().getEPackageEPackageCrossReference_1_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getReferencedMetamodelAccess().getEPackageEPackageCrossReference_1_0(); 
				return obj;
			}
		}
		return null;
	}

}

// ("as" alias=ID)?
protected class ReferencedMetamodel_Group_2 extends GroupToken {
	
	public ReferencedMetamodel_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getReferencedMetamodelAccess().getGroup_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ReferencedMetamodel_AliasAssignment_2_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "as"
protected class ReferencedMetamodel_AsKeyword_2_0 extends KeywordToken  {
	
	public ReferencedMetamodel_AsKeyword_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getReferencedMetamodelAccess().getAsKeyword_2_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ReferencedMetamodel_EPackageAssignment_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// alias=ID
protected class ReferencedMetamodel_AliasAssignment_2_1 extends AssignmentToken  {
	
	public ReferencedMetamodel_AliasAssignment_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getReferencedMetamodelAccess().getAliasAssignment_2_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ReferencedMetamodel_AsKeyword_2_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("alias",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("alias");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getReferencedMetamodelAccess().getAliasIDTerminalRuleCall_2_1_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getReferencedMetamodelAccess().getAliasIDTerminalRuleCall_2_1_0();
			return obj;
		}
		return null;
	}

}



/************ end Rule ReferencedMetamodel ****************/


/************ begin Rule ParserRule ****************
 *
 * ParserRule:
 * 	name=ID ("returns" type=TypeRef)? (definesHiddenTokens?="hidden" "(" (hiddenTokens+=[AbstractRule] (","
 * 	hiddenTokens+=[AbstractRule])*)? ")")? ":" alternatives=Alternatives ";";
 *
 **/

// name=ID ("returns" type=TypeRef)? (definesHiddenTokens?="hidden" "(" (hiddenTokens+=[AbstractRule] (","
// hiddenTokens+=[AbstractRule])*)? ")")? ":" alternatives=Alternatives ";"
protected class ParserRule_Group extends GroupToken {
	
	public ParserRule_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_SemicolonKeyword_5(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getParserRuleRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// name=ID
protected class ParserRule_NameAssignment_0 extends AssignmentToken  {
	
	public ParserRule_NameAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getNameAssignment_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getParserRuleAccess().getNameIDTerminalRuleCall_0_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getParserRuleAccess().getNameIDTerminalRuleCall_0_0();
			return obj;
		}
		return null;
	}

}

// ("returns" type=TypeRef)?
protected class ParserRule_Group_1 extends GroupToken {
	
	public ParserRule_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_TypeAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "returns"
protected class ParserRule_ReturnsKeyword_1_0 extends KeywordToken  {
	
	public ParserRule_ReturnsKeyword_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getReturnsKeyword_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_NameAssignment_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// type=TypeRef
protected class ParserRule_TypeAssignment_1_1 extends AssignmentToken  {
	
	public ParserRule_TypeAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getTypeAssignment_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TypeRef_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("type",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("type");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTypeRefRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getParserRuleAccess().getTypeTypeRefParserRuleCall_1_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new ParserRule_ReturnsKeyword_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


// (definesHiddenTokens?="hidden" "(" (hiddenTokens+=[AbstractRule] ("," hiddenTokens+=[AbstractRule])*)? ")")?
protected class ParserRule_Group_2 extends GroupToken {
	
	public ParserRule_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getGroup_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_RightParenthesisKeyword_2_3(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// definesHiddenTokens?="hidden"
protected class ParserRule_DefinesHiddenTokensAssignment_2_0 extends AssignmentToken  {
	
	public ParserRule_DefinesHiddenTokensAssignment_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getDefinesHiddenTokensAssignment_2_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new ParserRule_NameAssignment_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("definesHiddenTokens",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("definesHiddenTokens");
		if(Boolean.TRUE.equals(value)) { // org::eclipse::xtext::impl::KeywordImpl
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getParserRuleAccess().getDefinesHiddenTokensHiddenKeyword_2_0_0();
			return obj;
		}
		return null;
	}

}

// "("
protected class ParserRule_LeftParenthesisKeyword_2_1 extends KeywordToken  {
	
	public ParserRule_LeftParenthesisKeyword_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getLeftParenthesisKeyword_2_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_DefinesHiddenTokensAssignment_2_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// (hiddenTokens+=[AbstractRule] ("," hiddenTokens+=[AbstractRule])*)?
protected class ParserRule_Group_2_2 extends GroupToken {
	
	public ParserRule_Group_2_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getGroup_2_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_Group_2_2_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new ParserRule_HiddenTokensAssignment_2_2_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// hiddenTokens+=[AbstractRule]
protected class ParserRule_HiddenTokensAssignment_2_2_0 extends AssignmentToken  {
	
	public ParserRule_HiddenTokensAssignment_2_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getHiddenTokensAssignment_2_2_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_LeftParenthesisKeyword_2_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("hiddenTokens",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("hiddenTokens");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getParserRuleAccess().getHiddenTokensAbstractRuleCrossReference_2_2_0_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getParserRuleAccess().getHiddenTokensAbstractRuleCrossReference_2_2_0_0(); 
				return obj;
			}
		}
		return null;
	}

}

// ("," hiddenTokens+=[AbstractRule])*
protected class ParserRule_Group_2_2_1 extends GroupToken {
	
	public ParserRule_Group_2_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getGroup_2_2_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_HiddenTokensAssignment_2_2_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// ","
protected class ParserRule_CommaKeyword_2_2_1_0 extends KeywordToken  {
	
	public ParserRule_CommaKeyword_2_2_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getCommaKeyword_2_2_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_Group_2_2_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new ParserRule_HiddenTokensAssignment_2_2_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// hiddenTokens+=[AbstractRule]
protected class ParserRule_HiddenTokensAssignment_2_2_1_1 extends AssignmentToken  {
	
	public ParserRule_HiddenTokensAssignment_2_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getHiddenTokensAssignment_2_2_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_CommaKeyword_2_2_1_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("hiddenTokens",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("hiddenTokens");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getParserRuleAccess().getHiddenTokensAbstractRuleCrossReference_2_2_1_1_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getParserRuleAccess().getHiddenTokensAbstractRuleCrossReference_2_2_1_1_0(); 
				return obj;
			}
		}
		return null;
	}

}



// ")"
protected class ParserRule_RightParenthesisKeyword_2_3 extends KeywordToken  {
	
	public ParserRule_RightParenthesisKeyword_2_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getRightParenthesisKeyword_2_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_Group_2_2(lastRuleCallOrigin, this, 0, inst);
			case 1: return new ParserRule_LeftParenthesisKeyword_2_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}


// ":"
protected class ParserRule_ColonKeyword_3 extends KeywordToken  {
	
	public ParserRule_ColonKeyword_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getColonKeyword_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_Group_2(lastRuleCallOrigin, this, 0, inst);
			case 1: return new ParserRule_Group_1(lastRuleCallOrigin, this, 1, inst);
			case 2: return new ParserRule_NameAssignment_0(lastRuleCallOrigin, this, 2, inst);
			default: return null;
		}	
	}

}

// alternatives=Alternatives
protected class ParserRule_AlternativesAssignment_4 extends AssignmentToken  {
	
	public ParserRule_AlternativesAssignment_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getAlternativesAssignment_4();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Alternatives_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("alternatives",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("alternatives");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getAlternativesRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getParserRuleAccess().getAlternativesAlternativesParserRuleCall_4_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new ParserRule_ColonKeyword_3(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// ";"
protected class ParserRule_SemicolonKeyword_5 extends KeywordToken  {
	
	public ParserRule_SemicolonKeyword_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getParserRuleAccess().getSemicolonKeyword_5();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParserRule_AlternativesAssignment_4(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


/************ end Rule ParserRule ****************/


/************ begin Rule TypeRef ****************
 *
 * TypeRef:
 * 	(metamodel=[AbstractMetamodelDeclaration] "::")? classifier=[ecore::EClassifier];
 *
 **/

// (metamodel=[AbstractMetamodelDeclaration] "::")? classifier=[ecore::EClassifier]
protected class TypeRef_Group extends GroupToken {
	
	public TypeRef_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTypeRefAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TypeRef_ClassifierAssignment_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getTypeRefRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// (metamodel=[AbstractMetamodelDeclaration] "::")?
protected class TypeRef_Group_0 extends GroupToken {
	
	public TypeRef_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTypeRefAccess().getGroup_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TypeRef_ColonColonKeyword_0_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// metamodel=[AbstractMetamodelDeclaration]
protected class TypeRef_MetamodelAssignment_0_0 extends AssignmentToken  {
	
	public TypeRef_MetamodelAssignment_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTypeRefAccess().getMetamodelAssignment_0_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("metamodel",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("metamodel");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTypeRefAccess().getMetamodelAbstractMetamodelDeclarationCrossReference_0_0_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getTypeRefAccess().getMetamodelAbstractMetamodelDeclarationCrossReference_0_0_0(); 
				return obj;
			}
		}
		return null;
	}

}

// "::"
protected class TypeRef_ColonColonKeyword_0_1 extends KeywordToken  {
	
	public TypeRef_ColonColonKeyword_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getTypeRefAccess().getColonColonKeyword_0_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TypeRef_MetamodelAssignment_0_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


// classifier=[ecore::EClassifier]
protected class TypeRef_ClassifierAssignment_1 extends AssignmentToken  {
	
	public TypeRef_ClassifierAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTypeRefAccess().getClassifierAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TypeRef_Group_0(lastRuleCallOrigin, this, 0, inst);
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index - 1, inst);
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("classifier",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("classifier");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTypeRefAccess().getClassifierEClassifierCrossReference_1_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getTypeRefAccess().getClassifierEClassifierCrossReference_1_0(); 
				return obj;
			}
		}
		return null;
	}

}


/************ end Rule TypeRef ****************/


/************ begin Rule Alternatives ****************
 *
 * Alternatives returns AbstractElement:
 * 	UnorderedGroup ({Alternatives.elements+=current} ("|" elements+=UnorderedGroup)+)?;
 *
 **/

// UnorderedGroup ({Alternatives.elements+=current} ("|" elements+=UnorderedGroup)+)?
protected class Alternatives_Group extends GroupToken {
	
	public Alternatives_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAlternativesAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Alternatives_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Alternatives_UnorderedGroupParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getActionRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedGroupRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedRuleCallRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnorderedGroupAccess().getUnorderedGroupElementsAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// UnorderedGroup
protected class Alternatives_UnorderedGroupParserRuleCall_0 extends RuleCallToken {
	
	public Alternatives_UnorderedGroupParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAlternativesAccess().getUnorderedGroupParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UnorderedGroup_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(UnorderedGroup_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ({Alternatives.elements+=current} ("|" elements+=UnorderedGroup)+)?
protected class Alternatives_Group_1 extends GroupToken {
	
	public Alternatives_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAlternativesAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Alternatives_Group_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Alternatives.elements+=current}
protected class Alternatives_AlternativesElementsAction_1_0 extends ActionToken  {

	public Alternatives_AlternativesElementsAction_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getAlternativesAccess().getAlternativesElementsAction_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Alternatives_UnorderedGroupParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("elements", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("elements")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// ("|" elements+=UnorderedGroup)+
protected class Alternatives_Group_1_1 extends GroupToken {
	
	public Alternatives_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAlternativesAccess().getGroup_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Alternatives_ElementsAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "|"
protected class Alternatives_VerticalLineKeyword_1_1_0 extends KeywordToken  {
	
	public Alternatives_VerticalLineKeyword_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getAlternativesAccess().getVerticalLineKeyword_1_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Alternatives_Group_1_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Alternatives_AlternativesElementsAction_1_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// elements+=UnorderedGroup
protected class Alternatives_ElementsAssignment_1_1_1 extends AssignmentToken  {
	
	public Alternatives_ElementsAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getAlternativesAccess().getElementsAssignment_1_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UnorderedGroup_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("elements",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("elements");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getUnorderedGroupRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getAlternativesAccess().getElementsUnorderedGroupParserRuleCall_1_1_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new Alternatives_VerticalLineKeyword_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}




/************ end Rule Alternatives ****************/


/************ begin Rule UnorderedGroup ****************
 *
 * UnorderedGroup returns AbstractElement:
 * 	Group ({UnorderedGroup.elements+=current} ("&" elements+=Group)+)?;
 *
 **/

// Group ({UnorderedGroup.elements+=current} ("&" elements+=Group)+)?
protected class UnorderedGroup_Group extends GroupToken {
	
	public UnorderedGroup_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getUnorderedGroupAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UnorderedGroup_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new UnorderedGroup_GroupParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getActionRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedGroupRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedRuleCallRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnorderedGroupAccess().getUnorderedGroupElementsAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// Group
protected class UnorderedGroup_GroupParserRuleCall_0 extends RuleCallToken {
	
	public UnorderedGroup_GroupParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getUnorderedGroupAccess().getGroupParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Group_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(Group_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ({UnorderedGroup.elements+=current} ("&" elements+=Group)+)?
protected class UnorderedGroup_Group_1 extends GroupToken {
	
	public UnorderedGroup_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getUnorderedGroupAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UnorderedGroup_Group_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getUnorderedGroupAccess().getUnorderedGroupElementsAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {UnorderedGroup.elements+=current}
protected class UnorderedGroup_UnorderedGroupElementsAction_1_0 extends ActionToken  {

	public UnorderedGroup_UnorderedGroupElementsAction_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getUnorderedGroupAccess().getUnorderedGroupElementsAction_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UnorderedGroup_GroupParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("elements", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("elements")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// ("&" elements+=Group)+
protected class UnorderedGroup_Group_1_1 extends GroupToken {
	
	public UnorderedGroup_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getUnorderedGroupAccess().getGroup_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UnorderedGroup_ElementsAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "&"
protected class UnorderedGroup_AmpersandKeyword_1_1_0 extends KeywordToken  {
	
	public UnorderedGroup_AmpersandKeyword_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getUnorderedGroupAccess().getAmpersandKeyword_1_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UnorderedGroup_Group_1_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new UnorderedGroup_UnorderedGroupElementsAction_1_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// elements+=Group
protected class UnorderedGroup_ElementsAssignment_1_1_1 extends AssignmentToken  {
	
	public UnorderedGroup_ElementsAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getUnorderedGroupAccess().getElementsAssignment_1_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Group_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("elements",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("elements");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getGroupRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getUnorderedGroupAccess().getElementsGroupParserRuleCall_1_1_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new UnorderedGroup_AmpersandKeyword_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}




/************ end Rule UnorderedGroup ****************/


/************ begin Rule Group ****************
 *
 * Group returns AbstractElement:
 * 	AbstractToken ({Group.elements+=current} elements+=AbstractToken+)?;
 *
 **/

// AbstractToken ({Group.elements+=current} elements+=AbstractToken+)?
protected class Group_Group extends GroupToken {
	
	public Group_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getGroupAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Group_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Group_AbstractTokenParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getActionRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedGroupRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedRuleCallRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnorderedGroupAccess().getUnorderedGroupElementsAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// AbstractToken
protected class Group_AbstractTokenParserRuleCall_0 extends RuleCallToken {
	
	public Group_AbstractTokenParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getGroupAccess().getAbstractTokenParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractToken_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(AbstractToken_Alternatives.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ({Group.elements+=current} elements+=AbstractToken+)?
protected class Group_Group_1 extends GroupToken {
	
	public Group_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getGroupAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Group_ElementsAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getGroupAccess().getGroupElementsAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Group.elements+=current}
protected class Group_GroupElementsAction_1_0 extends ActionToken  {

	public Group_GroupElementsAction_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getGroupAccess().getGroupElementsAction_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Group_AbstractTokenParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("elements", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("elements")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// elements+=AbstractToken+
protected class Group_ElementsAssignment_1_1 extends AssignmentToken  {
	
	public Group_ElementsAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getGroupAccess().getElementsAssignment_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractToken_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("elements",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("elements");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getAbstractTokenRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getGroupAccess().getElementsAbstractTokenParserRuleCall_1_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new Group_ElementsAssignment_1_1(lastRuleCallOrigin, next, actIndex, consumed);
			case 1: return new Group_GroupElementsAction_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}



/************ end Rule Group ****************/


/************ begin Rule AbstractToken ****************
 *
 * AbstractToken returns AbstractElement:
 * 	AbstractTokenWithCardinality | Action;
 *
 **/

// AbstractTokenWithCardinality | Action
protected class AbstractToken_Alternatives extends AlternativesToken {

	public AbstractToken_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getAbstractTokenAccess().getAlternatives();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractToken_AbstractTokenWithCardinalityParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AbstractToken_ActionParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getActionRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedGroupRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedRuleCallRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnorderedGroupAccess().getUnorderedGroupElementsAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// AbstractTokenWithCardinality
protected class AbstractToken_AbstractTokenWithCardinalityParserRuleCall_0 extends RuleCallToken {
	
	public AbstractToken_AbstractTokenWithCardinalityParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractTokenAccess().getAbstractTokenWithCardinalityParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractTokenWithCardinality_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(AbstractTokenWithCardinality_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// Action
protected class AbstractToken_ActionParserRuleCall_1 extends RuleCallToken {
	
	public AbstractToken_ActionParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractTokenAccess().getActionParserRuleCall_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Action_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getActionRule().getType().getClassifier())
			return null;
		if(checkForRecursion(Action_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}


/************ end Rule AbstractToken ****************/


/************ begin Rule AbstractTokenWithCardinality ****************
 *
 * AbstractTokenWithCardinality returns AbstractElement:
 * 	(Assignment | AbstractTerminal) cardinality=("?" | "*" | "+")?;
 *
 **/

// (Assignment | AbstractTerminal) cardinality=("?" | "*" | "+")?
protected class AbstractTokenWithCardinality_Group extends GroupToken {
	
	public AbstractTokenWithCardinality_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAbstractTokenWithCardinalityAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractTokenWithCardinality_CardinalityAssignment_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AbstractTokenWithCardinality_Alternatives_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getActionRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedGroupRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedRuleCallRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnorderedGroupAccess().getUnorderedGroupElementsAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// Assignment | AbstractTerminal
protected class AbstractTokenWithCardinality_Alternatives_0 extends AlternativesToken {

	public AbstractTokenWithCardinality_Alternatives_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getAbstractTokenWithCardinalityAccess().getAlternatives_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractTokenWithCardinality_AssignmentParserRuleCall_0_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AbstractTokenWithCardinality_AbstractTerminalParserRuleCall_0_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// Assignment
protected class AbstractTokenWithCardinality_AssignmentParserRuleCall_0_0 extends RuleCallToken {
	
	public AbstractTokenWithCardinality_AssignmentParserRuleCall_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractTokenWithCardinalityAccess().getAssignmentParserRuleCall_0_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Assignment_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier())
			return null;
		if(checkForRecursion(Assignment_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// AbstractTerminal
protected class AbstractTokenWithCardinality_AbstractTerminalParserRuleCall_0_1 extends RuleCallToken {
	
	public AbstractTokenWithCardinality_AbstractTerminalParserRuleCall_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractTokenWithCardinalityAccess().getAbstractTerminalParserRuleCall_0_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractTerminal_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(AbstractTerminal_Alternatives.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}


// cardinality=("?" | "*" | "+")?
protected class AbstractTokenWithCardinality_CardinalityAssignment_1 extends AssignmentToken  {
	
	public AbstractTokenWithCardinality_CardinalityAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getAbstractTokenWithCardinalityAccess().getCardinalityAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractTokenWithCardinality_Alternatives_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("cardinality",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("cardinality");
		if(keywordSerializer.isValid(obj.getEObject(), grammarAccess.getAbstractTokenWithCardinalityAccess().getCardinalityQuestionMarkKeyword_1_0_0(), value, null)) {
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getAbstractTokenWithCardinalityAccess().getCardinalityQuestionMarkKeyword_1_0_0();
			return obj;
		}
		if(keywordSerializer.isValid(obj.getEObject(), grammarAccess.getAbstractTokenWithCardinalityAccess().getCardinalityAsteriskKeyword_1_0_1(), value, null)) {
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getAbstractTokenWithCardinalityAccess().getCardinalityAsteriskKeyword_1_0_1();
			return obj;
		}
		if(keywordSerializer.isValid(obj.getEObject(), grammarAccess.getAbstractTokenWithCardinalityAccess().getCardinalityPlusSignKeyword_1_0_2(), value, null)) {
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getAbstractTokenWithCardinalityAccess().getCardinalityPlusSignKeyword_1_0_2();
			return obj;
		}
		return null;
	}

}


/************ end Rule AbstractTokenWithCardinality ****************/


/************ begin Rule Action ****************
 *
 * Action:
 * 	"{" type=TypeRef ("." feature=ID operator=("=" | "+=") "current")? "}";
 *
 **/

// "{" type=TypeRef ("." feature=ID operator=("=" | "+=") "current")? "}"
protected class Action_Group extends GroupToken {
	
	public Action_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getActionAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Action_RightCurlyBracketKeyword_3(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getActionRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "{"
protected class Action_LeftCurlyBracketKeyword_0 extends KeywordToken  {
	
	public Action_LeftCurlyBracketKeyword_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getActionAccess().getLeftCurlyBracketKeyword_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// type=TypeRef
protected class Action_TypeAssignment_1 extends AssignmentToken  {
	
	public Action_TypeAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getActionAccess().getTypeAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TypeRef_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("type",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("type");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTypeRefRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getActionAccess().getTypeTypeRefParserRuleCall_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new Action_LeftCurlyBracketKeyword_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// ("." feature=ID operator=("=" | "+=") "current")?
protected class Action_Group_2 extends GroupToken {
	
	public Action_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getActionAccess().getGroup_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Action_CurrentKeyword_2_3(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "."
protected class Action_FullStopKeyword_2_0 extends KeywordToken  {
	
	public Action_FullStopKeyword_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getActionAccess().getFullStopKeyword_2_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Action_TypeAssignment_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// feature=ID
protected class Action_FeatureAssignment_2_1 extends AssignmentToken  {
	
	public Action_FeatureAssignment_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getActionAccess().getFeatureAssignment_2_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Action_FullStopKeyword_2_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("feature",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("feature");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getActionAccess().getFeatureIDTerminalRuleCall_2_1_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getActionAccess().getFeatureIDTerminalRuleCall_2_1_0();
			return obj;
		}
		return null;
	}

}

// operator=("=" | "+=")
protected class Action_OperatorAssignment_2_2 extends AssignmentToken  {
	
	public Action_OperatorAssignment_2_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getActionAccess().getOperatorAssignment_2_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Action_FeatureAssignment_2_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
		if(keywordSerializer.isValid(obj.getEObject(), grammarAccess.getActionAccess().getOperatorEqualsSignKeyword_2_2_0_0(), value, null)) {
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getActionAccess().getOperatorEqualsSignKeyword_2_2_0_0();
			return obj;
		}
		if(keywordSerializer.isValid(obj.getEObject(), grammarAccess.getActionAccess().getOperatorPlusSignEqualsSignKeyword_2_2_0_1(), value, null)) {
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getActionAccess().getOperatorPlusSignEqualsSignKeyword_2_2_0_1();
			return obj;
		}
		return null;
	}

}

// "current"
protected class Action_CurrentKeyword_2_3 extends KeywordToken  {
	
	public Action_CurrentKeyword_2_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getActionAccess().getCurrentKeyword_2_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Action_OperatorAssignment_2_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


// "}"
protected class Action_RightCurlyBracketKeyword_3 extends KeywordToken  {
	
	public Action_RightCurlyBracketKeyword_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getActionAccess().getRightCurlyBracketKeyword_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Action_Group_2(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Action_TypeAssignment_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}


/************ end Rule Action ****************/


/************ begin Rule AbstractTerminal ****************
 *
 * AbstractTerminal returns AbstractElement:
 * 	Keyword | RuleCall | ParenthesizedElement | // Keyword and RuleCall are used inside of Assignable terminal
 * 	// As we do not want to be able to write name==>ID
 * 	// the rules for Keyword and RuleCall have been copied
 * 	PredicatedKeyword | PredicatedRuleCall | // We have to make this one explicit since the ParenthesizedElement does not
 * 	// create an object but we have to set the predicated flag
 * 	// TODO: As soon as we have an own element for parenthesized elements with
 * 	// cardinality, we should refactor this part of the grammar
 * 	PredicatedGroup;
 *
 **/

// Keyword | RuleCall | ParenthesizedElement | // Keyword and RuleCall are used inside of Assignable terminal
// // As we do not want to be able to write name==>ID
// // the rules for Keyword and RuleCall have been copied
// PredicatedKeyword | PredicatedRuleCall | // We have to make this one explicit since the ParenthesizedElement does not
// // create an object but we have to set the predicated flag
// // TODO: As soon as we have an own element for parenthesized elements with
// // cardinality, we should refactor this part of the grammar
// PredicatedGroup
protected class AbstractTerminal_Alternatives extends AlternativesToken {

	public AbstractTerminal_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getAbstractTerminalAccess().getAlternatives();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractTerminal_KeywordParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AbstractTerminal_RuleCallParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
			case 2: return new AbstractTerminal_ParenthesizedElementParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
			case 3: return new AbstractTerminal_PredicatedKeywordParserRuleCall_3(lastRuleCallOrigin, this, 3, inst);
			case 4: return new AbstractTerminal_PredicatedRuleCallParserRuleCall_4(lastRuleCallOrigin, this, 4, inst);
			case 5: return new AbstractTerminal_PredicatedGroupParserRuleCall_5(lastRuleCallOrigin, this, 5, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getActionRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedGroupRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedRuleCallRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnorderedGroupAccess().getUnorderedGroupElementsAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// Keyword
protected class AbstractTerminal_KeywordParserRuleCall_0 extends RuleCallToken {
	
	public AbstractTerminal_KeywordParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractTerminalAccess().getKeywordParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Keyword_ValueAssignment(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier())
			return null;
		if(checkForRecursion(Keyword_ValueAssignment.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// RuleCall
protected class AbstractTerminal_RuleCallParserRuleCall_1 extends RuleCallToken {
	
	public AbstractTerminal_RuleCallParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractTerminalAccess().getRuleCallParserRuleCall_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new RuleCall_RuleAssignment(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getRuleCallRule().getType().getClassifier())
			return null;
		if(checkForRecursion(RuleCall_RuleAssignment.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ParenthesizedElement
protected class AbstractTerminal_ParenthesizedElementParserRuleCall_2 extends RuleCallToken {
	
	public AbstractTerminal_ParenthesizedElementParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractTerminalAccess().getParenthesizedElementParserRuleCall_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParenthesizedElement_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(ParenthesizedElement_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// // Keyword and RuleCall are used inside of Assignable terminal
// // As we do not want to be able to write name==>ID
// // the rules for Keyword and RuleCall have been copied
// PredicatedKeyword
protected class AbstractTerminal_PredicatedKeywordParserRuleCall_3 extends RuleCallToken {
	
	public AbstractTerminal_PredicatedKeywordParserRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractTerminalAccess().getPredicatedKeywordParserRuleCall_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PredicatedKeyword_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getPredicatedKeywordRule().getType().getClassifier())
			return null;
		if(checkForRecursion(PredicatedKeyword_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// PredicatedRuleCall
protected class AbstractTerminal_PredicatedRuleCallParserRuleCall_4 extends RuleCallToken {
	
	public AbstractTerminal_PredicatedRuleCallParserRuleCall_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractTerminalAccess().getPredicatedRuleCallParserRuleCall_4();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PredicatedRuleCall_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getPredicatedRuleCallRule().getType().getClassifier())
			return null;
		if(checkForRecursion(PredicatedRuleCall_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// // We have to make this one explicit since the ParenthesizedElement does not
// // create an object but we have to set the predicated flag
// // TODO: As soon as we have an own element for parenthesized elements with
// // cardinality, we should refactor this part of the grammar
// PredicatedGroup
protected class AbstractTerminal_PredicatedGroupParserRuleCall_5 extends RuleCallToken {
	
	public AbstractTerminal_PredicatedGroupParserRuleCall_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractTerminalAccess().getPredicatedGroupParserRuleCall_5();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PredicatedGroup_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getPredicatedGroupRule().getType().getClassifier())
			return null;
		if(checkForRecursion(PredicatedGroup_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}


/************ end Rule AbstractTerminal ****************/


/************ begin Rule Keyword ****************
 *
 * Keyword:
 * 	value=STRING;
 *
 **/

// value=STRING
protected class Keyword_ValueAssignment extends AssignmentToken  {
	
	public Keyword_ValueAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getKeywordAccess().getValueAssignment();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("value",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("value");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getKeywordAccess().getValueSTRINGTerminalRuleCall_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getKeywordAccess().getValueSTRINGTerminalRuleCall_0();
			return obj;
		}
		return null;
	}

}

/************ end Rule Keyword ****************/


/************ begin Rule RuleCall ****************
 *
 * RuleCall:
 * 	rule=[AbstractRule];
 *
 **/

// rule=[AbstractRule]
protected class RuleCall_RuleAssignment extends AssignmentToken  {
	
	public RuleCall_RuleAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getRuleCallAccess().getRuleAssignment();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getRuleCallRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("rule",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("rule");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getRuleCallAccess().getRuleAbstractRuleCrossReference_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getRuleCallAccess().getRuleAbstractRuleCrossReference_0(); 
				return obj;
			}
		}
		return null;
	}

}

/************ end Rule RuleCall ****************/


/************ begin Rule PredicatedKeyword ****************
 *
 * PredicatedKeyword returns Keyword:
 * 	predicated?="=>" value=STRING;
 *
 **/

// predicated?="=>" value=STRING
protected class PredicatedKeyword_Group extends GroupToken {
	
	public PredicatedKeyword_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getPredicatedKeywordAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PredicatedKeyword_ValueAssignment_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getPredicatedKeywordRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// predicated?="=>"
protected class PredicatedKeyword_PredicatedAssignment_0 extends AssignmentToken  {
	
	public PredicatedKeyword_PredicatedAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getPredicatedKeywordAccess().getPredicatedAssignment_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("predicated",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("predicated");
		if(Boolean.TRUE.equals(value)) { // org::eclipse::xtext::impl::KeywordImpl
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getPredicatedKeywordAccess().getPredicatedEqualsSignGreaterThanSignKeyword_0_0();
			return obj;
		}
		return null;
	}

}

// value=STRING
protected class PredicatedKeyword_ValueAssignment_1 extends AssignmentToken  {
	
	public PredicatedKeyword_ValueAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getPredicatedKeywordAccess().getValueAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PredicatedKeyword_PredicatedAssignment_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("value",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("value");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getPredicatedKeywordAccess().getValueSTRINGTerminalRuleCall_1_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getPredicatedKeywordAccess().getValueSTRINGTerminalRuleCall_1_0();
			return obj;
		}
		return null;
	}

}


/************ end Rule PredicatedKeyword ****************/


/************ begin Rule PredicatedRuleCall ****************
 *
 * PredicatedRuleCall returns RuleCall:
 * 	predicated?="=>" rule=[AbstractRule];
 *
 **/

// predicated?="=>" rule=[AbstractRule]
protected class PredicatedRuleCall_Group extends GroupToken {
	
	public PredicatedRuleCall_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getPredicatedRuleCallAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PredicatedRuleCall_RuleAssignment_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getPredicatedRuleCallRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// predicated?="=>"
protected class PredicatedRuleCall_PredicatedAssignment_0 extends AssignmentToken  {
	
	public PredicatedRuleCall_PredicatedAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getPredicatedRuleCallAccess().getPredicatedAssignment_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("predicated",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("predicated");
		if(Boolean.TRUE.equals(value)) { // org::eclipse::xtext::impl::KeywordImpl
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getPredicatedRuleCallAccess().getPredicatedEqualsSignGreaterThanSignKeyword_0_0();
			return obj;
		}
		return null;
	}

}

// rule=[AbstractRule]
protected class PredicatedRuleCall_RuleAssignment_1 extends AssignmentToken  {
	
	public PredicatedRuleCall_RuleAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getPredicatedRuleCallAccess().getRuleAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PredicatedRuleCall_PredicatedAssignment_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("rule",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("rule");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getPredicatedRuleCallAccess().getRuleAbstractRuleCrossReference_1_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getPredicatedRuleCallAccess().getRuleAbstractRuleCrossReference_1_0(); 
				return obj;
			}
		}
		return null;
	}

}


/************ end Rule PredicatedRuleCall ****************/


/************ begin Rule Assignment ****************
 *
 * Assignment:
 * 	predicated?="=>"? feature=ID operator=("+=" | "=" | "?=") ^terminal=AssignableTerminal;
 *
 **/

// predicated?="=>"? feature=ID operator=("+=" | "=" | "?=") ^terminal=AssignableTerminal
protected class Assignment_Group extends GroupToken {
	
	public Assignment_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAssignmentAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Assignment_TerminalAssignment_3(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// predicated?="=>"?
protected class Assignment_PredicatedAssignment_0 extends AssignmentToken  {
	
	public Assignment_PredicatedAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getAssignmentAccess().getPredicatedAssignment_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("predicated",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("predicated");
		if(Boolean.TRUE.equals(value)) { // org::eclipse::xtext::impl::KeywordImpl
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getAssignmentAccess().getPredicatedEqualsSignGreaterThanSignKeyword_0_0();
			return obj;
		}
		return null;
	}

}

// feature=ID
protected class Assignment_FeatureAssignment_1 extends AssignmentToken  {
	
	public Assignment_FeatureAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getAssignmentAccess().getFeatureAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Assignment_PredicatedAssignment_0(lastRuleCallOrigin, this, 0, inst);
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index - 1, inst);
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("feature",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("feature");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getAssignmentAccess().getFeatureIDTerminalRuleCall_1_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getAssignmentAccess().getFeatureIDTerminalRuleCall_1_0();
			return obj;
		}
		return null;
	}

}

// operator=("+=" | "=" | "?=")
protected class Assignment_OperatorAssignment_2 extends AssignmentToken  {
	
	public Assignment_OperatorAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getAssignmentAccess().getOperatorAssignment_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Assignment_FeatureAssignment_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
		if(keywordSerializer.isValid(obj.getEObject(), grammarAccess.getAssignmentAccess().getOperatorPlusSignEqualsSignKeyword_2_0_0(), value, null)) {
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getAssignmentAccess().getOperatorPlusSignEqualsSignKeyword_2_0_0();
			return obj;
		}
		if(keywordSerializer.isValid(obj.getEObject(), grammarAccess.getAssignmentAccess().getOperatorEqualsSignKeyword_2_0_1(), value, null)) {
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getAssignmentAccess().getOperatorEqualsSignKeyword_2_0_1();
			return obj;
		}
		if(keywordSerializer.isValid(obj.getEObject(), grammarAccess.getAssignmentAccess().getOperatorQuestionMarkEqualsSignKeyword_2_0_2(), value, null)) {
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getAssignmentAccess().getOperatorQuestionMarkEqualsSignKeyword_2_0_2();
			return obj;
		}
		return null;
	}

}

// ^terminal=AssignableTerminal
protected class Assignment_TerminalAssignment_3 extends AssignmentToken  {
	
	public Assignment_TerminalAssignment_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getAssignmentAccess().getTerminalAssignment_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AssignableTerminal_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("terminal",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("terminal");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getAssignableTerminalRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getAssignmentAccess().getTerminalAssignableTerminalParserRuleCall_3_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new Assignment_OperatorAssignment_2(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


/************ end Rule Assignment ****************/


/************ begin Rule AssignableTerminal ****************
 *
 * AssignableTerminal returns AbstractElement:
 * 	Keyword | RuleCall | ParenthesizedAssignableElement | CrossReference;
 *
 **/

// Keyword | RuleCall | ParenthesizedAssignableElement | CrossReference
protected class AssignableTerminal_Alternatives extends AlternativesToken {

	public AssignableTerminal_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getAssignableTerminalAccess().getAlternatives();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AssignableTerminal_KeywordParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AssignableTerminal_RuleCallParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
			case 2: return new AssignableTerminal_ParenthesizedAssignableElementParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
			case 3: return new AssignableTerminal_CrossReferenceParserRuleCall_3(lastRuleCallOrigin, this, 3, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAssignableAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getCrossReferenceRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getRuleCallRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// Keyword
protected class AssignableTerminal_KeywordParserRuleCall_0 extends RuleCallToken {
	
	public AssignableTerminal_KeywordParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAssignableTerminalAccess().getKeywordParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Keyword_ValueAssignment(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier())
			return null;
		if(checkForRecursion(Keyword_ValueAssignment.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// RuleCall
protected class AssignableTerminal_RuleCallParserRuleCall_1 extends RuleCallToken {
	
	public AssignableTerminal_RuleCallParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAssignableTerminalAccess().getRuleCallParserRuleCall_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new RuleCall_RuleAssignment(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getRuleCallRule().getType().getClassifier())
			return null;
		if(checkForRecursion(RuleCall_RuleAssignment.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ParenthesizedAssignableElement
protected class AssignableTerminal_ParenthesizedAssignableElementParserRuleCall_2 extends RuleCallToken {
	
	public AssignableTerminal_ParenthesizedAssignableElementParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAssignableTerminalAccess().getParenthesizedAssignableElementParserRuleCall_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParenthesizedAssignableElement_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(ParenthesizedAssignableElement_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// CrossReference
protected class AssignableTerminal_CrossReferenceParserRuleCall_3 extends RuleCallToken {
	
	public AssignableTerminal_CrossReferenceParserRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAssignableTerminalAccess().getCrossReferenceParserRuleCall_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CrossReference_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getCrossReferenceRule().getType().getClassifier())
			return null;
		if(checkForRecursion(CrossReference_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}


/************ end Rule AssignableTerminal ****************/


/************ begin Rule ParenthesizedAssignableElement ****************
 *
 * ParenthesizedAssignableElement returns AbstractElement:
 * 	"(" AssignableAlternatives ")";
 *
 **/

// "(" AssignableAlternatives ")"
protected class ParenthesizedAssignableElement_Group extends GroupToken {
	
	public ParenthesizedAssignableElement_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getParenthesizedAssignableElementAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParenthesizedAssignableElement_RightParenthesisKeyword_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAssignableAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getCrossReferenceRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getRuleCallRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "("
protected class ParenthesizedAssignableElement_LeftParenthesisKeyword_0 extends KeywordToken  {
	
	public ParenthesizedAssignableElement_LeftParenthesisKeyword_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getParenthesizedAssignableElementAccess().getLeftParenthesisKeyword_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// AssignableAlternatives
protected class ParenthesizedAssignableElement_AssignableAlternativesParserRuleCall_1 extends RuleCallToken {
	
	public ParenthesizedAssignableElement_AssignableAlternativesParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getParenthesizedAssignableElementAccess().getAssignableAlternativesParserRuleCall_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AssignableAlternatives_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(AssignableAlternatives_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParenthesizedAssignableElement_LeftParenthesisKeyword_0(lastRuleCallOrigin, next, actIndex, inst);
			default: return null;
		}	
	}	
}

// ")"
protected class ParenthesizedAssignableElement_RightParenthesisKeyword_2 extends KeywordToken  {
	
	public ParenthesizedAssignableElement_RightParenthesisKeyword_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getParenthesizedAssignableElementAccess().getRightParenthesisKeyword_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParenthesizedAssignableElement_AssignableAlternativesParserRuleCall_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


/************ end Rule ParenthesizedAssignableElement ****************/


/************ begin Rule AssignableAlternatives ****************
 *
 * AssignableAlternatives returns AbstractElement:
 * 	AssignableTerminal ({Alternatives.elements+=current} ("|" elements+=AssignableTerminal)+)?;
 *
 **/

// AssignableTerminal ({Alternatives.elements+=current} ("|" elements+=AssignableTerminal)+)?
protected class AssignableAlternatives_Group extends GroupToken {
	
	public AssignableAlternatives_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAssignableAlternativesAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AssignableAlternatives_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AssignableAlternatives_AssignableTerminalParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAssignableAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getCrossReferenceRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getRuleCallRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// AssignableTerminal
protected class AssignableAlternatives_AssignableTerminalParserRuleCall_0 extends RuleCallToken {
	
	public AssignableAlternatives_AssignableTerminalParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAssignableAlternativesAccess().getAssignableTerminalParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AssignableTerminal_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(AssignableTerminal_Alternatives.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ({Alternatives.elements+=current} ("|" elements+=AssignableTerminal)+)?
protected class AssignableAlternatives_Group_1 extends GroupToken {
	
	public AssignableAlternatives_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAssignableAlternativesAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AssignableAlternatives_Group_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAssignableAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Alternatives.elements+=current}
protected class AssignableAlternatives_AlternativesElementsAction_1_0 extends ActionToken  {

	public AssignableAlternatives_AlternativesElementsAction_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getAssignableAlternativesAccess().getAlternativesElementsAction_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AssignableAlternatives_AssignableTerminalParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("elements", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("elements")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// ("|" elements+=AssignableTerminal)+
protected class AssignableAlternatives_Group_1_1 extends GroupToken {
	
	public AssignableAlternatives_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAssignableAlternativesAccess().getGroup_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AssignableAlternatives_ElementsAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "|"
protected class AssignableAlternatives_VerticalLineKeyword_1_1_0 extends KeywordToken  {
	
	public AssignableAlternatives_VerticalLineKeyword_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getAssignableAlternativesAccess().getVerticalLineKeyword_1_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AssignableAlternatives_Group_1_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AssignableAlternatives_AlternativesElementsAction_1_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// elements+=AssignableTerminal
protected class AssignableAlternatives_ElementsAssignment_1_1_1 extends AssignmentToken  {
	
	public AssignableAlternatives_ElementsAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getAssignableAlternativesAccess().getElementsAssignment_1_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AssignableTerminal_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("elements",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("elements");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getAssignableTerminalRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getAssignableAlternativesAccess().getElementsAssignableTerminalParserRuleCall_1_1_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new AssignableAlternatives_VerticalLineKeyword_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}




/************ end Rule AssignableAlternatives ****************/


/************ begin Rule CrossReference ****************
 *
 * CrossReference:
 * 	"[" type=TypeRef ("|" ^terminal=CrossReferenceableTerminal)? "]";
 *
 **/

// "[" type=TypeRef ("|" ^terminal=CrossReferenceableTerminal)? "]"
protected class CrossReference_Group extends GroupToken {
	
	public CrossReference_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getCrossReferenceAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CrossReference_RightSquareBracketKeyword_3(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getCrossReferenceRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "["
protected class CrossReference_LeftSquareBracketKeyword_0 extends KeywordToken  {
	
	public CrossReference_LeftSquareBracketKeyword_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getCrossReferenceAccess().getLeftSquareBracketKeyword_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// type=TypeRef
protected class CrossReference_TypeAssignment_1 extends AssignmentToken  {
	
	public CrossReference_TypeAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getCrossReferenceAccess().getTypeAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TypeRef_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("type",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("type");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTypeRefRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getCrossReferenceAccess().getTypeTypeRefParserRuleCall_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new CrossReference_LeftSquareBracketKeyword_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// ("|" ^terminal=CrossReferenceableTerminal)?
protected class CrossReference_Group_2 extends GroupToken {
	
	public CrossReference_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getCrossReferenceAccess().getGroup_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CrossReference_TerminalAssignment_2_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "|"
protected class CrossReference_VerticalLineKeyword_2_0 extends KeywordToken  {
	
	public CrossReference_VerticalLineKeyword_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getCrossReferenceAccess().getVerticalLineKeyword_2_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CrossReference_TypeAssignment_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// ^terminal=CrossReferenceableTerminal
protected class CrossReference_TerminalAssignment_2_1 extends AssignmentToken  {
	
	public CrossReference_TerminalAssignment_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getCrossReferenceAccess().getTerminalAssignment_2_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CrossReferenceableTerminal_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("terminal",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("terminal");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getCrossReferenceableTerminalRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getCrossReferenceAccess().getTerminalCrossReferenceableTerminalParserRuleCall_2_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new CrossReference_VerticalLineKeyword_2_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


// "]"
protected class CrossReference_RightSquareBracketKeyword_3 extends KeywordToken  {
	
	public CrossReference_RightSquareBracketKeyword_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getCrossReferenceAccess().getRightSquareBracketKeyword_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CrossReference_Group_2(lastRuleCallOrigin, this, 0, inst);
			case 1: return new CrossReference_TypeAssignment_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}


/************ end Rule CrossReference ****************/


/************ begin Rule CrossReferenceableTerminal ****************
 *
 * CrossReferenceableTerminal returns AbstractElement:
 * 	Keyword | RuleCall;
 *
 **/

// Keyword | RuleCall
protected class CrossReferenceableTerminal_Alternatives extends AlternativesToken {

	public CrossReferenceableTerminal_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getCrossReferenceableTerminalAccess().getAlternatives();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CrossReferenceableTerminal_KeywordParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new CrossReferenceableTerminal_RuleCallParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getRuleCallRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// Keyword
protected class CrossReferenceableTerminal_KeywordParserRuleCall_0 extends RuleCallToken {
	
	public CrossReferenceableTerminal_KeywordParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getCrossReferenceableTerminalAccess().getKeywordParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Keyword_ValueAssignment(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier())
			return null;
		if(checkForRecursion(Keyword_ValueAssignment.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// RuleCall
protected class CrossReferenceableTerminal_RuleCallParserRuleCall_1 extends RuleCallToken {
	
	public CrossReferenceableTerminal_RuleCallParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getCrossReferenceableTerminalAccess().getRuleCallParserRuleCall_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new RuleCall_RuleAssignment(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getRuleCallRule().getType().getClassifier())
			return null;
		if(checkForRecursion(RuleCall_RuleAssignment.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}


/************ end Rule CrossReferenceableTerminal ****************/


/************ begin Rule ParenthesizedElement ****************
 *
 * ParenthesizedElement returns AbstractElement:
 * 	"(" Alternatives ")";
 *
 **/

// "(" Alternatives ")"
protected class ParenthesizedElement_Group extends GroupToken {
	
	public ParenthesizedElement_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getParenthesizedElementAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParenthesizedElement_RightParenthesisKeyword_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getActionRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedGroupRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPredicatedRuleCallRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnorderedGroupAccess().getUnorderedGroupElementsAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "("
protected class ParenthesizedElement_LeftParenthesisKeyword_0 extends KeywordToken  {
	
	public ParenthesizedElement_LeftParenthesisKeyword_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getParenthesizedElementAccess().getLeftParenthesisKeyword_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// Alternatives
protected class ParenthesizedElement_AlternativesParserRuleCall_1 extends RuleCallToken {
	
	public ParenthesizedElement_AlternativesParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getParenthesizedElementAccess().getAlternativesParserRuleCall_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Alternatives_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(Alternatives_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParenthesizedElement_LeftParenthesisKeyword_0(lastRuleCallOrigin, next, actIndex, inst);
			default: return null;
		}	
	}	
}

// ")"
protected class ParenthesizedElement_RightParenthesisKeyword_2 extends KeywordToken  {
	
	public ParenthesizedElement_RightParenthesisKeyword_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getParenthesizedElementAccess().getRightParenthesisKeyword_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParenthesizedElement_AlternativesParserRuleCall_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


/************ end Rule ParenthesizedElement ****************/


/************ begin Rule PredicatedGroup ****************
 *
 * PredicatedGroup returns Group:
 * 	predicated?="=>" "(" elements+=Alternatives ")";
 *
 **/

// predicated?="=>" "(" elements+=Alternatives ")"
protected class PredicatedGroup_Group extends GroupToken {
	
	public PredicatedGroup_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getPredicatedGroupAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PredicatedGroup_RightParenthesisKeyword_3(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getPredicatedGroupRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// predicated?="=>"
protected class PredicatedGroup_PredicatedAssignment_0 extends AssignmentToken  {
	
	public PredicatedGroup_PredicatedAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getPredicatedGroupAccess().getPredicatedAssignment_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("predicated",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("predicated");
		if(Boolean.TRUE.equals(value)) { // org::eclipse::xtext::impl::KeywordImpl
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getPredicatedGroupAccess().getPredicatedEqualsSignGreaterThanSignKeyword_0_0();
			return obj;
		}
		return null;
	}

}

// "("
protected class PredicatedGroup_LeftParenthesisKeyword_1 extends KeywordToken  {
	
	public PredicatedGroup_LeftParenthesisKeyword_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getPredicatedGroupAccess().getLeftParenthesisKeyword_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PredicatedGroup_PredicatedAssignment_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// elements+=Alternatives
protected class PredicatedGroup_ElementsAssignment_2 extends AssignmentToken  {
	
	public PredicatedGroup_ElementsAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getPredicatedGroupAccess().getElementsAssignment_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Alternatives_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("elements",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("elements");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getAlternativesRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getPredicatedGroupAccess().getElementsAlternativesParserRuleCall_2_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new PredicatedGroup_LeftParenthesisKeyword_1(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// ")"
protected class PredicatedGroup_RightParenthesisKeyword_3 extends KeywordToken  {
	
	public PredicatedGroup_RightParenthesisKeyword_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getPredicatedGroupAccess().getRightParenthesisKeyword_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PredicatedGroup_ElementsAssignment_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


/************ end Rule PredicatedGroup ****************/


/************ begin Rule TerminalRule ****************
 *
 * TerminalRule:
 * 	"terminal" (^fragment?="fragment" name=ID | name=ID ("returns" type=TypeRef)?) ":" alternatives=TerminalAlternatives
 * 	";";
 *
 **/

// "terminal" (^fragment?="fragment" name=ID | name=ID ("returns" type=TypeRef)?) ":" alternatives=TerminalAlternatives ";"
protected class TerminalRule_Group extends GroupToken {
	
	public TerminalRule_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTerminalRuleAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalRule_SemicolonKeyword_4(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getTerminalRuleRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "terminal"
protected class TerminalRule_TerminalKeyword_0 extends KeywordToken  {
	
	public TerminalRule_TerminalKeyword_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getTerminalRuleAccess().getTerminalKeyword_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// ^fragment?="fragment" name=ID | name=ID ("returns" type=TypeRef)?
protected class TerminalRule_Alternatives_1 extends AlternativesToken {

	public TerminalRule_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getTerminalRuleAccess().getAlternatives_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalRule_Group_1_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new TerminalRule_Group_1_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// ^fragment?="fragment" name=ID
protected class TerminalRule_Group_1_0 extends GroupToken {
	
	public TerminalRule_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTerminalRuleAccess().getGroup_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalRule_NameAssignment_1_0_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// ^fragment?="fragment"
protected class TerminalRule_FragmentAssignment_1_0_0 extends AssignmentToken  {
	
	public TerminalRule_FragmentAssignment_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTerminalRuleAccess().getFragmentAssignment_1_0_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalRule_TerminalKeyword_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("fragment",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("fragment");
		if(Boolean.TRUE.equals(value)) { // org::eclipse::xtext::impl::KeywordImpl
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getTerminalRuleAccess().getFragmentFragmentKeyword_1_0_0_0();
			return obj;
		}
		return null;
	}

}

// name=ID
protected class TerminalRule_NameAssignment_1_0_1 extends AssignmentToken  {
	
	public TerminalRule_NameAssignment_1_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTerminalRuleAccess().getNameAssignment_1_0_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalRule_FragmentAssignment_1_0_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getTerminalRuleAccess().getNameIDTerminalRuleCall_1_0_1_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getTerminalRuleAccess().getNameIDTerminalRuleCall_1_0_1_0();
			return obj;
		}
		return null;
	}

}


// name=ID ("returns" type=TypeRef)?
protected class TerminalRule_Group_1_1 extends GroupToken {
	
	public TerminalRule_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTerminalRuleAccess().getGroup_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalRule_Group_1_1_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new TerminalRule_NameAssignment_1_1_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// name=ID
protected class TerminalRule_NameAssignment_1_1_0 extends AssignmentToken  {
	
	public TerminalRule_NameAssignment_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTerminalRuleAccess().getNameAssignment_1_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalRule_TerminalKeyword_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getTerminalRuleAccess().getNameIDTerminalRuleCall_1_1_0_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getTerminalRuleAccess().getNameIDTerminalRuleCall_1_1_0_0();
			return obj;
		}
		return null;
	}

}

// ("returns" type=TypeRef)?
protected class TerminalRule_Group_1_1_1 extends GroupToken {
	
	public TerminalRule_Group_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTerminalRuleAccess().getGroup_1_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalRule_TypeAssignment_1_1_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "returns"
protected class TerminalRule_ReturnsKeyword_1_1_1_0 extends KeywordToken  {
	
	public TerminalRule_ReturnsKeyword_1_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getTerminalRuleAccess().getReturnsKeyword_1_1_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalRule_NameAssignment_1_1_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// type=TypeRef
protected class TerminalRule_TypeAssignment_1_1_1_1 extends AssignmentToken  {
	
	public TerminalRule_TypeAssignment_1_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTerminalRuleAccess().getTypeAssignment_1_1_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TypeRef_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("type",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("type");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTypeRefRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getTerminalRuleAccess().getTypeTypeRefParserRuleCall_1_1_1_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new TerminalRule_ReturnsKeyword_1_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}




// ":"
protected class TerminalRule_ColonKeyword_2 extends KeywordToken  {
	
	public TerminalRule_ColonKeyword_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getTerminalRuleAccess().getColonKeyword_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalRule_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// alternatives=TerminalAlternatives
protected class TerminalRule_AlternativesAssignment_3 extends AssignmentToken  {
	
	public TerminalRule_AlternativesAssignment_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTerminalRuleAccess().getAlternativesAssignment_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalAlternatives_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("alternatives",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("alternatives");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTerminalAlternativesRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getTerminalRuleAccess().getAlternativesTerminalAlternativesParserRuleCall_3_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new TerminalRule_ColonKeyword_2(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// ";"
protected class TerminalRule_SemicolonKeyword_4 extends KeywordToken  {
	
	public TerminalRule_SemicolonKeyword_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getTerminalRuleAccess().getSemicolonKeyword_4();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalRule_AlternativesAssignment_3(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


/************ end Rule TerminalRule ****************/


/************ begin Rule TerminalAlternatives ****************
 *
 * TerminalAlternatives returns AbstractElement:
 * 	TerminalGroup ({Alternatives.elements+=current} ("|" elements+=TerminalGroup)+)?;
 *
 **/

// TerminalGroup ({Alternatives.elements+=current} ("|" elements+=TerminalGroup)+)?
protected class TerminalAlternatives_Group extends GroupToken {
	
	public TerminalAlternatives_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTerminalAlternativesAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalAlternatives_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new TerminalAlternatives_TerminalGroupParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getTerminalAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getCharacterRangeAccess().getCharacterRangeLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEOFAccess().getEOFAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getTerminalGroupAccess().getGroupElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getNegatedTokenRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getRuleCallRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUntilTokenRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getWildcardAccess().getWildcardAction_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// TerminalGroup
protected class TerminalAlternatives_TerminalGroupParserRuleCall_0 extends RuleCallToken {
	
	public TerminalAlternatives_TerminalGroupParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getTerminalAlternativesAccess().getTerminalGroupParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalGroup_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(TerminalGroup_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ({Alternatives.elements+=current} ("|" elements+=TerminalGroup)+)?
protected class TerminalAlternatives_Group_1 extends GroupToken {
	
	public TerminalAlternatives_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTerminalAlternativesAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalAlternatives_Group_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getTerminalAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Alternatives.elements+=current}
protected class TerminalAlternatives_AlternativesElementsAction_1_0 extends ActionToken  {

	public TerminalAlternatives_AlternativesElementsAction_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getTerminalAlternativesAccess().getAlternativesElementsAction_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalAlternatives_TerminalGroupParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("elements", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("elements")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// ("|" elements+=TerminalGroup)+
protected class TerminalAlternatives_Group_1_1 extends GroupToken {
	
	public TerminalAlternatives_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTerminalAlternativesAccess().getGroup_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalAlternatives_ElementsAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "|"
protected class TerminalAlternatives_VerticalLineKeyword_1_1_0 extends KeywordToken  {
	
	public TerminalAlternatives_VerticalLineKeyword_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getTerminalAlternativesAccess().getVerticalLineKeyword_1_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalAlternatives_Group_1_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new TerminalAlternatives_AlternativesElementsAction_1_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// elements+=TerminalGroup
protected class TerminalAlternatives_ElementsAssignment_1_1_1 extends AssignmentToken  {
	
	public TerminalAlternatives_ElementsAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTerminalAlternativesAccess().getElementsAssignment_1_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalGroup_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("elements",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("elements");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTerminalGroupRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getTerminalAlternativesAccess().getElementsTerminalGroupParserRuleCall_1_1_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new TerminalAlternatives_VerticalLineKeyword_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}




/************ end Rule TerminalAlternatives ****************/


/************ begin Rule TerminalGroup ****************
 *
 * TerminalGroup returns AbstractElement:
 * 	TerminalToken ({Group.elements+=current} elements+=TerminalToken+)?;
 *
 **/

// TerminalToken ({Group.elements+=current} elements+=TerminalToken+)?
protected class TerminalGroup_Group extends GroupToken {
	
	public TerminalGroup_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTerminalGroupAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalGroup_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new TerminalGroup_TerminalTokenParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getTerminalAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getCharacterRangeAccess().getCharacterRangeLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEOFAccess().getEOFAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getTerminalGroupAccess().getGroupElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getNegatedTokenRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getRuleCallRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUntilTokenRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getWildcardAccess().getWildcardAction_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// TerminalToken
protected class TerminalGroup_TerminalTokenParserRuleCall_0 extends RuleCallToken {
	
	public TerminalGroup_TerminalTokenParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getTerminalGroupAccess().getTerminalTokenParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalToken_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(TerminalToken_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ({Group.elements+=current} elements+=TerminalToken+)?
protected class TerminalGroup_Group_1 extends GroupToken {
	
	public TerminalGroup_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTerminalGroupAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalGroup_ElementsAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getTerminalGroupAccess().getGroupElementsAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Group.elements+=current}
protected class TerminalGroup_GroupElementsAction_1_0 extends ActionToken  {

	public TerminalGroup_GroupElementsAction_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getTerminalGroupAccess().getGroupElementsAction_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalGroup_TerminalTokenParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("elements", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("elements")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// elements+=TerminalToken+
protected class TerminalGroup_ElementsAssignment_1_1 extends AssignmentToken  {
	
	public TerminalGroup_ElementsAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTerminalGroupAccess().getElementsAssignment_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalToken_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("elements",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("elements");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTerminalTokenRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getTerminalGroupAccess().getElementsTerminalTokenParserRuleCall_1_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new TerminalGroup_ElementsAssignment_1_1(lastRuleCallOrigin, next, actIndex, consumed);
			case 1: return new TerminalGroup_GroupElementsAction_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}



/************ end Rule TerminalGroup ****************/


/************ begin Rule TerminalToken ****************
 *
 * TerminalToken returns AbstractElement:
 * 	TerminalTokenElement cardinality=("?" | "*" | "+")?;
 *
 **/

// TerminalTokenElement cardinality=("?" | "*" | "+")?
protected class TerminalToken_Group extends GroupToken {
	
	public TerminalToken_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTerminalTokenAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalToken_CardinalityAssignment_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new TerminalToken_TerminalTokenElementParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getTerminalAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getCharacterRangeAccess().getCharacterRangeLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEOFAccess().getEOFAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getTerminalGroupAccess().getGroupElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getNegatedTokenRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getRuleCallRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUntilTokenRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getWildcardAccess().getWildcardAction_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// TerminalTokenElement
protected class TerminalToken_TerminalTokenElementParserRuleCall_0 extends RuleCallToken {
	
	public TerminalToken_TerminalTokenElementParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getTerminalTokenAccess().getTerminalTokenElementParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalTokenElement_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(TerminalTokenElement_Alternatives.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// cardinality=("?" | "*" | "+")?
protected class TerminalToken_CardinalityAssignment_1 extends AssignmentToken  {
	
	public TerminalToken_CardinalityAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTerminalTokenAccess().getCardinalityAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalToken_TerminalTokenElementParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("cardinality",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("cardinality");
		if(keywordSerializer.isValid(obj.getEObject(), grammarAccess.getTerminalTokenAccess().getCardinalityQuestionMarkKeyword_1_0_0(), value, null)) {
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getTerminalTokenAccess().getCardinalityQuestionMarkKeyword_1_0_0();
			return obj;
		}
		if(keywordSerializer.isValid(obj.getEObject(), grammarAccess.getTerminalTokenAccess().getCardinalityAsteriskKeyword_1_0_1(), value, null)) {
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getTerminalTokenAccess().getCardinalityAsteriskKeyword_1_0_1();
			return obj;
		}
		if(keywordSerializer.isValid(obj.getEObject(), grammarAccess.getTerminalTokenAccess().getCardinalityPlusSignKeyword_1_0_2(), value, null)) {
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getTerminalTokenAccess().getCardinalityPlusSignKeyword_1_0_2();
			return obj;
		}
		return null;
	}

}


/************ end Rule TerminalToken ****************/


/************ begin Rule TerminalTokenElement ****************
 *
 * TerminalTokenElement returns AbstractElement:
 * 	CharacterRange | RuleCall | ParenthesizedTerminalElement | AbstractNegatedToken | Wildcard | ^EOF;
 *
 **/

// CharacterRange | RuleCall | ParenthesizedTerminalElement | AbstractNegatedToken | Wildcard | ^EOF
protected class TerminalTokenElement_Alternatives extends AlternativesToken {

	public TerminalTokenElement_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getTerminalTokenElementAccess().getAlternatives();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalTokenElement_CharacterRangeParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new TerminalTokenElement_RuleCallParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
			case 2: return new TerminalTokenElement_ParenthesizedTerminalElementParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
			case 3: return new TerminalTokenElement_AbstractNegatedTokenParserRuleCall_3(lastRuleCallOrigin, this, 3, inst);
			case 4: return new TerminalTokenElement_WildcardParserRuleCall_4(lastRuleCallOrigin, this, 4, inst);
			case 5: return new TerminalTokenElement_EOFParserRuleCall_5(lastRuleCallOrigin, this, 5, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getTerminalAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getCharacterRangeAccess().getCharacterRangeLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEOFAccess().getEOFAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getTerminalGroupAccess().getGroupElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getNegatedTokenRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getRuleCallRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUntilTokenRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getWildcardAccess().getWildcardAction_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// CharacterRange
protected class TerminalTokenElement_CharacterRangeParserRuleCall_0 extends RuleCallToken {
	
	public TerminalTokenElement_CharacterRangeParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getTerminalTokenElementAccess().getCharacterRangeParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CharacterRange_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getCharacterRangeAccess().getCharacterRangeLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier())
			return null;
		if(checkForRecursion(CharacterRange_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// RuleCall
protected class TerminalTokenElement_RuleCallParserRuleCall_1 extends RuleCallToken {
	
	public TerminalTokenElement_RuleCallParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getTerminalTokenElementAccess().getRuleCallParserRuleCall_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new RuleCall_RuleAssignment(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getRuleCallRule().getType().getClassifier())
			return null;
		if(checkForRecursion(RuleCall_RuleAssignment.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ParenthesizedTerminalElement
protected class TerminalTokenElement_ParenthesizedTerminalElementParserRuleCall_2 extends RuleCallToken {
	
	public TerminalTokenElement_ParenthesizedTerminalElementParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getTerminalTokenElementAccess().getParenthesizedTerminalElementParserRuleCall_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParenthesizedTerminalElement_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(ParenthesizedTerminalElement_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// AbstractNegatedToken
protected class TerminalTokenElement_AbstractNegatedTokenParserRuleCall_3 extends RuleCallToken {
	
	public TerminalTokenElement_AbstractNegatedTokenParserRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getTerminalTokenElementAccess().getAbstractNegatedTokenParserRuleCall_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractNegatedToken_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getNegatedTokenRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUntilTokenRule().getType().getClassifier())
			return null;
		if(checkForRecursion(AbstractNegatedToken_Alternatives.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// Wildcard
protected class TerminalTokenElement_WildcardParserRuleCall_4 extends RuleCallToken {
	
	public TerminalTokenElement_WildcardParserRuleCall_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getTerminalTokenElementAccess().getWildcardParserRuleCall_4();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Wildcard_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getWildcardAccess().getWildcardAction_0().getType().getClassifier())
			return null;
		if(checkForRecursion(Wildcard_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ^EOF
protected class TerminalTokenElement_EOFParserRuleCall_5 extends RuleCallToken {
	
	public TerminalTokenElement_EOFParserRuleCall_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getTerminalTokenElementAccess().getEOFParserRuleCall_5();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EOF_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEOFAccess().getEOFAction_0().getType().getClassifier())
			return null;
		if(checkForRecursion(EOF_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}


/************ end Rule TerminalTokenElement ****************/


/************ begin Rule ParenthesizedTerminalElement ****************
 *
 * ParenthesizedTerminalElement returns AbstractElement:
 * 	"(" TerminalAlternatives ")";
 *
 **/

// "(" TerminalAlternatives ")"
protected class ParenthesizedTerminalElement_Group extends GroupToken {
	
	public ParenthesizedTerminalElement_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getParenthesizedTerminalElementAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParenthesizedTerminalElement_RightParenthesisKeyword_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getTerminalAlternativesAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getCharacterRangeAccess().getCharacterRangeLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEOFAccess().getEOFAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getTerminalGroupAccess().getGroupElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getNegatedTokenRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getRuleCallRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUntilTokenRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getWildcardAccess().getWildcardAction_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "("
protected class ParenthesizedTerminalElement_LeftParenthesisKeyword_0 extends KeywordToken  {
	
	public ParenthesizedTerminalElement_LeftParenthesisKeyword_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getParenthesizedTerminalElementAccess().getLeftParenthesisKeyword_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// TerminalAlternatives
protected class ParenthesizedTerminalElement_TerminalAlternativesParserRuleCall_1 extends RuleCallToken {
	
	public ParenthesizedTerminalElement_TerminalAlternativesParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getParenthesizedTerminalElementAccess().getTerminalAlternativesParserRuleCall_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalAlternatives_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(TerminalAlternatives_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParenthesizedTerminalElement_LeftParenthesisKeyword_0(lastRuleCallOrigin, next, actIndex, inst);
			default: return null;
		}	
	}	
}

// ")"
protected class ParenthesizedTerminalElement_RightParenthesisKeyword_2 extends KeywordToken  {
	
	public ParenthesizedTerminalElement_RightParenthesisKeyword_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getParenthesizedTerminalElementAccess().getRightParenthesisKeyword_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ParenthesizedTerminalElement_TerminalAlternativesParserRuleCall_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


/************ end Rule ParenthesizedTerminalElement ****************/


/************ begin Rule AbstractNegatedToken ****************
 *
 * AbstractNegatedToken:
 * 	NegatedToken | UntilToken;
 *
 **/

// NegatedToken | UntilToken
protected class AbstractNegatedToken_Alternatives extends AlternativesToken {

	public AbstractNegatedToken_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getAbstractNegatedTokenAccess().getAlternatives();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AbstractNegatedToken_NegatedTokenParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AbstractNegatedToken_UntilTokenParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getNegatedTokenRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUntilTokenRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// NegatedToken
protected class AbstractNegatedToken_NegatedTokenParserRuleCall_0 extends RuleCallToken {
	
	public AbstractNegatedToken_NegatedTokenParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractNegatedTokenAccess().getNegatedTokenParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new NegatedToken_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getNegatedTokenRule().getType().getClassifier())
			return null;
		if(checkForRecursion(NegatedToken_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// UntilToken
protected class AbstractNegatedToken_UntilTokenParserRuleCall_1 extends RuleCallToken {
	
	public AbstractNegatedToken_UntilTokenParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractNegatedTokenAccess().getUntilTokenParserRuleCall_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UntilToken_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getUntilTokenRule().getType().getClassifier())
			return null;
		if(checkForRecursion(UntilToken_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}


/************ end Rule AbstractNegatedToken ****************/


/************ begin Rule NegatedToken ****************
 *
 * NegatedToken:
 * 	"!" ^terminal=TerminalTokenElement;
 *
 **/

// "!" ^terminal=TerminalTokenElement
protected class NegatedToken_Group extends GroupToken {
	
	public NegatedToken_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getNegatedTokenAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new NegatedToken_TerminalAssignment_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getNegatedTokenRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "!"
protected class NegatedToken_ExclamationMarkKeyword_0 extends KeywordToken  {
	
	public NegatedToken_ExclamationMarkKeyword_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getNegatedTokenAccess().getExclamationMarkKeyword_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// ^terminal=TerminalTokenElement
protected class NegatedToken_TerminalAssignment_1 extends AssignmentToken  {
	
	public NegatedToken_TerminalAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getNegatedTokenAccess().getTerminalAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalTokenElement_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("terminal",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("terminal");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTerminalTokenElementRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getNegatedTokenAccess().getTerminalTerminalTokenElementParserRuleCall_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new NegatedToken_ExclamationMarkKeyword_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


/************ end Rule NegatedToken ****************/


/************ begin Rule UntilToken ****************
 *
 * UntilToken:
 * 	"->" ^terminal=TerminalTokenElement;
 *
 **/

// "->" ^terminal=TerminalTokenElement
protected class UntilToken_Group extends GroupToken {
	
	public UntilToken_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getUntilTokenAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UntilToken_TerminalAssignment_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getUntilTokenRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "->"
protected class UntilToken_HyphenMinusGreaterThanSignKeyword_0 extends KeywordToken  {
	
	public UntilToken_HyphenMinusGreaterThanSignKeyword_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getUntilTokenAccess().getHyphenMinusGreaterThanSignKeyword_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// ^terminal=TerminalTokenElement
protected class UntilToken_TerminalAssignment_1 extends AssignmentToken  {
	
	public UntilToken_TerminalAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getUntilTokenAccess().getTerminalAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TerminalTokenElement_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("terminal",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("terminal");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTerminalTokenElementRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getUntilTokenAccess().getTerminalTerminalTokenElementParserRuleCall_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new UntilToken_HyphenMinusGreaterThanSignKeyword_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


/************ end Rule UntilToken ****************/


/************ begin Rule Wildcard ****************
 *
 * Wildcard:
 * 	{Wildcard} ".";
 *
 **/

// {Wildcard} "."
protected class Wildcard_Group extends GroupToken {
	
	public Wildcard_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getWildcardAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Wildcard_FullStopKeyword_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getWildcardAccess().getWildcardAction_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Wildcard}
protected class Wildcard_WildcardAction_0 extends ActionToken  {

	public Wildcard_WildcardAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getWildcardAccess().getWildcardAction_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(!eObjectConsumer.isConsumed()) return null;
		return eObjectConsumer;
	}
}

// "."
protected class Wildcard_FullStopKeyword_1 extends KeywordToken  {
	
	public Wildcard_FullStopKeyword_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getWildcardAccess().getFullStopKeyword_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Wildcard_WildcardAction_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


/************ end Rule Wildcard ****************/


/************ begin Rule EOF ****************
 *
 * ^EOF:
 * 	{^EOF} "EOF";
 *
 **/

// {^EOF} "EOF"
protected class EOF_Group extends GroupToken {
	
	public EOF_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getEOFAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EOF_EOFKeyword_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEOFAccess().getEOFAction_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {^EOF}
protected class EOF_EOFAction_0 extends ActionToken  {

	public EOF_EOFAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getEOFAccess().getEOFAction_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(!eObjectConsumer.isConsumed()) return null;
		return eObjectConsumer;
	}
}

// "EOF"
protected class EOF_EOFKeyword_1 extends KeywordToken  {
	
	public EOF_EOFKeyword_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getEOFAccess().getEOFKeyword_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EOF_EOFAction_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


/************ end Rule EOF ****************/


/************ begin Rule CharacterRange ****************
 *
 * CharacterRange returns AbstractElement:
 * 	Keyword ({CharacterRange.left=current} ".." right=Keyword)?;
 *
 **/

// Keyword ({CharacterRange.left=current} ".." right=Keyword)?
protected class CharacterRange_Group extends GroupToken {
	
	public CharacterRange_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getCharacterRangeAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CharacterRange_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new CharacterRange_KeywordParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getCharacterRangeAccess().getCharacterRangeLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// Keyword
protected class CharacterRange_KeywordParserRuleCall_0 extends RuleCallToken {
	
	public CharacterRange_KeywordParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getCharacterRangeAccess().getKeywordParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Keyword_ValueAssignment(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getKeywordRule().getType().getClassifier())
			return null;
		if(checkForRecursion(Keyword_ValueAssignment.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ({CharacterRange.left=current} ".." right=Keyword)?
protected class CharacterRange_Group_1 extends GroupToken {
	
	public CharacterRange_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getCharacterRangeAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CharacterRange_RightAssignment_1_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getCharacterRangeAccess().getCharacterRangeLeftAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {CharacterRange.left=current}
protected class CharacterRange_CharacterRangeLeftAction_1_0 extends ActionToken  {

	public CharacterRange_CharacterRangeLeftAction_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getCharacterRangeAccess().getCharacterRangeLeftAction_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CharacterRange_KeywordParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("left", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// ".."
protected class CharacterRange_FullStopFullStopKeyword_1_1 extends KeywordToken  {
	
	public CharacterRange_FullStopFullStopKeyword_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getCharacterRangeAccess().getFullStopFullStopKeyword_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CharacterRange_CharacterRangeLeftAction_1_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// right=Keyword
protected class CharacterRange_RightAssignment_1_2 extends AssignmentToken  {
	
	public CharacterRange_RightAssignment_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getCharacterRangeAccess().getRightAssignment_1_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Keyword_ValueAssignment(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("right",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getKeywordRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getCharacterRangeAccess().getRightKeywordParserRuleCall_1_2_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new CharacterRange_FullStopFullStopKeyword_1_1(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}



/************ end Rule CharacterRange ****************/


/************ begin Rule EnumRule ****************
 *
 * EnumRule:
 * 	"enum" name=ID ("returns" type=TypeRef)? ":" alternatives=EnumLiterals ";";
 *
 **/

// "enum" name=ID ("returns" type=TypeRef)? ":" alternatives=EnumLiterals ";"
protected class EnumRule_Group extends GroupToken {
	
	public EnumRule_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getEnumRuleAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumRule_SemicolonKeyword_5(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEnumRuleRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "enum"
protected class EnumRule_EnumKeyword_0 extends KeywordToken  {
	
	public EnumRule_EnumKeyword_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getEnumRuleAccess().getEnumKeyword_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// name=ID
protected class EnumRule_NameAssignment_1 extends AssignmentToken  {
	
	public EnumRule_NameAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getEnumRuleAccess().getNameAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumRule_EnumKeyword_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getEnumRuleAccess().getNameIDTerminalRuleCall_1_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getEnumRuleAccess().getNameIDTerminalRuleCall_1_0();
			return obj;
		}
		return null;
	}

}

// ("returns" type=TypeRef)?
protected class EnumRule_Group_2 extends GroupToken {
	
	public EnumRule_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getEnumRuleAccess().getGroup_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumRule_TypeAssignment_2_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "returns"
protected class EnumRule_ReturnsKeyword_2_0 extends KeywordToken  {
	
	public EnumRule_ReturnsKeyword_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getEnumRuleAccess().getReturnsKeyword_2_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumRule_NameAssignment_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// type=TypeRef
protected class EnumRule_TypeAssignment_2_1 extends AssignmentToken  {
	
	public EnumRule_TypeAssignment_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getEnumRuleAccess().getTypeAssignment_2_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TypeRef_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("type",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("type");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTypeRefRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getEnumRuleAccess().getTypeTypeRefParserRuleCall_2_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new EnumRule_ReturnsKeyword_2_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


// ":"
protected class EnumRule_ColonKeyword_3 extends KeywordToken  {
	
	public EnumRule_ColonKeyword_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getEnumRuleAccess().getColonKeyword_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumRule_Group_2(lastRuleCallOrigin, this, 0, inst);
			case 1: return new EnumRule_NameAssignment_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// alternatives=EnumLiterals
protected class EnumRule_AlternativesAssignment_4 extends AssignmentToken  {
	
	public EnumRule_AlternativesAssignment_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getEnumRuleAccess().getAlternativesAssignment_4();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumLiterals_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("alternatives",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("alternatives");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getEnumLiteralsRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getEnumRuleAccess().getAlternativesEnumLiteralsParserRuleCall_4_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new EnumRule_ColonKeyword_3(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// ";"
protected class EnumRule_SemicolonKeyword_5 extends KeywordToken  {
	
	public EnumRule_SemicolonKeyword_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getEnumRuleAccess().getSemicolonKeyword_5();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumRule_AlternativesAssignment_4(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


/************ end Rule EnumRule ****************/


/************ begin Rule EnumLiterals ****************
 *
 * EnumLiterals returns AbstractElement:
 * 	EnumLiteralDeclaration ({Alternatives.elements+=current} ("|" elements+=EnumLiteralDeclaration)+)?;
 *
 **/

// EnumLiteralDeclaration ({Alternatives.elements+=current} ("|" elements+=EnumLiteralDeclaration)+)?
protected class EnumLiterals_Group extends GroupToken {
	
	public EnumLiterals_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getEnumLiteralsAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumLiterals_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new EnumLiterals_EnumLiteralDeclarationParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEnumLiteralsAccess().getAlternativesElementsAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEnumLiteralDeclarationRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// EnumLiteralDeclaration
protected class EnumLiterals_EnumLiteralDeclarationParserRuleCall_0 extends RuleCallToken {
	
	public EnumLiterals_EnumLiteralDeclarationParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getEnumLiteralsAccess().getEnumLiteralDeclarationParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumLiteralDeclaration_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEnumLiteralDeclarationRule().getType().getClassifier())
			return null;
		if(checkForRecursion(EnumLiteralDeclaration_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ({Alternatives.elements+=current} ("|" elements+=EnumLiteralDeclaration)+)?
protected class EnumLiterals_Group_1 extends GroupToken {
	
	public EnumLiterals_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getEnumLiteralsAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumLiterals_Group_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEnumLiteralsAccess().getAlternativesElementsAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Alternatives.elements+=current}
protected class EnumLiterals_AlternativesElementsAction_1_0 extends ActionToken  {

	public EnumLiterals_AlternativesElementsAction_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getEnumLiteralsAccess().getAlternativesElementsAction_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumLiterals_EnumLiteralDeclarationParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("elements", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("elements")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// ("|" elements+=EnumLiteralDeclaration)+
protected class EnumLiterals_Group_1_1 extends GroupToken {
	
	public EnumLiterals_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getEnumLiteralsAccess().getGroup_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumLiterals_ElementsAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "|"
protected class EnumLiterals_VerticalLineKeyword_1_1_0 extends KeywordToken  {
	
	public EnumLiterals_VerticalLineKeyword_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getEnumLiteralsAccess().getVerticalLineKeyword_1_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumLiterals_Group_1_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new EnumLiterals_AlternativesElementsAction_1_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// elements+=EnumLiteralDeclaration
protected class EnumLiterals_ElementsAssignment_1_1_1 extends AssignmentToken  {
	
	public EnumLiterals_ElementsAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getEnumLiteralsAccess().getElementsAssignment_1_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumLiteralDeclaration_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("elements",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("elements");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getEnumLiteralDeclarationRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getEnumLiteralsAccess().getElementsEnumLiteralDeclarationParserRuleCall_1_1_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new EnumLiterals_VerticalLineKeyword_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}




/************ end Rule EnumLiterals ****************/


/************ begin Rule EnumLiteralDeclaration ****************
 *
 * EnumLiteralDeclaration:
 * 	enumLiteral=[ecore::EEnumLiteral] ("=" literal=Keyword)?;
 *
 **/

// enumLiteral=[ecore::EEnumLiteral] ("=" literal=Keyword)?
protected class EnumLiteralDeclaration_Group extends GroupToken {
	
	public EnumLiteralDeclaration_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getEnumLiteralDeclarationAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumLiteralDeclaration_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new EnumLiteralDeclaration_EnumLiteralAssignment_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEnumLiteralDeclarationRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// enumLiteral=[ecore::EEnumLiteral]
protected class EnumLiteralDeclaration_EnumLiteralAssignment_0 extends AssignmentToken  {
	
	public EnumLiteralDeclaration_EnumLiteralAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getEnumLiteralDeclarationAccess().getEnumLiteralAssignment_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("enumLiteral",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("enumLiteral");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getEnumLiteralDeclarationAccess().getEnumLiteralEEnumLiteralCrossReference_0_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getEnumLiteralDeclarationAccess().getEnumLiteralEEnumLiteralCrossReference_0_0(); 
				return obj;
			}
		}
		return null;
	}

}

// ("=" literal=Keyword)?
protected class EnumLiteralDeclaration_Group_1 extends GroupToken {
	
	public EnumLiteralDeclaration_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getEnumLiteralDeclarationAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumLiteralDeclaration_LiteralAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "="
protected class EnumLiteralDeclaration_EqualsSignKeyword_1_0 extends KeywordToken  {
	
	public EnumLiteralDeclaration_EqualsSignKeyword_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getEnumLiteralDeclarationAccess().getEqualsSignKeyword_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EnumLiteralDeclaration_EnumLiteralAssignment_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// literal=Keyword
protected class EnumLiteralDeclaration_LiteralAssignment_1_1 extends AssignmentToken  {
	
	public EnumLiteralDeclaration_LiteralAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getEnumLiteralDeclarationAccess().getLiteralAssignment_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Keyword_ValueAssignment(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("literal",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("literal");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getKeywordRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getEnumLiteralDeclarationAccess().getLiteralKeywordParserRuleCall_1_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new EnumLiteralDeclaration_EqualsSignKeyword_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}



/************ end Rule EnumLiteralDeclaration ****************/

}