/*
* generated by Xtext
*/
package org.eclipse.incquery.patternlanguage.mondix.services;

import com.google.inject.Singleton;
import com.google.inject.Inject;

import java.util.List;

import org.eclipse.xtext.*;
import org.eclipse.xtext.service.GrammarProvider;
import org.eclipse.xtext.service.AbstractElementFinder.*;

import org.eclipse.incquery.patternlanguage.services.PatternLanguageGrammarAccess;
import org.eclipse.xtext.xbase.services.XbaseGrammarAccess;
import org.eclipse.xtext.xbase.services.XtypeGrammarAccess;

@Singleton
public class MondixPatternLanguageGrammarAccess extends AbstractGrammarElementFinder {
	
	
	public class MondixPatternModelElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "MondixPatternModel");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Action cMondixPatternModelAction_0 = (Action)cGroup.eContents().get(0);
		private final Assignment cPatternsAssignment_1 = (Assignment)cGroup.eContents().get(1);
		private final RuleCall cPatternsPatternParserRuleCall_1_0 = (RuleCall)cPatternsAssignment_1.eContents().get(0);
		
		//MondixPatternModel returns core::PatternModel:
		//	{MondixPatternModel} patterns+=Pattern*;
		public ParserRule getRule() { return rule; }

		//{MondixPatternModel} patterns+=Pattern*
		public Group getGroup() { return cGroup; }

		//{MondixPatternModel}
		public Action getMondixPatternModelAction_0() { return cMondixPatternModelAction_0; }

		//patterns+=Pattern*
		public Assignment getPatternsAssignment_1() { return cPatternsAssignment_1; }

		//Pattern
		public RuleCall getPatternsPatternParserRuleCall_1_0() { return cPatternsPatternParserRuleCall_1_0; }
	}

	public class ParameterElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Parameter");
		private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1);
		private final RuleCall cNameIDTerminalRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0);
		
		//Parameter returns Variable:
		//	name=ID;
		public ParserRule getRule() { return rule; }

		//name=ID
		public Assignment getNameAssignment() { return cNameAssignment; }

		//ID
		public RuleCall getNameIDTerminalRuleCall_0() { return cNameIDTerminalRuleCall_0; }
	}

	public class ConstraintElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Constraint");
		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
		private final RuleCall cPatternCompositionConstraintParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
		private final RuleCall cCompareConstraintParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
		private final RuleCall cNodeConstraintParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
		private final RuleCall cEdgeConstraintParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3);
		
		//Constraint returns core::Constraint:
		//	PatternCompositionConstraint | CompareConstraint | NodeConstraint | EdgeConstraint;
		public ParserRule getRule() { return rule; }

		//PatternCompositionConstraint | CompareConstraint | NodeConstraint | EdgeConstraint
		public Alternatives getAlternatives() { return cAlternatives; }

		//PatternCompositionConstraint
		public RuleCall getPatternCompositionConstraintParserRuleCall_0() { return cPatternCompositionConstraintParserRuleCall_0; }

		//CompareConstraint
		public RuleCall getCompareConstraintParserRuleCall_1() { return cCompareConstraintParserRuleCall_1; }

		//NodeConstraint
		public RuleCall getNodeConstraintParserRuleCall_2() { return cNodeConstraintParserRuleCall_2; }

		//EdgeConstraint
		public RuleCall getEdgeConstraintParserRuleCall_3() { return cEdgeConstraintParserRuleCall_3; }
	}

	public class NodeConstraintElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "NodeConstraint");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Assignment cTypeAssignment_0 = (Assignment)cGroup.eContents().get(0);
		private final RuleCall cTypeIDTerminalRuleCall_0_0 = (RuleCall)cTypeAssignment_0.eContents().get(0);
		private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1);
		private final Assignment cVariableAssignment_2 = (Assignment)cGroup.eContents().get(2);
		private final RuleCall cVariableVariableReferenceParserRuleCall_2_0 = (RuleCall)cVariableAssignment_2.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_3 = (Keyword)cGroup.eContents().get(3);
		
		//NodeConstraint:
		//	type=ID "(" variable=VariableReference ")";
		public ParserRule getRule() { return rule; }

		//type=ID "(" variable=VariableReference ")"
		public Group getGroup() { return cGroup; }

		//type=ID
		public Assignment getTypeAssignment_0() { return cTypeAssignment_0; }

		//ID
		public RuleCall getTypeIDTerminalRuleCall_0_0() { return cTypeIDTerminalRuleCall_0_0; }

		//"("
		public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; }

		//variable=VariableReference
		public Assignment getVariableAssignment_2() { return cVariableAssignment_2; }

		//VariableReference
		public RuleCall getVariableVariableReferenceParserRuleCall_2_0() { return cVariableVariableReferenceParserRuleCall_2_0; }

		//")"
		public Keyword getRightParenthesisKeyword_3() { return cRightParenthesisKeyword_3; }
	}

	public class EdgeConstraintElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "EdgeConstraint");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Assignment cRefTypeAssignment_0 = (Assignment)cGroup.eContents().get(0);
		private final RuleCall cRefTypeIDTerminalRuleCall_0_0 = (RuleCall)cRefTypeAssignment_0.eContents().get(0);
		private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1);
		private final Assignment cSourceAssignment_2 = (Assignment)cGroup.eContents().get(2);
		private final RuleCall cSourceVariableReferenceParserRuleCall_2_0 = (RuleCall)cSourceAssignment_2.eContents().get(0);
		private final Keyword cCommaKeyword_3 = (Keyword)cGroup.eContents().get(3);
		private final Assignment cTargetAssignment_4 = (Assignment)cGroup.eContents().get(4);
		private final RuleCall cTargetValueReferenceParserRuleCall_4_0 = (RuleCall)cTargetAssignment_4.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_5 = (Keyword)cGroup.eContents().get(5);
		
		//EdgeConstraint:
		//	refType=ID "(" source=VariableReference "," target=ValueReference ")";
		public ParserRule getRule() { return rule; }

		//refType=ID "(" source=VariableReference "," target=ValueReference ")"
		public Group getGroup() { return cGroup; }

		//refType=ID
		public Assignment getRefTypeAssignment_0() { return cRefTypeAssignment_0; }

		//ID
		public RuleCall getRefTypeIDTerminalRuleCall_0_0() { return cRefTypeIDTerminalRuleCall_0_0; }

		//"("
		public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; }

		//source=VariableReference
		public Assignment getSourceAssignment_2() { return cSourceAssignment_2; }

		//VariableReference
		public RuleCall getSourceVariableReferenceParserRuleCall_2_0() { return cSourceVariableReferenceParserRuleCall_2_0; }

		//","
		public Keyword getCommaKeyword_3() { return cCommaKeyword_3; }

		//target=ValueReference
		public Assignment getTargetAssignment_4() { return cTargetAssignment_4; }

		//ValueReference
		public RuleCall getTargetValueReferenceParserRuleCall_4_0() { return cTargetValueReferenceParserRuleCall_4_0; }

		//")"
		public Keyword getRightParenthesisKeyword_5() { return cRightParenthesisKeyword_5; }
	}
	
	
	private MondixPatternModelElements pMondixPatternModel;
	private ParameterElements pParameter;
	private ConstraintElements pConstraint;
	private NodeConstraintElements pNodeConstraint;
	private EdgeConstraintElements pEdgeConstraint;
	
	private final Grammar grammar;

	private PatternLanguageGrammarAccess gaPatternLanguage;

	@Inject
	public MondixPatternLanguageGrammarAccess(GrammarProvider grammarProvider,
		PatternLanguageGrammarAccess gaPatternLanguage) {
		this.grammar = internalFindGrammar(grammarProvider);
		this.gaPatternLanguage = gaPatternLanguage;
	}
	
	protected Grammar internalFindGrammar(GrammarProvider grammarProvider) {
		Grammar grammar = grammarProvider.getGrammar(this);
		while (grammar != null) {
			if ("org.eclipse.incquery.patternlanguage.mondix.MondixPatternLanguage".equals(grammar.getName())) {
				return grammar;
			}
			List<Grammar> grammars = grammar.getUsedGrammars();
			if (!grammars.isEmpty()) {
				grammar = grammars.iterator().next();
			} else {
				return null;
			}
		}
		return grammar;
	}
	
	
	public Grammar getGrammar() {
		return grammar;
	}
	

	public PatternLanguageGrammarAccess getPatternLanguageGrammarAccess() {
		return gaPatternLanguage;
	}

	
	//MondixPatternModel returns core::PatternModel:
	//	{MondixPatternModel} patterns+=Pattern*;
	public MondixPatternModelElements getMondixPatternModelAccess() {
		return (pMondixPatternModel != null) ? pMondixPatternModel : (pMondixPatternModel = new MondixPatternModelElements());
	}
	
	public ParserRule getMondixPatternModelRule() {
		return getMondixPatternModelAccess().getRule();
	}

	//Parameter returns Variable:
	//	name=ID;
	public ParameterElements getParameterAccess() {
		return (pParameter != null) ? pParameter : (pParameter = new ParameterElements());
	}
	
	public ParserRule getParameterRule() {
		return getParameterAccess().getRule();
	}

	//Constraint returns core::Constraint:
	//	PatternCompositionConstraint | CompareConstraint | NodeConstraint | EdgeConstraint;
	public ConstraintElements getConstraintAccess() {
		return (pConstraint != null) ? pConstraint : (pConstraint = new ConstraintElements());
	}
	
	public ParserRule getConstraintRule() {
		return getConstraintAccess().getRule();
	}

	//NodeConstraint:
	//	type=ID "(" variable=VariableReference ")";
	public NodeConstraintElements getNodeConstraintAccess() {
		return (pNodeConstraint != null) ? pNodeConstraint : (pNodeConstraint = new NodeConstraintElements());
	}
	
	public ParserRule getNodeConstraintRule() {
		return getNodeConstraintAccess().getRule();
	}

	//EdgeConstraint:
	//	refType=ID "(" source=VariableReference "," target=ValueReference ")";
	public EdgeConstraintElements getEdgeConstraintAccess() {
		return (pEdgeConstraint != null) ? pEdgeConstraint : (pEdgeConstraint = new EdgeConstraintElements());
	}
	
	public ParserRule getEdgeConstraintRule() {
		return getEdgeConstraintAccess().getRule();
	}

	//PatternModel:
	//	("package" packageName=QualifiedName)? patterns+=Pattern*;
	public PatternLanguageGrammarAccess.PatternModelElements getPatternModelAccess() {
		return gaPatternLanguage.getPatternModelAccess();
	}
	
	public ParserRule getPatternModelRule() {
		return getPatternModelAccess().getRule();
	}

	//Pattern:
	//	annotations+=Annotation* modifiers+=Modifiers* "pattern" name=ID "(" (parameters+=Parameter (","
	//	parameters+=Parameter)*)? ")" "="? bodies+=PatternBody ("or" bodies+=PatternBody)*;
	public PatternLanguageGrammarAccess.PatternElements getPatternAccess() {
		return gaPatternLanguage.getPatternAccess();
	}
	
	public ParserRule getPatternRule() {
		return getPatternAccess().getRule();
	}

	//Annotation:
	//	"@" name=ID ("(" parameters+=AnnotationParameter ("," parameters+=AnnotationParameter)* ")")?;
	public PatternLanguageGrammarAccess.AnnotationElements getAnnotationAccess() {
		return gaPatternLanguage.getAnnotationAccess();
	}
	
	public ParserRule getAnnotationRule() {
		return getAnnotationAccess().getRule();
	}

	//AnnotationParameter:
	//	name=ID "=" value=AnnotationValueReference;
	public PatternLanguageGrammarAccess.AnnotationParameterElements getAnnotationParameterAccess() {
		return gaPatternLanguage.getAnnotationParameterAccess();
	}
	
	public ParserRule getAnnotationParameterRule() {
		return getAnnotationParameterAccess().getRule();
	}

	//Modifiers: //injective?='injective' &
	//	private?="private";
	public PatternLanguageGrammarAccess.ModifiersElements getModifiersAccess() {
		return gaPatternLanguage.getModifiersAccess();
	}
	
	public ParserRule getModifiersRule() {
		return getModifiersAccess().getRule();
	}

	//Variable returns types::JvmIdentifiableElement:
	//	{Variable} name=ID (":" type=Type)?;
	public PatternLanguageGrammarAccess.VariableElements getVariableAccess() {
		return gaPatternLanguage.getVariableAccess();
	}
	
	public ParserRule getVariableRule() {
		return getVariableAccess().getRule();
	}

	//ParameterRef returns Variable:
	//	{ParameterRef} name=ID referredParam=[Variable] (":" type=Type)?;
	public PatternLanguageGrammarAccess.ParameterRefElements getParameterRefAccess() {
		return gaPatternLanguage.getParameterRefAccess();
	}
	
	public ParserRule getParameterRefRule() {
		return getParameterRefAccess().getRule();
	}

	//LocalVariable returns Variable:
	//	{LocalVariable} name=ID (":" type=Type)?;
	public PatternLanguageGrammarAccess.LocalVariableElements getLocalVariableAccess() {
		return gaPatternLanguage.getLocalVariableAccess();
	}
	
	public ParserRule getLocalVariableRule() {
		return getLocalVariableAccess().getRule();
	}

	//VariableReference:
	//	var=ID;
	public PatternLanguageGrammarAccess.VariableReferenceElements getVariableReferenceAccess() {
		return gaPatternLanguage.getVariableReferenceAccess();
	}
	
	public ParserRule getVariableReferenceRule() {
		return getVariableReferenceAccess().getRule();
	}

	////These types are not meant to be written directly, just in the desc languages
	//Type:
	//	{EntityType} typename=ID;
	public PatternLanguageGrammarAccess.TypeElements getTypeAccess() {
		return gaPatternLanguage.getTypeAccess();
	}
	
	public ParserRule getTypeRule() {
		return getTypeAccess().getRule();
	}

	////These types are not meant to be written directly, just in the desc languages
	//RefType returns Type:
	//	{RelationType} typename=ID;
	public PatternLanguageGrammarAccess.RefTypeElements getRefTypeAccess() {
		return gaPatternLanguage.getRefTypeAccess();
	}
	
	public ParserRule getRefTypeRule() {
		return getRefTypeAccess().getRule();
	}

	//PatternBody:
	//	{PatternBody} name=ID? "{" (constraints+=Constraint ";")* "}";
	public PatternLanguageGrammarAccess.PatternBodyElements getPatternBodyAccess() {
		return gaPatternLanguage.getPatternBodyAccess();
	}
	
	public ParserRule getPatternBodyRule() {
		return getPatternBodyAccess().getRule();
	}

	//PatternCompositionConstraint returns Constraint:
	//	{PatternCompositionConstraint} negative?="neg"? call=PatternCall;
	public PatternLanguageGrammarAccess.PatternCompositionConstraintElements getPatternCompositionConstraintAccess() {
		return gaPatternLanguage.getPatternCompositionConstraintAccess();
	}
	
	public ParserRule getPatternCompositionConstraintRule() {
		return getPatternCompositionConstraintAccess().getRule();
	}

	////'count' 'find' patternRef=[Pattern] '(' (parameters+=ValueReference (','
	////parameters+=ValueReference)*)? ')';
	//PatternCall:
	//	"find" patternRef=[Pattern|QualifiedName] transitive?="+"? "(" (parameters+=ValueReference (","
	//	parameters+=ValueReference)*)? ")";
	public PatternLanguageGrammarAccess.PatternCallElements getPatternCallAccess() {
		return gaPatternLanguage.getPatternCallAccess();
	}
	
	public ParserRule getPatternCallRule() {
		return getPatternCallAccess().getRule();
	}

	//CompareConstraint returns Constraint:
	//	{CompareConstraint} leftOperand=ValueReference feature=CompareFeature rightOperand=ValueReference;
	public PatternLanguageGrammarAccess.CompareConstraintElements getCompareConstraintAccess() {
		return gaPatternLanguage.getCompareConstraintAccess();
	}
	
	public ParserRule getCompareConstraintRule() {
		return getCompareConstraintAccess().getRule();
	}

	//enum CompareFeature:
	//	equality="==" | inequality="!=";
	public PatternLanguageGrammarAccess.CompareFeatureElements getCompareFeatureAccess() {
		return gaPatternLanguage.getCompareFeatureAccess();
	}
	
	public EnumRule getCompareFeatureRule() {
		return getCompareFeatureAccess().getRule();
	}

	//CheckConstraint returns Constraint:
	//	{CheckConstraint} "check" "(" expression=XExpression ")";
	public PatternLanguageGrammarAccess.CheckConstraintElements getCheckConstraintAccess() {
		return gaPatternLanguage.getCheckConstraintAccess();
	}
	
	public ParserRule getCheckConstraintRule() {
		return getCheckConstraintAccess().getRule();
	}

	//PathExpressionConstraint returns Constraint:
	//	{PathExpressionConstraint} head=PathExpressionHead;
	public PatternLanguageGrammarAccess.PathExpressionConstraintElements getPathExpressionConstraintAccess() {
		return gaPatternLanguage.getPathExpressionConstraintAccess();
	}
	
	public ParserRule getPathExpressionConstraintRule() {
		return getPathExpressionConstraintAccess().getRule();
	}

	//PathExpressionHead returns PathExpressionElement:
	//	{PathExpressionHead} type=Type "." tail=PathExpressionTail "(" src=VariableReference "," dst=ValueReference ")";
	public PatternLanguageGrammarAccess.PathExpressionHeadElements getPathExpressionHeadAccess() {
		return gaPatternLanguage.getPathExpressionHeadAccess();
	}
	
	public ParserRule getPathExpressionHeadRule() {
		return getPathExpressionHeadAccess().getRule();
	}

	//PathExpressionTail returns PathExpressionElement:
	//	{PathExpressionTail} type=RefType ("[" index=INT "]")? closure?="*"? ("." tail=PathExpressionTail)?;
	public PatternLanguageGrammarAccess.PathExpressionTailElements getPathExpressionTailAccess() {
		return gaPatternLanguage.getPathExpressionTailAccess();
	}
	
	public ParserRule getPathExpressionTailRule() {
		return getPathExpressionTailAccess().getRule();
	}

	//ValueReference:
	//	LiteralValueReference | VariableValue | ComputationValue;
	public PatternLanguageGrammarAccess.ValueReferenceElements getValueReferenceAccess() {
		return gaPatternLanguage.getValueReferenceAccess();
	}
	
	public ParserRule getValueReferenceRule() {
		return getValueReferenceAccess().getRule();
	}

	//AnnotationValueReference returns ValueReference:
	//	ValueReference | ListValue;
	public PatternLanguageGrammarAccess.AnnotationValueReferenceElements getAnnotationValueReferenceAccess() {
		return gaPatternLanguage.getAnnotationValueReferenceAccess();
	}
	
	public ParserRule getAnnotationValueReferenceRule() {
		return getAnnotationValueReferenceAccess().getRule();
	}

	//LiteralValueReference returns ValueReference:
	//	IntValue | StringValue | DoubleValue | BoolValue;
	public PatternLanguageGrammarAccess.LiteralValueReferenceElements getLiteralValueReferenceAccess() {
		return gaPatternLanguage.getLiteralValueReferenceAccess();
	}
	
	public ParserRule getLiteralValueReferenceRule() {
		return getLiteralValueReferenceAccess().getRule();
	}

	//IntValue returns LiteralValueReference:
	//	{IntValue} value=INTNUMBER;
	public PatternLanguageGrammarAccess.IntValueElements getIntValueAccess() {
		return gaPatternLanguage.getIntValueAccess();
	}
	
	public ParserRule getIntValueRule() {
		return getIntValueAccess().getRule();
	}

	//INTNUMBER returns ecore::EInt:
	//	"-"? INT;
	public PatternLanguageGrammarAccess.INTNUMBERElements getINTNUMBERAccess() {
		return gaPatternLanguage.getINTNUMBERAccess();
	}
	
	public ParserRule getINTNUMBERRule() {
		return getINTNUMBERAccess().getRule();
	}

	//StringValue returns LiteralValueReference:
	//	{StringValue} value=STRING;
	public PatternLanguageGrammarAccess.StringValueElements getStringValueAccess() {
		return gaPatternLanguage.getStringValueAccess();
	}
	
	public ParserRule getStringValueRule() {
		return getStringValueAccess().getRule();
	}

	//BoolValue returns LiteralValueReference:
	//	{BoolValue} value=BOOLEAN;
	public PatternLanguageGrammarAccess.BoolValueElements getBoolValueAccess() {
		return gaPatternLanguage.getBoolValueAccess();
	}
	
	public ParserRule getBoolValueRule() {
		return getBoolValueAccess().getRule();
	}

	//BOOLEAN returns ecore::EBoolean:
	//	"true" | "false" | "TRUE" | "FALSE";
	public PatternLanguageGrammarAccess.BOOLEANElements getBOOLEANAccess() {
		return gaPatternLanguage.getBOOLEANAccess();
	}
	
	public ParserRule getBOOLEANRule() {
		return getBOOLEANAccess().getRule();
	}

	//DoubleValue returns LiteralValueReference:
	//	{DoubleValue} value=DOUBLE;
	public PatternLanguageGrammarAccess.DoubleValueElements getDoubleValueAccess() {
		return gaPatternLanguage.getDoubleValueAccess();
	}
	
	public ParserRule getDoubleValueRule() {
		return getDoubleValueAccess().getRule();
	}

	//DOUBLE returns ecore::EDouble:
	//	"-"? INT "." INT;
	public PatternLanguageGrammarAccess.DOUBLEElements getDOUBLEAccess() {
		return gaPatternLanguage.getDOUBLEAccess();
	}
	
	public ParserRule getDOUBLERule() {
		return getDOUBLEAccess().getRule();
	}

	//VariableValue returns ValueReference:
	//	{VariableValue} value=VariableReference;
	public PatternLanguageGrammarAccess.VariableValueElements getVariableValueAccess() {
		return gaPatternLanguage.getVariableValueAccess();
	}
	
	public ParserRule getVariableValueRule() {
		return getVariableValueAccess().getRule();
	}

	//ListValue returns LiteralValueReference:
	//	{ListValue} "{" values+=ValueReference ("," values+=ValueReference)* "}";
	public PatternLanguageGrammarAccess.ListValueElements getListValueAccess() {
		return gaPatternLanguage.getListValueAccess();
	}
	
	public ParserRule getListValueRule() {
		return getListValueAccess().getRule();
	}

	//ComputationValue returns ValueReference:
	//	AggregatedValue | FunctionEvaluationValue;
	public PatternLanguageGrammarAccess.ComputationValueElements getComputationValueAccess() {
		return gaPatternLanguage.getComputationValueAccess();
	}
	
	public ParserRule getComputationValueRule() {
		return getComputationValueAccess().getRule();
	}

	//FunctionEvaluationValue returns ComputationValue:
	//	{FunctionEvaluationValue} "eval" "(" expression=XExpression ")";
	public PatternLanguageGrammarAccess.FunctionEvaluationValueElements getFunctionEvaluationValueAccess() {
		return gaPatternLanguage.getFunctionEvaluationValueAccess();
	}
	
	public ParserRule getFunctionEvaluationValueRule() {
		return getFunctionEvaluationValueAccess().getRule();
	}

	//AggregatedValue returns ComputationValue:
	//	{AggregatedValue} / *'aggregate'* / aggregator=AggregatorExpression call=PatternCall;
	public PatternLanguageGrammarAccess.AggregatedValueElements getAggregatedValueAccess() {
		return gaPatternLanguage.getAggregatedValueAccess();
	}
	
	public ParserRule getAggregatedValueRule() {
		return getAggregatedValueAccess().getRule();
	}

	//AggregatorExpression:
	//	{CountAggregator} "count";
	public PatternLanguageGrammarAccess.AggregatorExpressionElements getAggregatorExpressionAccess() {
		return gaPatternLanguage.getAggregatorExpressionAccess();
	}
	
	public ParserRule getAggregatorExpressionRule() {
		return getAggregatorExpressionAccess().getRule();
	}

	//XExpression:
	//	XAssignment;
	public XbaseGrammarAccess.XExpressionElements getXExpressionAccess() {
		return gaPatternLanguage.getXExpressionAccess();
	}
	
	public ParserRule getXExpressionRule() {
		return getXExpressionAccess().getRule();
	}

	//XAssignment returns XExpression:
	//	{XAssignment} feature=[types::JvmIdentifiableElement|FeatureCallID] OpSingleAssign value=XAssignment | XOrExpression
	//	(=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpMultiAssign])
	//	rightOperand=XAssignment)?;
	public XbaseGrammarAccess.XAssignmentElements getXAssignmentAccess() {
		return gaPatternLanguage.getXAssignmentAccess();
	}
	
	public ParserRule getXAssignmentRule() {
		return getXAssignmentAccess().getRule();
	}

	//OpSingleAssign:
	//	"=";
	public XbaseGrammarAccess.OpSingleAssignElements getOpSingleAssignAccess() {
		return gaPatternLanguage.getOpSingleAssignAccess();
	}
	
	public ParserRule getOpSingleAssignRule() {
		return getOpSingleAssignAccess().getRule();
	}

	//OpMultiAssign:
	//	"+=" | "-=" | "*=" | "/=" | "%=" | "<" "<" "=" | ">" ">"? ">=";
	public XbaseGrammarAccess.OpMultiAssignElements getOpMultiAssignAccess() {
		return gaPatternLanguage.getOpMultiAssignAccess();
	}
	
	public ParserRule getOpMultiAssignRule() {
		return getOpMultiAssignAccess().getRule();
	}

	//XOrExpression returns XExpression:
	//	XAndExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpOr])
	//	rightOperand=XAndExpression)*;
	public XbaseGrammarAccess.XOrExpressionElements getXOrExpressionAccess() {
		return gaPatternLanguage.getXOrExpressionAccess();
	}
	
	public ParserRule getXOrExpressionRule() {
		return getXOrExpressionAccess().getRule();
	}

	//OpOr:
	//	"||";
	public XbaseGrammarAccess.OpOrElements getOpOrAccess() {
		return gaPatternLanguage.getOpOrAccess();
	}
	
	public ParserRule getOpOrRule() {
		return getOpOrAccess().getRule();
	}

	//XAndExpression returns XExpression:
	//	XEqualityExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpAnd])
	//	rightOperand=XEqualityExpression)*;
	public XbaseGrammarAccess.XAndExpressionElements getXAndExpressionAccess() {
		return gaPatternLanguage.getXAndExpressionAccess();
	}
	
	public ParserRule getXAndExpressionRule() {
		return getXAndExpressionAccess().getRule();
	}

	//OpAnd:
	//	"&&";
	public XbaseGrammarAccess.OpAndElements getOpAndAccess() {
		return gaPatternLanguage.getOpAndAccess();
	}
	
	public ParserRule getOpAndRule() {
		return getOpAndAccess().getRule();
	}

	//XEqualityExpression returns XExpression:
	//	XRelationalExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpEquality])
	//	rightOperand=XRelationalExpression)*;
	public XbaseGrammarAccess.XEqualityExpressionElements getXEqualityExpressionAccess() {
		return gaPatternLanguage.getXEqualityExpressionAccess();
	}
	
	public ParserRule getXEqualityExpressionRule() {
		return getXEqualityExpressionAccess().getRule();
	}

	//OpEquality:
	//	"==" | "!=" | "===" | "!==";
	public XbaseGrammarAccess.OpEqualityElements getOpEqualityAccess() {
		return gaPatternLanguage.getOpEqualityAccess();
	}
	
	public ParserRule getOpEqualityRule() {
		return getOpEqualityAccess().getRule();
	}

	//XRelationalExpression returns XExpression:
	//	XOtherOperatorExpression (=> ({XInstanceOfExpression.expression=current} "instanceof") type=JvmTypeReference | =>
	//	({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpCompare])
	//	rightOperand=XOtherOperatorExpression)*;
	public XbaseGrammarAccess.XRelationalExpressionElements getXRelationalExpressionAccess() {
		return gaPatternLanguage.getXRelationalExpressionAccess();
	}
	
	public ParserRule getXRelationalExpressionRule() {
		return getXRelationalExpressionAccess().getRule();
	}

	//OpCompare:
	//	">=" | "<" "=" | ">" | "<";
	public XbaseGrammarAccess.OpCompareElements getOpCompareAccess() {
		return gaPatternLanguage.getOpCompareAccess();
	}
	
	public ParserRule getOpCompareRule() {
		return getOpCompareAccess().getRule();
	}

	//XOtherOperatorExpression returns XExpression:
	//	XAdditiveExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpOther])
	//	rightOperand=XAdditiveExpression)*;
	public XbaseGrammarAccess.XOtherOperatorExpressionElements getXOtherOperatorExpressionAccess() {
		return gaPatternLanguage.getXOtherOperatorExpressionAccess();
	}
	
	public ParserRule getXOtherOperatorExpressionRule() {
		return getXOtherOperatorExpressionAccess().getRule();
	}

	//OpOther:
	//	"->" | "..<" | ">" ".." | ".." | "=>" | ">" (=> (">" ">") | ">") | "<" (=> ("<" "<") | "<" | "=>") | "<>" | "?:";
	public XbaseGrammarAccess.OpOtherElements getOpOtherAccess() {
		return gaPatternLanguage.getOpOtherAccess();
	}
	
	public ParserRule getOpOtherRule() {
		return getOpOtherAccess().getRule();
	}

	//XAdditiveExpression returns XExpression:
	//	XMultiplicativeExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpAdd])
	//	rightOperand=XMultiplicativeExpression)*;
	public XbaseGrammarAccess.XAdditiveExpressionElements getXAdditiveExpressionAccess() {
		return gaPatternLanguage.getXAdditiveExpressionAccess();
	}
	
	public ParserRule getXAdditiveExpressionRule() {
		return getXAdditiveExpressionAccess().getRule();
	}

	//OpAdd:
	//	"+" | "-";
	public XbaseGrammarAccess.OpAddElements getOpAddAccess() {
		return gaPatternLanguage.getOpAddAccess();
	}
	
	public ParserRule getOpAddRule() {
		return getOpAddAccess().getRule();
	}

	//XMultiplicativeExpression returns XExpression:
	//	XUnaryOperation (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpMulti])
	//	rightOperand=XUnaryOperation)*;
	public XbaseGrammarAccess.XMultiplicativeExpressionElements getXMultiplicativeExpressionAccess() {
		return gaPatternLanguage.getXMultiplicativeExpressionAccess();
	}
	
	public ParserRule getXMultiplicativeExpressionRule() {
		return getXMultiplicativeExpressionAccess().getRule();
	}

	//OpMulti:
	//	"*" | "**" | "/" | "%";
	public XbaseGrammarAccess.OpMultiElements getOpMultiAccess() {
		return gaPatternLanguage.getOpMultiAccess();
	}
	
	public ParserRule getOpMultiRule() {
		return getOpMultiAccess().getRule();
	}

	//XUnaryOperation returns XExpression:
	//	{XUnaryOperation} feature=[types::JvmIdentifiableElement|OpUnary] operand=XUnaryOperation | XCastedExpression;
	public XbaseGrammarAccess.XUnaryOperationElements getXUnaryOperationAccess() {
		return gaPatternLanguage.getXUnaryOperationAccess();
	}
	
	public ParserRule getXUnaryOperationRule() {
		return getXUnaryOperationAccess().getRule();
	}

	//OpUnary:
	//	"!" | "-" | "+";
	public XbaseGrammarAccess.OpUnaryElements getOpUnaryAccess() {
		return gaPatternLanguage.getOpUnaryAccess();
	}
	
	public ParserRule getOpUnaryRule() {
		return getOpUnaryAccess().getRule();
	}

	//XCastedExpression returns XExpression:
	//	XPostfixOperation (=> ({XCastedExpression.target=current} "as") type=JvmTypeReference)*;
	public XbaseGrammarAccess.XCastedExpressionElements getXCastedExpressionAccess() {
		return gaPatternLanguage.getXCastedExpressionAccess();
	}
	
	public ParserRule getXCastedExpressionRule() {
		return getXCastedExpressionAccess().getRule();
	}

	//XPostfixOperation returns XExpression:
	//	XMemberFeatureCall => ({XPostfixOperation.operand=current} feature=[types::JvmIdentifiableElement|OpPostfix])?;
	public XbaseGrammarAccess.XPostfixOperationElements getXPostfixOperationAccess() {
		return gaPatternLanguage.getXPostfixOperationAccess();
	}
	
	public ParserRule getXPostfixOperationRule() {
		return getXPostfixOperationAccess().getRule();
	}

	//OpPostfix:
	//	"++" | "--";
	public XbaseGrammarAccess.OpPostfixElements getOpPostfixAccess() {
		return gaPatternLanguage.getOpPostfixAccess();
	}
	
	public ParserRule getOpPostfixRule() {
		return getOpPostfixAccess().getRule();
	}

	//XMemberFeatureCall returns XExpression:
	//	XPrimaryExpression (=> ({XAssignment.assignable=current} ("." | explicitStatic?="::")
	//	feature=[types::JvmIdentifiableElement|FeatureCallID] OpSingleAssign) value=XAssignment | =>
	//	({XMemberFeatureCall.memberCallTarget=current} ("." | nullSafe?="?." | explicitStatic?="::")) ("<"
	//	typeArguments+=JvmArgumentTypeReference ("," typeArguments+=JvmArgumentTypeReference)* ">")?
	//	feature=[types::JvmIdentifiableElement|IdOrSuper] (=> explicitOperationCall?="(" (memberCallArguments+=XShortClosure |
	//	memberCallArguments+=XExpression ("," memberCallArguments+=XExpression)*)? ")")? memberCallArguments+=XClosure?)*;
	public XbaseGrammarAccess.XMemberFeatureCallElements getXMemberFeatureCallAccess() {
		return gaPatternLanguage.getXMemberFeatureCallAccess();
	}
	
	public ParserRule getXMemberFeatureCallRule() {
		return getXMemberFeatureCallAccess().getRule();
	}

	//XPrimaryExpression returns XExpression:
	//	XConstructorCall | XBlockExpression | XSwitchExpression | XSynchronizedExpression | XFeatureCall | XLiteral |
	//	XIfExpression | XForLoopExpression | XBasicForLoopExpression | XWhileExpression | XDoWhileExpression |
	//	XThrowExpression | XReturnExpression | XTryCatchFinallyExpression | XParenthesizedExpression;
	public XbaseGrammarAccess.XPrimaryExpressionElements getXPrimaryExpressionAccess() {
		return gaPatternLanguage.getXPrimaryExpressionAccess();
	}
	
	public ParserRule getXPrimaryExpressionRule() {
		return getXPrimaryExpressionAccess().getRule();
	}

	//XLiteral returns XExpression:
	//	XCollectionLiteral | XClosure | XBooleanLiteral | XNumberLiteral | XNullLiteral | XStringLiteral | XTypeLiteral;
	public XbaseGrammarAccess.XLiteralElements getXLiteralAccess() {
		return gaPatternLanguage.getXLiteralAccess();
	}
	
	public ParserRule getXLiteralRule() {
		return getXLiteralAccess().getRule();
	}

	//XCollectionLiteral:
	//	XSetLiteral | XListLiteral;
	public XbaseGrammarAccess.XCollectionLiteralElements getXCollectionLiteralAccess() {
		return gaPatternLanguage.getXCollectionLiteralAccess();
	}
	
	public ParserRule getXCollectionLiteralRule() {
		return getXCollectionLiteralAccess().getRule();
	}

	//XSetLiteral:
	//	{XSetLiteral} "#" "{" (elements+=XExpression ("," elements+=XExpression)*)? "}";
	public XbaseGrammarAccess.XSetLiteralElements getXSetLiteralAccess() {
		return gaPatternLanguage.getXSetLiteralAccess();
	}
	
	public ParserRule getXSetLiteralRule() {
		return getXSetLiteralAccess().getRule();
	}

	//XListLiteral:
	//	{XListLiteral} "#" "[" (elements+=XExpression ("," elements+=XExpression)*)? "]";
	public XbaseGrammarAccess.XListLiteralElements getXListLiteralAccess() {
		return gaPatternLanguage.getXListLiteralAccess();
	}
	
	public ParserRule getXListLiteralRule() {
		return getXListLiteralAccess().getRule();
	}

	//XClosure returns XExpression:
	//	=> ({XClosure} "[") => ((declaredFormalParameters+=JvmFormalParameter (","
	//	declaredFormalParameters+=JvmFormalParameter)*)? explicitSyntax?="|")? expression=XExpressionInClosure "]";
	public XbaseGrammarAccess.XClosureElements getXClosureAccess() {
		return gaPatternLanguage.getXClosureAccess();
	}
	
	public ParserRule getXClosureRule() {
		return getXClosureAccess().getRule();
	}

	//XExpressionInClosure returns XExpression:
	//	{XBlockExpression} (expressions+=XExpressionOrVarDeclaration ";"?)*;
	public XbaseGrammarAccess.XExpressionInClosureElements getXExpressionInClosureAccess() {
		return gaPatternLanguage.getXExpressionInClosureAccess();
	}
	
	public ParserRule getXExpressionInClosureRule() {
		return getXExpressionInClosureAccess().getRule();
	}

	//XShortClosure returns XExpression:
	//	=> ({XClosure} (declaredFormalParameters+=JvmFormalParameter ("," declaredFormalParameters+=JvmFormalParameter)*)?
	//	explicitSyntax?="|") expression=XExpression;
	public XbaseGrammarAccess.XShortClosureElements getXShortClosureAccess() {
		return gaPatternLanguage.getXShortClosureAccess();
	}
	
	public ParserRule getXShortClosureRule() {
		return getXShortClosureAccess().getRule();
	}

	//XParenthesizedExpression returns XExpression:
	//	"(" XExpression ")";
	public XbaseGrammarAccess.XParenthesizedExpressionElements getXParenthesizedExpressionAccess() {
		return gaPatternLanguage.getXParenthesizedExpressionAccess();
	}
	
	public ParserRule getXParenthesizedExpressionRule() {
		return getXParenthesizedExpressionAccess().getRule();
	}

	//XIfExpression returns XExpression:
	//	{XIfExpression} "if" "(" if=XExpression ")" then=XExpression ("else" else=XExpression)?;
	public XbaseGrammarAccess.XIfExpressionElements getXIfExpressionAccess() {
		return gaPatternLanguage.getXIfExpressionAccess();
	}
	
	public ParserRule getXIfExpressionRule() {
		return getXIfExpressionAccess().getRule();
	}

	//XSwitchExpression returns XExpression:
	//	{XSwitchExpression} "switch" (=> ("(" declaredParam=JvmFormalParameter ":") switch=XExpression ")" | =>
	//	(declaredParam=JvmFormalParameter ":")? switch=XExpression) "{" cases+=XCasePart* ("default" ":" default=XExpression)?
	//	"}";
	public XbaseGrammarAccess.XSwitchExpressionElements getXSwitchExpressionAccess() {
		return gaPatternLanguage.getXSwitchExpressionAccess();
	}
	
	public ParserRule getXSwitchExpressionRule() {
		return getXSwitchExpressionAccess().getRule();
	}

	//XCasePart:
	//	{XCasePart} typeGuard=JvmTypeReference? ("case" case=XExpression)? (":" then=XExpression | ",");
	public XbaseGrammarAccess.XCasePartElements getXCasePartAccess() {
		return gaPatternLanguage.getXCasePartAccess();
	}
	
	public ParserRule getXCasePartRule() {
		return getXCasePartAccess().getRule();
	}

	//XForLoopExpression returns XExpression:
	//	=> ({XForLoopExpression} "for" "(" declaredParam=JvmFormalParameter ":") forExpression=XExpression ")"
	//	eachExpression=XExpression;
	public XbaseGrammarAccess.XForLoopExpressionElements getXForLoopExpressionAccess() {
		return gaPatternLanguage.getXForLoopExpressionAccess();
	}
	
	public ParserRule getXForLoopExpressionRule() {
		return getXForLoopExpressionAccess().getRule();
	}

	//XBasicForLoopExpression returns XExpression:
	//	{XBasicForLoopExpression} "for" "(" (initExpressions+=XExpressionOrVarDeclaration (","
	//	initExpressions+=XExpressionOrVarDeclaration)*)? ";" expression=XExpression? ";" (updateExpressions+=XExpression (","
	//	updateExpressions+=XExpression)*)? ")" eachExpression=XExpression;
	public XbaseGrammarAccess.XBasicForLoopExpressionElements getXBasicForLoopExpressionAccess() {
		return gaPatternLanguage.getXBasicForLoopExpressionAccess();
	}
	
	public ParserRule getXBasicForLoopExpressionRule() {
		return getXBasicForLoopExpressionAccess().getRule();
	}

	//XWhileExpression returns XExpression:
	//	{XWhileExpression} "while" "(" predicate=XExpression ")" body=XExpression;
	public XbaseGrammarAccess.XWhileExpressionElements getXWhileExpressionAccess() {
		return gaPatternLanguage.getXWhileExpressionAccess();
	}
	
	public ParserRule getXWhileExpressionRule() {
		return getXWhileExpressionAccess().getRule();
	}

	//XDoWhileExpression returns XExpression:
	//	{XDoWhileExpression} "do" body=XExpression "while" "(" predicate=XExpression ")";
	public XbaseGrammarAccess.XDoWhileExpressionElements getXDoWhileExpressionAccess() {
		return gaPatternLanguage.getXDoWhileExpressionAccess();
	}
	
	public ParserRule getXDoWhileExpressionRule() {
		return getXDoWhileExpressionAccess().getRule();
	}

	//XBlockExpression returns XExpression:
	//	{XBlockExpression} "{" (expressions+=XExpressionOrVarDeclaration ";"?)* "}";
	public XbaseGrammarAccess.XBlockExpressionElements getXBlockExpressionAccess() {
		return gaPatternLanguage.getXBlockExpressionAccess();
	}
	
	public ParserRule getXBlockExpressionRule() {
		return getXBlockExpressionAccess().getRule();
	}

	//XExpressionOrVarDeclaration returns XExpression:
	//	XVariableDeclaration | XExpression;
	public XbaseGrammarAccess.XExpressionOrVarDeclarationElements getXExpressionOrVarDeclarationAccess() {
		return gaPatternLanguage.getXExpressionOrVarDeclarationAccess();
	}
	
	public ParserRule getXExpressionOrVarDeclarationRule() {
		return getXExpressionOrVarDeclarationAccess().getRule();
	}

	//XVariableDeclaration returns XExpression:
	//	{XVariableDeclaration} (writeable?="var" | "val") (=> (type=JvmTypeReference name=ValidID) | name=ValidID) ("="
	//	right=XExpression)?;
	public XbaseGrammarAccess.XVariableDeclarationElements getXVariableDeclarationAccess() {
		return gaPatternLanguage.getXVariableDeclarationAccess();
	}
	
	public ParserRule getXVariableDeclarationRule() {
		return getXVariableDeclarationAccess().getRule();
	}

	//JvmFormalParameter returns types::JvmFormalParameter:
	//	parameterType=JvmTypeReference? name=ValidID;
	public XbaseGrammarAccess.JvmFormalParameterElements getJvmFormalParameterAccess() {
		return gaPatternLanguage.getJvmFormalParameterAccess();
	}
	
	public ParserRule getJvmFormalParameterRule() {
		return getJvmFormalParameterAccess().getRule();
	}

	//FullJvmFormalParameter returns types::JvmFormalParameter:
	//	parameterType=JvmTypeReference name=ValidID;
	public XbaseGrammarAccess.FullJvmFormalParameterElements getFullJvmFormalParameterAccess() {
		return gaPatternLanguage.getFullJvmFormalParameterAccess();
	}
	
	public ParserRule getFullJvmFormalParameterRule() {
		return getFullJvmFormalParameterAccess().getRule();
	}

	//XFeatureCall returns XExpression:
	//	{XFeatureCall} ("<" typeArguments+=JvmArgumentTypeReference ("," typeArguments+=JvmArgumentTypeReference)* ">")?
	//	feature=[types::JvmIdentifiableElement|IdOrSuper] (=> explicitOperationCall?="(" (featureCallArguments+=XShortClosure
	//	| featureCallArguments+=XExpression ("," featureCallArguments+=XExpression)*)? ")")? featureCallArguments+=XClosure?;
	public XbaseGrammarAccess.XFeatureCallElements getXFeatureCallAccess() {
		return gaPatternLanguage.getXFeatureCallAccess();
	}
	
	public ParserRule getXFeatureCallRule() {
		return getXFeatureCallAccess().getRule();
	}

	//FeatureCallID:
	//	ValidID | "extends" | "static" | "import" | "extension";
	public XbaseGrammarAccess.FeatureCallIDElements getFeatureCallIDAccess() {
		return gaPatternLanguage.getFeatureCallIDAccess();
	}
	
	public ParserRule getFeatureCallIDRule() {
		return getFeatureCallIDAccess().getRule();
	}

	//IdOrSuper:
	//	FeatureCallID | "super";
	public XbaseGrammarAccess.IdOrSuperElements getIdOrSuperAccess() {
		return gaPatternLanguage.getIdOrSuperAccess();
	}
	
	public ParserRule getIdOrSuperRule() {
		return getIdOrSuperAccess().getRule();
	}

	//XConstructorCall returns XExpression:
	//	{XConstructorCall} "new" constructor=[types::JvmConstructor|QualifiedName] ("<"
	//	typeArguments+=JvmArgumentTypeReference ("," typeArguments+=JvmArgumentTypeReference)* ">")? (=>
	//	explicitConstructorCall?="(" (arguments+=XShortClosure | arguments+=XExpression ("," arguments+=XExpression)*)? ")")?
	//	arguments+=XClosure?;
	public XbaseGrammarAccess.XConstructorCallElements getXConstructorCallAccess() {
		return gaPatternLanguage.getXConstructorCallAccess();
	}
	
	public ParserRule getXConstructorCallRule() {
		return getXConstructorCallAccess().getRule();
	}

	//XBooleanLiteral returns XExpression:
	//	{XBooleanLiteral} ("false" | isTrue?="true");
	public XbaseGrammarAccess.XBooleanLiteralElements getXBooleanLiteralAccess() {
		return gaPatternLanguage.getXBooleanLiteralAccess();
	}
	
	public ParserRule getXBooleanLiteralRule() {
		return getXBooleanLiteralAccess().getRule();
	}

	//XNullLiteral returns XExpression:
	//	{XNullLiteral} "null";
	public XbaseGrammarAccess.XNullLiteralElements getXNullLiteralAccess() {
		return gaPatternLanguage.getXNullLiteralAccess();
	}
	
	public ParserRule getXNullLiteralRule() {
		return getXNullLiteralAccess().getRule();
	}

	//XNumberLiteral returns XExpression:
	//	{XNumberLiteral} value=Number;
	public XbaseGrammarAccess.XNumberLiteralElements getXNumberLiteralAccess() {
		return gaPatternLanguage.getXNumberLiteralAccess();
	}
	
	public ParserRule getXNumberLiteralRule() {
		return getXNumberLiteralAccess().getRule();
	}

	//XStringLiteral returns XExpression:
	//	{XStringLiteral} value=STRING;
	public XbaseGrammarAccess.XStringLiteralElements getXStringLiteralAccess() {
		return gaPatternLanguage.getXStringLiteralAccess();
	}
	
	public ParserRule getXStringLiteralRule() {
		return getXStringLiteralAccess().getRule();
	}

	//XTypeLiteral returns XExpression:
	//	{XTypeLiteral} "typeof" "(" type=[types::JvmType|QualifiedName] arrayDimensions+=ArrayBrackets* ")";
	public XbaseGrammarAccess.XTypeLiteralElements getXTypeLiteralAccess() {
		return gaPatternLanguage.getXTypeLiteralAccess();
	}
	
	public ParserRule getXTypeLiteralRule() {
		return getXTypeLiteralAccess().getRule();
	}

	//XThrowExpression returns XExpression:
	//	{XThrowExpression} "throw" expression=XExpression;
	public XbaseGrammarAccess.XThrowExpressionElements getXThrowExpressionAccess() {
		return gaPatternLanguage.getXThrowExpressionAccess();
	}
	
	public ParserRule getXThrowExpressionRule() {
		return getXThrowExpressionAccess().getRule();
	}

	//XReturnExpression returns XExpression:
	//	{XReturnExpression} "return" -> expression=XExpression?;
	public XbaseGrammarAccess.XReturnExpressionElements getXReturnExpressionAccess() {
		return gaPatternLanguage.getXReturnExpressionAccess();
	}
	
	public ParserRule getXReturnExpressionRule() {
		return getXReturnExpressionAccess().getRule();
	}

	//XTryCatchFinallyExpression returns XExpression:
	//	{XTryCatchFinallyExpression} "try" expression=XExpression (catchClauses+=XCatchClause+ ("finally"
	//	finallyExpression=XExpression)? | "finally" finallyExpression=XExpression);
	public XbaseGrammarAccess.XTryCatchFinallyExpressionElements getXTryCatchFinallyExpressionAccess() {
		return gaPatternLanguage.getXTryCatchFinallyExpressionAccess();
	}
	
	public ParserRule getXTryCatchFinallyExpressionRule() {
		return getXTryCatchFinallyExpressionAccess().getRule();
	}

	//XSynchronizedExpression returns XExpression:
	//	=> ({XSynchronizedExpression} "synchronized" "(") param=XExpression ")" expression=XExpression;
	public XbaseGrammarAccess.XSynchronizedExpressionElements getXSynchronizedExpressionAccess() {
		return gaPatternLanguage.getXSynchronizedExpressionAccess();
	}
	
	public ParserRule getXSynchronizedExpressionRule() {
		return getXSynchronizedExpressionAccess().getRule();
	}

	//XCatchClause:
	//	"catch" "(" declaredParam=FullJvmFormalParameter ")" expression=XExpression;
	public XbaseGrammarAccess.XCatchClauseElements getXCatchClauseAccess() {
		return gaPatternLanguage.getXCatchClauseAccess();
	}
	
	public ParserRule getXCatchClauseRule() {
		return getXCatchClauseAccess().getRule();
	}

	//QualifiedName:
	//	ValidID ("." ValidID)*;
	public XbaseGrammarAccess.QualifiedNameElements getQualifiedNameAccess() {
		return gaPatternLanguage.getQualifiedNameAccess();
	}
	
	public ParserRule getQualifiedNameRule() {
		return getQualifiedNameAccess().getRule();
	}

	//Number hidden():
	//	HEX | (INT | DECIMAL) ("." (INT | DECIMAL))?;
	public XbaseGrammarAccess.NumberElements getNumberAccess() {
		return gaPatternLanguage.getNumberAccess();
	}
	
	public ParserRule getNumberRule() {
		return getNumberAccess().getRule();
	}

	/// **
	// * Dummy rule, for "better" downwards compatibility, since GrammarAccess generates non-static inner classes, 
	// * which makes downstream grammars break on classloading, when a rule is removed.
	// * / StaticQualifier:
	//	(ValidID "::")+;
	public XbaseGrammarAccess.StaticQualifierElements getStaticQualifierAccess() {
		return gaPatternLanguage.getStaticQualifierAccess();
	}
	
	public ParserRule getStaticQualifierRule() {
		return getStaticQualifierAccess().getRule();
	}

	//terminal HEX:
	//	("0x" | "0X") ("0".."9" | "a".."f" | "A".."F" | "_")+ ("#" (("b" | "B") ("i" | "I") | ("l" | "L")))?;
	public TerminalRule getHEXRule() {
		return gaPatternLanguage.getHEXRule();
	} 

	//terminal INT returns ecore::EInt:
	//	"0".."9" ("0".."9" | "_")*;
	public TerminalRule getINTRule() {
		return gaPatternLanguage.getINTRule();
	} 

	//terminal DECIMAL:
	//	INT (("e" | "E") ("+" | "-")? INT)? (("b" | "B") ("i" | "I" | "d" | "D") | ("l" | "L" | "d" | "D" | "f" | "F"))?;
	public TerminalRule getDECIMALRule() {
		return gaPatternLanguage.getDECIMALRule();
	} 

	//JvmTypeReference:
	//	JvmParameterizedTypeReference => ({JvmGenericArrayTypeReference.componentType=current} ArrayBrackets)* |
	//	XFunctionTypeRef;
	public XtypeGrammarAccess.JvmTypeReferenceElements getJvmTypeReferenceAccess() {
		return gaPatternLanguage.getJvmTypeReferenceAccess();
	}
	
	public ParserRule getJvmTypeReferenceRule() {
		return getJvmTypeReferenceAccess().getRule();
	}

	//ArrayBrackets:
	//	"[" "]";
	public XtypeGrammarAccess.ArrayBracketsElements getArrayBracketsAccess() {
		return gaPatternLanguage.getArrayBracketsAccess();
	}
	
	public ParserRule getArrayBracketsRule() {
		return getArrayBracketsAccess().getRule();
	}

	//XFunctionTypeRef:
	//	("(" (paramTypes+=JvmTypeReference ("," paramTypes+=JvmTypeReference)*)? ")")? "=>" returnType=JvmTypeReference;
	public XtypeGrammarAccess.XFunctionTypeRefElements getXFunctionTypeRefAccess() {
		return gaPatternLanguage.getXFunctionTypeRefAccess();
	}
	
	public ParserRule getXFunctionTypeRefRule() {
		return getXFunctionTypeRefAccess().getRule();
	}

	//JvmParameterizedTypeReference:
	//	type=[JvmType|QualifiedName] ("<" arguments+=JvmArgumentTypeReference ("," arguments+=JvmArgumentTypeReference)*
	//	">")?;
	public XtypeGrammarAccess.JvmParameterizedTypeReferenceElements getJvmParameterizedTypeReferenceAccess() {
		return gaPatternLanguage.getJvmParameterizedTypeReferenceAccess();
	}
	
	public ParserRule getJvmParameterizedTypeReferenceRule() {
		return getJvmParameterizedTypeReferenceAccess().getRule();
	}

	//JvmArgumentTypeReference returns JvmTypeReference:
	//	JvmTypeReference | JvmWildcardTypeReference;
	public XtypeGrammarAccess.JvmArgumentTypeReferenceElements getJvmArgumentTypeReferenceAccess() {
		return gaPatternLanguage.getJvmArgumentTypeReferenceAccess();
	}
	
	public ParserRule getJvmArgumentTypeReferenceRule() {
		return getJvmArgumentTypeReferenceAccess().getRule();
	}

	//JvmWildcardTypeReference:
	//	{JvmWildcardTypeReference} "?" (constraints+=JvmUpperBound | constraints+=JvmLowerBound)?;
	public XtypeGrammarAccess.JvmWildcardTypeReferenceElements getJvmWildcardTypeReferenceAccess() {
		return gaPatternLanguage.getJvmWildcardTypeReferenceAccess();
	}
	
	public ParserRule getJvmWildcardTypeReferenceRule() {
		return getJvmWildcardTypeReferenceAccess().getRule();
	}

	//JvmUpperBound:
	//	"extends" typeReference=JvmTypeReference;
	public XtypeGrammarAccess.JvmUpperBoundElements getJvmUpperBoundAccess() {
		return gaPatternLanguage.getJvmUpperBoundAccess();
	}
	
	public ParserRule getJvmUpperBoundRule() {
		return getJvmUpperBoundAccess().getRule();
	}

	//JvmUpperBoundAnded returns JvmUpperBound:
	//	"&" typeReference=JvmTypeReference;
	public XtypeGrammarAccess.JvmUpperBoundAndedElements getJvmUpperBoundAndedAccess() {
		return gaPatternLanguage.getJvmUpperBoundAndedAccess();
	}
	
	public ParserRule getJvmUpperBoundAndedRule() {
		return getJvmUpperBoundAndedAccess().getRule();
	}

	//JvmLowerBound:
	//	"super" typeReference=JvmTypeReference;
	public XtypeGrammarAccess.JvmLowerBoundElements getJvmLowerBoundAccess() {
		return gaPatternLanguage.getJvmLowerBoundAccess();
	}
	
	public ParserRule getJvmLowerBoundRule() {
		return getJvmLowerBoundAccess().getRule();
	}

	//JvmTypeParameter:
	//	name=ValidID (constraints+=JvmUpperBound constraints+=JvmUpperBoundAnded*)?;
	public XtypeGrammarAccess.JvmTypeParameterElements getJvmTypeParameterAccess() {
		return gaPatternLanguage.getJvmTypeParameterAccess();
	}
	
	public ParserRule getJvmTypeParameterRule() {
		return getJvmTypeParameterAccess().getRule();
	}

	//QualifiedNameWithWildcard:
	//	QualifiedName "." "*";
	public XtypeGrammarAccess.QualifiedNameWithWildcardElements getQualifiedNameWithWildcardAccess() {
		return gaPatternLanguage.getQualifiedNameWithWildcardAccess();
	}
	
	public ParserRule getQualifiedNameWithWildcardRule() {
		return getQualifiedNameWithWildcardAccess().getRule();
	}

	//ValidID:
	//	ID;
	public XtypeGrammarAccess.ValidIDElements getValidIDAccess() {
		return gaPatternLanguage.getValidIDAccess();
	}
	
	public ParserRule getValidIDRule() {
		return getValidIDAccess().getRule();
	}

	//XImportSection:
	//	importDeclarations+=XImportDeclaration+;
	public XtypeGrammarAccess.XImportSectionElements getXImportSectionAccess() {
		return gaPatternLanguage.getXImportSectionAccess();
	}
	
	public ParserRule getXImportSectionRule() {
		return getXImportSectionAccess().getRule();
	}

	//XImportDeclaration:
	//	"import" (static?="static" extension?="extension"? importedType=[JvmDeclaredType|QualifiedNameInStaticImport]
	//	(wildcard?="*" | memberName=ValidID) | importedType=[JvmDeclaredType|QualifiedName] |
	//	importedNamespace=QualifiedNameWithWildcard) ";"?;
	public XtypeGrammarAccess.XImportDeclarationElements getXImportDeclarationAccess() {
		return gaPatternLanguage.getXImportDeclarationAccess();
	}
	
	public ParserRule getXImportDeclarationRule() {
		return getXImportDeclarationAccess().getRule();
	}

	//QualifiedNameInStaticImport:
	//	(ValidID ".")+;
	public XtypeGrammarAccess.QualifiedNameInStaticImportElements getQualifiedNameInStaticImportAccess() {
		return gaPatternLanguage.getQualifiedNameInStaticImportAccess();
	}
	
	public ParserRule getQualifiedNameInStaticImportRule() {
		return getQualifiedNameInStaticImportAccess().getRule();
	}

	//terminal ID:
	//	"^"? ("a".."z" | "A".."Z" | "$" | "_") ("a".."z" | "A".."Z" | "$" | "_" | "0".."9")*;
	public TerminalRule getIDRule() {
		return gaPatternLanguage.getIDRule();
	} 

	//terminal STRING:
	//	"\"" ("\\" ("b" | "t" | "n" | "f" | "r" | "u" | "\"" | "\'" | "\\") | !("\\" | "\""))* "\"" | "\'" ("\\" ("b" | "t" |
	//	"n" | "f" | "r" | "u" | "\"" | "\'" | "\\") | !("\\" | "\'"))* "\'";
	public TerminalRule getSTRINGRule() {
		return gaPatternLanguage.getSTRINGRule();
	} 

	//terminal ML_COMMENT:
	//	"/ *"->"* /";
	public TerminalRule getML_COMMENTRule() {
		return gaPatternLanguage.getML_COMMENTRule();
	} 

	//terminal SL_COMMENT:
	//	"//" !("\n" | "\r")* ("\r"? "\n")?;
	public TerminalRule getSL_COMMENTRule() {
		return gaPatternLanguage.getSL_COMMENTRule();
	} 

	//terminal WS:
	//	(" " | "\t" | "\r" | "\n")+;
	public TerminalRule getWSRule() {
		return gaPatternLanguage.getWSRule();
	} 

	//terminal ANY_OTHER:
	//	.;
	public TerminalRule getANY_OTHERRule() {
		return gaPatternLanguage.getANY_OTHERRule();
	} 
}
