path: root/plugins/uml/textedit/org.eclipse.papyrus.uml.textedit.stereotypeproperty.xtext/src-gen/org/eclipse/papyrus/uml/textedit/stereotypeproperty/xtext/services/AppliedStereotypePropertyGrammarAccess.java

/*
 * generated by Xtext
 */
package org.eclipse.papyrus.uml.textedit.stereotypeproperty.xtext.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.papyrus.uml.alf.services.AlfGrammarAccess;

@Singleton
public class AppliedStereotypePropertyGrammarAccess extends AbstractGrammarElementFinder {
	
	
	public class AppliedStereotypePropertyRuleElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.papyrus.uml.textedit.stereotypeproperty.xtext.AppliedStereotypeProperty.AppliedStereotypePropertyRule");
		private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1);
		private final RuleCall cValueExpressionValueRuleParserRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0);
		
		//AppliedStereotypePropertyRule:
		//	value=ExpressionValueRule;
		@Override public ParserRule getRule() { return rule; }

		//value=ExpressionValueRule
		public Assignment getValueAssignment() { return cValueAssignment; }

		//ExpressionValueRule
		public RuleCall getValueExpressionValueRuleParserRuleCall_0() { return cValueExpressionValueRuleParserRuleCall_0; }
	}

	public class ExpressionValueRuleElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.papyrus.uml.textedit.stereotypeproperty.xtext.AppliedStereotypeProperty.ExpressionValueRule");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cEqualsSignKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Assignment cExpressionAssignment_1 = (Assignment)cGroup.eContents().get(1);
		private final RuleCall cExpressionSequenceElementParserRuleCall_1_0 = (RuleCall)cExpressionAssignment_1.eContents().get(0);
		
		//ExpressionValueRule:
		//	'=' expression=SequenceElement;
		@Override public ParserRule getRule() { return rule; }

		//'=' expression=SequenceElement
		public Group getGroup() { return cGroup; }

		//'='
		public Keyword getEqualsSignKeyword_0() { return cEqualsSignKeyword_0; }

		//expression=SequenceElement
		public Assignment getExpressionAssignment_1() { return cExpressionAssignment_1; }

		//SequenceElement
		public RuleCall getExpressionSequenceElementParserRuleCall_1_0() { return cExpressionSequenceElementParserRuleCall_1_0; }
	}
	
	
	private final AppliedStereotypePropertyRuleElements pAppliedStereotypePropertyRule;
	private final ExpressionValueRuleElements pExpressionValueRule;
	
	private final Grammar grammar;

	private final AlfGrammarAccess gaAlf;

	@Inject
	public AppliedStereotypePropertyGrammarAccess(GrammarProvider grammarProvider,
		AlfGrammarAccess gaAlf) {
		this.grammar = internalFindGrammar(grammarProvider);
		this.gaAlf = gaAlf;
		this.pAppliedStereotypePropertyRule = new AppliedStereotypePropertyRuleElements();
		this.pExpressionValueRule = new ExpressionValueRuleElements();
	}
	
	protected Grammar internalFindGrammar(GrammarProvider grammarProvider) {
		Grammar grammar = grammarProvider.getGrammar(this);
		while (grammar != null) {
			if ("org.eclipse.papyrus.uml.textedit.stereotypeproperty.xtext.AppliedStereotypeProperty".equals(grammar.getName())) {
				return grammar;
			}
			List<Grammar> grammars = grammar.getUsedGrammars();
			if (!grammars.isEmpty()) {
				grammar = grammars.iterator().next();
			} else {
				return null;
			}
		}
		return grammar;
	}
	
	@Override
	public Grammar getGrammar() {
		return grammar;
	}
	

	public AlfGrammarAccess getAlfGrammarAccess() {
		return gaAlf;
	}

	
	//AppliedStereotypePropertyRule:
	//	value=ExpressionValueRule;
	public AppliedStereotypePropertyRuleElements getAppliedStereotypePropertyRuleAccess() {
		return pAppliedStereotypePropertyRule;
	}
	
	public ParserRule getAppliedStereotypePropertyRuleRule() {
		return getAppliedStereotypePropertyRuleAccess().getRule();
	}

	//ExpressionValueRule:
	//	'=' expression=SequenceElement;
	public ExpressionValueRuleElements getExpressionValueRuleAccess() {
		return pExpressionValueRule;
	}
	
	public ParserRule getExpressionValueRuleRule() {
		return getExpressionValueRuleAccess().getRule();
	}

	/// *********
	// * UNITS *
	// ********* / UnitDefinition:
	//	namespaceName=NamespaceDeclaration?
	//	^import+=ImportDeclaration*
	//	documentation+=DOCUMENTATION_COMMENT?
	//	annotation+=StereotypeAnnotation*
	//	definition=NamespaceDefinition;
	public AlfGrammarAccess.UnitDefinitionElements getUnitDefinitionAccess() {
		return gaAlf.getUnitDefinitionAccess();
	}
	
	public ParserRule getUnitDefinitionRule() {
		return getUnitDefinitionAccess().getRule();
	}

	//StereotypeAnnotation:
	//	'@' stereotypeName=QualifiedName ('(' (names=QualifiedNameList | taggedValues=TaggedValueList) ')')?;
	public AlfGrammarAccess.StereotypeAnnotationElements getStereotypeAnnotationAccess() {
		return gaAlf.getStereotypeAnnotationAccess();
	}
	
	public ParserRule getStereotypeAnnotationRule() {
		return getStereotypeAnnotationAccess().getRule();
	}

	//TaggedValueList:
	//	taggedValue+=TaggedValue ("," taggedValue+=TaggedValue)*;
	public AlfGrammarAccess.TaggedValueListElements getTaggedValueListAccess() {
		return gaAlf.getTaggedValueListAccess();
	}
	
	public ParserRule getTaggedValueListRule() {
		return getTaggedValueListAccess().getRule();
	}

	//TaggedValue:
	//	name=Name '=>' (value=BOOLEAN_VALUE | operator=NumericUnaryOperator? value=NATURAL_VALUE | value='*' | value=STRING);
	public AlfGrammarAccess.TaggedValueElements getTaggedValueAccess() {
		return gaAlf.getTaggedValueAccess();
	}
	
	public ParserRule getTaggedValueRule() {
		return getTaggedValueAccess().getRule();
	}

	//NamespaceDeclaration QualifiedName:
	//	'namespace' QualifiedName ';'
	public AlfGrammarAccess.NamespaceDeclarationElements getNamespaceDeclarationAccess() {
		return gaAlf.getNamespaceDeclarationAccess();
	}
	
	public ParserRule getNamespaceDeclarationRule() {
		return getNamespaceDeclarationAccess().getRule();
	}

	//ImportDeclaration ImportReference:
	//	(PackageImportReference | ElementImportReference) ';'
	public AlfGrammarAccess.ImportDeclarationElements getImportDeclarationAccess() {
		return gaAlf.getImportDeclarationAccess();
	}
	
	public ParserRule getImportDeclarationRule() {
		return getImportDeclarationAccess().getRule();
	}

	//ElementImportReference:
	//	visibility=ImportVisibilityIndicator 'import' referentName=QualifiedName ('as' alias=Name)?;
	public AlfGrammarAccess.ElementImportReferenceElements getElementImportReferenceAccess() {
		return gaAlf.getElementImportReferenceAccess();
	}
	
	public ParserRule getElementImportReferenceRule() {
		return getElementImportReferenceAccess().getRule();
	}

	//PackageImportReference:
	//	visibility=ImportVisibilityIndicator 'import' referentName=PackageImportQualifiedName
	//	//  ( 
	//	//    referentName = UnqualifiedName ('::' | '.') '*' |
	//	//    referentName = ColonQualifiedName '::' '*' | 
	//	//    referentName = DotQualifiedName '.' '*'
	//	//  )
	//;
	public AlfGrammarAccess.PackageImportReferenceElements getPackageImportReferenceAccess() {
		return gaAlf.getPackageImportReferenceAccess();
	}
	
	public ParserRule getPackageImportReferenceRule() {
		return getPackageImportReferenceAccess().getRule();
	}

	//PackageImportQualifiedName QualifiedName:
	//	nameBinding+=NameBinding (('::' nameBinding+=NameBinding)* '::' '*' | ('.' nameBinding+=NameBinding)* '.' '*')
	public AlfGrammarAccess.PackageImportQualifiedNameElements getPackageImportQualifiedNameAccess() {
		return gaAlf.getPackageImportQualifiedNameAccess();
	}
	
	public ParserRule getPackageImportQualifiedNameRule() {
		return getPackageImportQualifiedNameAccess().getRule();
	}

	//ImportVisibilityIndicator:
	//	'public' | 'private';
	public AlfGrammarAccess.ImportVisibilityIndicatorElements getImportVisibilityIndicatorAccess() {
		return gaAlf.getImportVisibilityIndicatorAccess();
	}
	
	public ParserRule getImportVisibilityIndicatorRule() {
		return getImportVisibilityIndicatorAccess().getRule();
	}

	/// * NAMESPACES * / NamespaceDefinition:
	//	PackageDefinition | ClassifierDefinition;
	public AlfGrammarAccess.NamespaceDefinitionElements getNamespaceDefinitionAccess() {
		return gaAlf.getNamespaceDefinitionAccess();
	}
	
	public ParserRule getNamespaceDefinitionRule() {
		return getNamespaceDefinitionAccess().getRule();
	}

	//VisibilityIndicator:
	//	ImportVisibilityIndicator | 'protected';
	public AlfGrammarAccess.VisibilityIndicatorElements getVisibilityIndicatorAccess() {
		return gaAlf.getVisibilityIndicatorAccess();
	}
	
	public ParserRule getVisibilityIndicatorRule() {
		return getVisibilityIndicatorAccess().getRule();
	}

	//// CHANGE: Separated Member into Member with a composite reference to MemberDefinition.
	/// * PACKAGES * / PackageDefinition:
	//	'package' name=Name '{' ownedMember+=PackagedElement* '}';
	public AlfGrammarAccess.PackageDefinitionElements getPackageDefinitionAccess() {
		return gaAlf.getPackageDefinitionAccess();
	}
	
	public ParserRule getPackageDefinitionRule() {
		return getPackageDefinitionAccess().getRule();
	}

	//PackageDefinitionOrStub PackageDefinition:
	//	'package' name=Name (isStub?=';' | '{' ownedMember+=PackagedElement* '}')
	public AlfGrammarAccess.PackageDefinitionOrStubElements getPackageDefinitionOrStubAccess() {
		return gaAlf.getPackageDefinitionOrStubAccess();
	}
	
	public ParserRule getPackageDefinitionOrStubRule() {
		return getPackageDefinitionOrStubAccess().getRule();
	}

	//// PackageBody : 
	//// 	{PackageBody}'{' ( packagedElement += PackagedElement )* '}'
	//// ;
	//PackagedElement Member:
	//	documentation+=DOCUMENTATION_COMMENT?
	//	annotation+=StereotypeAnnotation*
	//	visibility=ImportVisibilityIndicator
	//	definition=PackagedElementDefinition
	public AlfGrammarAccess.PackagedElementElements getPackagedElementAccess() {
		return gaAlf.getPackagedElementAccess();
	}
	
	public ParserRule getPackagedElementRule() {
		return getPackagedElementAccess().getRule();
	}

	//PackagedElementDefinition MemberDefinition:
	//	PackageDefinitionOrStub | ClassifierDefinitionOrStub
	public AlfGrammarAccess.PackagedElementDefinitionElements getPackagedElementDefinitionAccess() {
		return gaAlf.getPackagedElementDefinitionAccess();
	}
	
	public ParserRule getPackagedElementDefinitionRule() {
		return getPackagedElementDefinitionAccess().getRule();
	}

	/// ***************
	// * CLASSIFIERS *
	// *************** / ClassifierDefinition:
	//	ClassDefinition | ActiveClassDefinition | DataTypeDefinition | EnumerationDefinition | AssociationDefinition |
	//	SignalDefinition | ActivityDefinition;
	public AlfGrammarAccess.ClassifierDefinitionElements getClassifierDefinitionAccess() {
		return gaAlf.getClassifierDefinitionAccess();
	}
	
	public ParserRule getClassifierDefinitionRule() {
		return getClassifierDefinitionAccess().getRule();
	}

	//ClassifierDefinitionOrStub ClassifierDefinition:
	//	ClassDefinitionOrStub | ActiveClassDefinitionOrStub | DataTypeDefinitionOrStub | EnumerationDefinitionOrStub |
	//	AssociationDefinitionOrStub | SignalDefinitionOrStub | ActivityDefinitionOrStub
	public AlfGrammarAccess.ClassifierDefinitionOrStubElements getClassifierDefinitionOrStubAccess() {
		return gaAlf.getClassifierDefinitionOrStubAccess();
	}
	
	public ParserRule getClassifierDefinitionOrStubRule() {
		return getClassifierDefinitionOrStubAccess().getRule();
	}

	//ClassifierSignature ClassifierDefinition:
	//	name=Name ('<' ownedMember+=ClassifierTemplateParameter (',' ownedMember+=ClassifierTemplateParameter)* '>')?
	//	specialization=SpecializationClause?
	public AlfGrammarAccess.ClassifierSignatureElements getClassifierSignatureAccess() {
		return gaAlf.getClassifierSignatureAccess();
	}
	
	public ParserRule getClassifierSignatureRule() {
		return getClassifierSignatureAccess().getRule();
	}

	//ClassifierTemplateParameter Member:
	//	documentation+=DOCUMENTATION_COMMENT?
	//	definition=ClassifierTemplateParameterDefinition
	public AlfGrammarAccess.ClassifierTemplateParameterElements getClassifierTemplateParameterAccess() {
		return gaAlf.getClassifierTemplateParameterAccess();
	}
	
	public ParserRule getClassifierTemplateParameterRule() {
		return getClassifierTemplateParameterAccess().getRule();
	}

	//ClassifierTemplateParameterDefinition ClassifierTemplateParameter:
	//	name=Name ('specializes' specialization=TemplateParameterConstraint)?
	public AlfGrammarAccess.ClassifierTemplateParameterDefinitionElements getClassifierTemplateParameterDefinitionAccess() {
		return gaAlf.getClassifierTemplateParameterDefinitionAccess();
	}
	
	public ParserRule getClassifierTemplateParameterDefinitionRule() {
		return getClassifierTemplateParameterDefinitionAccess().getRule();
	}

	//TemplateParameterConstraint QualifiedNameList:
	//	name+=QualifiedName
	public AlfGrammarAccess.TemplateParameterConstraintElements getTemplateParameterConstraintAccess() {
		return gaAlf.getTemplateParameterConstraintAccess();
	}
	
	public ParserRule getTemplateParameterConstraintRule() {
		return getTemplateParameterConstraintAccess().getRule();
	}

	//SpecializationClause QualifiedNameList:
	//	'specializes' QualifiedNameList
	public AlfGrammarAccess.SpecializationClauseElements getSpecializationClauseAccess() {
		return gaAlf.getSpecializationClauseAccess();
	}
	
	public ParserRule getSpecializationClauseRule() {
		return getSpecializationClauseAccess().getRule();
	}

	/// * CLASSES * / ClassDeclaration ClassDefinition:
	//	isAbstract?='abstract'? 'class' name=Name ('<' ownedMember+=ClassifierTemplateParameter (','
	//	ownedMember+=ClassifierTemplateParameter)* '>')?
	//	specialization=SpecializationClause?
	public AlfGrammarAccess.ClassDeclarationElements getClassDeclarationAccess() {
		return gaAlf.getClassDeclarationAccess();
	}
	
	public ParserRule getClassDeclarationRule() {
		return getClassDeclarationAccess().getRule();
	}

	//ClassDefinition:
	//	ClassDeclaration
	//	'{' ownedMember+=ClassMember* '}';
	public AlfGrammarAccess.ClassDefinitionElements getClassDefinitionAccess() {
		return gaAlf.getClassDefinitionAccess();
	}
	
	public ParserRule getClassDefinitionRule() {
		return getClassDefinitionAccess().getRule();
	}

	//ClassDefinitionOrStub ClassDefinition:
	//	ClassDeclaration (isStub?=';' | '{' ownedMember+=ClassMember* '}')
	public AlfGrammarAccess.ClassDefinitionOrStubElements getClassDefinitionOrStubAccess() {
		return gaAlf.getClassDefinitionOrStubAccess();
	}
	
	public ParserRule getClassDefinitionOrStubRule() {
		return getClassDefinitionOrStubAccess().getRule();
	}

	//ClassMember Member:
	//	documentation+=DOCUMENTATION_COMMENT*
	//	annotation+=StereotypeAnnotation*
	//	visibility=VisibilityIndicator?
	//	definition=ClassMemberDefinition
	public AlfGrammarAccess.ClassMemberElements getClassMemberAccess() {
		return gaAlf.getClassMemberAccess();
	}
	
	public ParserRule getClassMemberRule() {
		return getClassMemberAccess().getRule();
	}

	//ClassMemberDefinition MemberDefinition:
	//	ClassifierDefinitionOrStub | FeatureDefinitionOrStub
	public AlfGrammarAccess.ClassMemberDefinitionElements getClassMemberDefinitionAccess() {
		return gaAlf.getClassMemberDefinitionAccess();
	}
	
	public ParserRule getClassMemberDefinitionRule() {
		return getClassMemberDefinitionAccess().getRule();
	}

	/// * ACTIVE CLASSES * / ActiveClassDeclaration ActiveClassDefinition:
	//	isAbstract?='abstract'? 'active' 'class' name=Name ('<' ownedMember+=ClassifierTemplateParameter (','
	//	ownedMember+=ClassifierTemplateParameter)* '>')?
	//	specialization=SpecializationClause?
	public AlfGrammarAccess.ActiveClassDeclarationElements getActiveClassDeclarationAccess() {
		return gaAlf.getActiveClassDeclarationAccess();
	}
	
	public ParserRule getActiveClassDeclarationRule() {
		return getActiveClassDeclarationAccess().getRule();
	}

	//ActiveClassDefinition:
	//	ActiveClassDeclaration
	//	'{' ownedMember+=ActiveClassMember* '}' ('do' classifierBehavior=BehaviorClause)?;
	public AlfGrammarAccess.ActiveClassDefinitionElements getActiveClassDefinitionAccess() {
		return gaAlf.getActiveClassDefinitionAccess();
	}
	
	public ParserRule getActiveClassDefinitionRule() {
		return getActiveClassDefinitionAccess().getRule();
	}

	//ActiveClassDefinitionOrStub ActiveClassDefinition:
	//	ActiveClassDeclaration (isStub?=';' |
	//	'{' ownedMember+=ActiveClassMember* '}' ('do' classifierBehavior=BehaviorClause)?)
	public AlfGrammarAccess.ActiveClassDefinitionOrStubElements getActiveClassDefinitionOrStubAccess() {
		return gaAlf.getActiveClassDefinitionOrStubAccess();
	}
	
	public ParserRule getActiveClassDefinitionOrStubRule() {
		return getActiveClassDefinitionOrStubAccess().getRule();
	}

	//BehaviorClause ActivityDefinition:
	//	body=Block | name=Name
	public AlfGrammarAccess.BehaviorClauseElements getBehaviorClauseAccess() {
		return gaAlf.getBehaviorClauseAccess();
	}
	
	public ParserRule getBehaviorClauseRule() {
		return getBehaviorClauseAccess().getRule();
	}

	//ActiveClassMember Member:
	//	documentation+=DOCUMENTATION_COMMENT?
	//	annotation+=StereotypeAnnotation*
	//	visibility=VisibilityIndicator?
	//	definition=ActiveClassMemberDefinition
	public AlfGrammarAccess.ActiveClassMemberElements getActiveClassMemberAccess() {
		return gaAlf.getActiveClassMemberAccess();
	}
	
	public ParserRule getActiveClassMemberRule() {
		return getActiveClassMemberAccess().getRule();
	}

	//ActiveClassMemberDefinition MemberDefinition:
	//	ClassMemberDefinition | ActiveFeatureDefinitionOrStub
	public AlfGrammarAccess.ActiveClassMemberDefinitionElements getActiveClassMemberDefinitionAccess() {
		return gaAlf.getActiveClassMemberDefinitionAccess();
	}
	
	public ParserRule getActiveClassMemberDefinitionRule() {
		return getActiveClassMemberDefinitionAccess().getRule();
	}

	/// * DATA TYPES * / DataTypeDeclaration DataTypeDefinition:
	//	isAbstract?='abstract'? 'datatype' name=Name ('<' ownedMember+=ClassifierTemplateParameter (','
	//	ownedMember+=ClassifierTemplateParameter)* '>')?
	//	specialization=SpecializationClause?
	public AlfGrammarAccess.DataTypeDeclarationElements getDataTypeDeclarationAccess() {
		return gaAlf.getDataTypeDeclarationAccess();
	}
	
	public ParserRule getDataTypeDeclarationRule() {
		return getDataTypeDeclarationAccess().getRule();
	}

	//DataTypeDefinition:
	//	DataTypeDeclaration
	//	'{' ownedMember+=StructuredMember* '}';
	public AlfGrammarAccess.DataTypeDefinitionElements getDataTypeDefinitionAccess() {
		return gaAlf.getDataTypeDefinitionAccess();
	}
	
	public ParserRule getDataTypeDefinitionRule() {
		return getDataTypeDefinitionAccess().getRule();
	}

	//DataTypeDefinitionOrStub DataTypeDefinition:
	//	DataTypeDeclaration (isStub?=';' | '{' ownedMember+=StructuredMember* '}')
	public AlfGrammarAccess.DataTypeDefinitionOrStubElements getDataTypeDefinitionOrStubAccess() {
		return gaAlf.getDataTypeDefinitionOrStubAccess();
	}
	
	public ParserRule getDataTypeDefinitionOrStubRule() {
		return getDataTypeDefinitionOrStubAccess().getRule();
	}

	//StructuredMember Member:
	//	documentation+=DOCUMENTATION_COMMENT?
	//	annotation+=StereotypeAnnotation*
	//	visibility='public'?
	//	definition=PropertyDefinition
	public AlfGrammarAccess.StructuredMemberElements getStructuredMemberAccess() {
		return gaAlf.getStructuredMemberAccess();
	}
	
	public ParserRule getStructuredMemberRule() {
		return getStructuredMemberAccess().getRule();
	}

	/// * ASSOCIATIONS * / AssociationDeclaration AssociationDefinition:
	//	isAbstract?='abstract'? 'assoc' name=Name ('<' ownedMember+=ClassifierTemplateParameter (','
	//	ownedMember+=ClassifierTemplateParameter)* '>')?
	//	specialization=SpecializationClause?
	public AlfGrammarAccess.AssociationDeclarationElements getAssociationDeclarationAccess() {
		return gaAlf.getAssociationDeclarationAccess();
	}
	
	public ParserRule getAssociationDeclarationRule() {
		return getAssociationDeclarationAccess().getRule();
	}

	//AssociationDefinition:
	//	AssociationDeclaration
	//	'{' ownedMember+=StructuredMember* '}';
	public AlfGrammarAccess.AssociationDefinitionElements getAssociationDefinitionAccess() {
		return gaAlf.getAssociationDefinitionAccess();
	}
	
	public ParserRule getAssociationDefinitionRule() {
		return getAssociationDefinitionAccess().getRule();
	}

	//AssociationDefinitionOrStub AssociationDefinition:
	//	AssociationDeclaration (isStub?=';' | '{' ownedMember+=StructuredMember* '}')
	public AlfGrammarAccess.AssociationDefinitionOrStubElements getAssociationDefinitionOrStubAccess() {
		return gaAlf.getAssociationDefinitionOrStubAccess();
	}
	
	public ParserRule getAssociationDefinitionOrStubRule() {
		return getAssociationDefinitionOrStubAccess().getRule();
	}

	/// * ENUMERATIONS * / EnumerationDeclaration EnumerationDefinition:
	//	'enum' name=Name specialization=SpecializationClause?
	public AlfGrammarAccess.EnumerationDeclarationElements getEnumerationDeclarationAccess() {
		return gaAlf.getEnumerationDeclarationAccess();
	}
	
	public ParserRule getEnumerationDeclarationRule() {
		return getEnumerationDeclarationAccess().getRule();
	}

	//EnumerationDefinition:
	//	EnumerationDeclaration
	//	'{' (ownedMember+=EnumerationLiteralName (',' ownedMember+=EnumerationLiteralName)*)? '}';
	public AlfGrammarAccess.EnumerationDefinitionElements getEnumerationDefinitionAccess() {
		return gaAlf.getEnumerationDefinitionAccess();
	}
	
	public ParserRule getEnumerationDefinitionRule() {
		return getEnumerationDefinitionAccess().getRule();
	}

	//EnumerationDefinitionOrStub EnumerationDefinition:
	//	EnumerationDeclaration (isStub?=';' | '{' (ownedMember+=EnumerationLiteralName (','
	//	ownedMember+=EnumerationLiteralName)*)? '}')
	public AlfGrammarAccess.EnumerationDefinitionOrStubElements getEnumerationDefinitionOrStubAccess() {
		return gaAlf.getEnumerationDefinitionOrStubAccess();
	}
	
	public ParserRule getEnumerationDefinitionOrStubRule() {
		return getEnumerationDefinitionOrStubAccess().getRule();
	}

	//EnumerationLiteralName Member:
	//	documentation+=DOCUMENTATION_COMMENT?
	//	// TODO: visibility = 'public'
	//	definition=EnumerationLiteralNameDefinition
	public AlfGrammarAccess.EnumerationLiteralNameElements getEnumerationLiteralNameAccess() {
		return gaAlf.getEnumerationLiteralNameAccess();
	}
	
	public ParserRule getEnumerationLiteralNameRule() {
		return getEnumerationLiteralNameAccess().getRule();
	}

	//EnumerationLiteralNameDefinition EnumerationLiteralName:
	//	name=Name
	public AlfGrammarAccess.EnumerationLiteralNameDefinitionElements getEnumerationLiteralNameDefinitionAccess() {
		return gaAlf.getEnumerationLiteralNameDefinitionAccess();
	}
	
	public ParserRule getEnumerationLiteralNameDefinitionRule() {
		return getEnumerationLiteralNameDefinitionAccess().getRule();
	}

	/// * SIGNALS * / SignalDeclaration SignalDefinition:
	//	isAbstract?='abstract'? 'signal' name=Name ('<' ownedMember+=ClassifierTemplateParameter (','
	//	ownedMember+=ClassifierTemplateParameter)* '>')?
	//	specialization=SpecializationClause?
	public AlfGrammarAccess.SignalDeclarationElements getSignalDeclarationAccess() {
		return gaAlf.getSignalDeclarationAccess();
	}
	
	public ParserRule getSignalDeclarationRule() {
		return getSignalDeclarationAccess().getRule();
	}

	//SignalDefinition:
	//	SignalDeclaration
	//	'{' ownedMember+=StructuredMember* '}';
	public AlfGrammarAccess.SignalDefinitionElements getSignalDefinitionAccess() {
		return gaAlf.getSignalDefinitionAccess();
	}
	
	public ParserRule getSignalDefinitionRule() {
		return getSignalDefinitionAccess().getRule();
	}

	//SignalDefinitionOrStub SignalDefinition:
	//	SignalDeclaration (isStub?=';' | '{' ownedMember+=StructuredMember* '}')
	public AlfGrammarAccess.SignalDefinitionOrStubElements getSignalDefinitionOrStubAccess() {
		return gaAlf.getSignalDefinitionOrStubAccess();
	}
	
	public ParserRule getSignalDefinitionOrStubRule() {
		return getSignalDefinitionOrStubAccess().getRule();
	}

	/// * ACTIVITIES * / ActivityDeclaration ActivityDefinition:
	//	'activity' name=Name ('<' ownedMember+=ClassifierTemplateParameter (',' ownedMember+=ClassifierTemplateParameter)*
	//	'>')?
	//	'(' (ownedMember+=FormalParameter (',' ownedMember+=FormalParameter)*)? ')'
	//	ownedMember+=ReturnParameter?
	public AlfGrammarAccess.ActivityDeclarationElements getActivityDeclarationAccess() {
		return gaAlf.getActivityDeclarationAccess();
	}
	
	public ParserRule getActivityDeclarationRule() {
		return getActivityDeclarationAccess().getRule();
	}

	//ActivityDefinition:
	//	ActivityDeclaration
	//	body=Block;
	public AlfGrammarAccess.ActivityDefinitionElements getActivityDefinitionAccess() {
		return gaAlf.getActivityDefinitionAccess();
	}
	
	public ParserRule getActivityDefinitionRule() {
		return getActivityDefinitionAccess().getRule();
	}

	//ActivityDefinitionOrStub ActivityDefinition:
	//	ActivityDeclaration (isStub?=';' | body=Block)
	public AlfGrammarAccess.ActivityDefinitionOrStubElements getActivityDefinitionOrStubAccess() {
		return gaAlf.getActivityDefinitionOrStubAccess();
	}
	
	public ParserRule getActivityDefinitionOrStubRule() {
		return getActivityDefinitionOrStubAccess().getRule();
	}

	//FormalParameter Member:
	//	documentation+=DOCUMENTATION_COMMENT?
	//	annotation+=StereotypeAnnotation*
	//	definition=FormalParameterDefinition
	public AlfGrammarAccess.FormalParameterElements getFormalParameterAccess() {
		return gaAlf.getFormalParameterAccess();
	}
	
	public ParserRule getFormalParameterRule() {
		return getFormalParameterAccess().getRule();
	}

	//FormalParameterDefinition NonReturnParameter:
	//	direction=ParameterDirection name=Name ':'
	//	// CHANGE: Made TypedElementDefinition a composite part of FormalParameter, rather than the supertype
	//	typePart=TypePart
	public AlfGrammarAccess.FormalParameterDefinitionElements getFormalParameterDefinitionAccess() {
		return gaAlf.getFormalParameterDefinitionAccess();
	}
	
	public ParserRule getFormalParameterDefinitionRule() {
		return getFormalParameterDefinitionAccess().getRule();
	}

	//ReturnParameter Member:
	//	definition=ReturnParameterDefinition
	public AlfGrammarAccess.ReturnParameterElements getReturnParameterAccess() {
		return gaAlf.getReturnParameterAccess();
	}
	
	public ParserRule getReturnParameterRule() {
		return getReturnParameterAccess().getRule();
	}

	//ReturnParameterDefinition ReturnParameter: // CHANGE: Added the NonReturnParameter subtype of FormalParameter to accomodate Xtext serialization.
	//	':' typePart=TypePart
	public AlfGrammarAccess.ReturnParameterDefinitionElements getReturnParameterDefinitionAccess() {
		return gaAlf.getReturnParameterDefinitionAccess();
	}
	
	public ParserRule getReturnParameterDefinitionRule() {
		return getReturnParameterDefinitionAccess().getRule();
	}

	//ParameterDirection:
	//	'in' | 'out' | 'inout';
	public AlfGrammarAccess.ParameterDirectionElements getParameterDirectionAccess() {
		return gaAlf.getParameterDirectionAccess();
	}
	
	public ParserRule getParameterDirectionRule() {
		return getParameterDirectionAccess().getRule();
	}

	/// * FEATURES * / FeatureDefinitionOrStub MemberDefinition:
	//	AttributeDefinition | OperationDefinitionOrStub
	public AlfGrammarAccess.FeatureDefinitionOrStubElements getFeatureDefinitionOrStubAccess() {
		return gaAlf.getFeatureDefinitionOrStubAccess();
	}
	
	public ParserRule getFeatureDefinitionOrStubRule() {
		return getFeatureDefinitionOrStubAccess().getRule();
	}

	//ActiveFeatureDefinitionOrStub MemberDefinition:
	//	ReceptionDefinition | SignalReceptionDefinitionOrStub
	public AlfGrammarAccess.ActiveFeatureDefinitionOrStubElements getActiveFeatureDefinitionOrStubAccess() {
		return gaAlf.getActiveFeatureDefinitionOrStubAccess();
	}
	
	public ParserRule getActiveFeatureDefinitionOrStubRule() {
		return getActiveFeatureDefinitionOrStubAccess().getRule();
	}

	/// * PROPERTIES * / PropertyDefinition:
	//	PropertyDeclaration ';';
	public AlfGrammarAccess.PropertyDefinitionElements getPropertyDefinitionAccess() {
		return gaAlf.getPropertyDefinitionAccess();
	}
	
	public ParserRule getPropertyDefinitionRule() {
		return getPropertyDefinitionAccess().getRule();
	}

	//AttributeDefinition PropertyDefinition:
	//	PropertyDeclaration initializer=AttributeInitializer? ';'
	public AlfGrammarAccess.AttributeDefinitionElements getAttributeDefinitionAccess() {
		return gaAlf.getAttributeDefinitionAccess();
	}
	
	public ParserRule getAttributeDefinitionRule() {
		return getAttributeDefinitionAccess().getRule();
	}

	//AttributeInitializer Expression:
	//	'=' InitializationExpression
	public AlfGrammarAccess.AttributeInitializerElements getAttributeInitializerAccess() {
		return gaAlf.getAttributeInitializerAccess();
	}
	
	public ParserRule getAttributeInitializerRule() {
		return getAttributeInitializerAccess().getRule();
	}

	//PropertyDeclaration PropertyDefinition:
	//	name=Name ':' isComposite?='compose'?
	//	// CHANGE: Made TypedElementDefinition a composite part of PropertyDefinition instead of the supertype
	//	typePart=TypePart
	public AlfGrammarAccess.PropertyDeclarationElements getPropertyDeclarationAccess() {
		return gaAlf.getPropertyDeclarationAccess();
	}
	
	public ParserRule getPropertyDeclarationRule() {
		return getPropertyDeclarationAccess().getRule();
	}

	//TypePart TypedElementDefinition:
	//	(isAny?='any' | typeName=QualifiedName) (('[' (isMultiplicity?=']' | (lowerBound=NATURAL_VALUE '..')?
	//	upperBound=UnlimitedNaturalLiteral ']'))? (isOrdered?='ordered' isNonunique?='nonunique'? | isNonunique?='nonunique'
	//	isOrdered?='ordered'? | isSequence?='sequence')?)?
	public AlfGrammarAccess.TypePartElements getTypePartAccess() {
		return gaAlf.getTypePartAccess();
	}
	
	public ParserRule getTypePartRule() {
		return getTypePartAccess().getRule();
	}

	/// *
	//TypeName returns QualifiedName :
	//	'any' | QualifiedName
	//;
	// * / UnlimitedNaturalLiteral:
	//	NATURAL_VALUE | '*';
	public AlfGrammarAccess.UnlimitedNaturalLiteralElements getUnlimitedNaturalLiteralAccess() {
		return gaAlf.getUnlimitedNaturalLiteralAccess();
	}
	
	public ParserRule getUnlimitedNaturalLiteralRule() {
		return getUnlimitedNaturalLiteralAccess().getRule();
	}

	/// * OPERATIONS * / OperationDeclaration OperationDefinition:
	//	isAbstract?='abstract'? name=Name
	//	'(' (ownedMember+=FormalParameter (',' ownedMember+=FormalParameter)*)? ')'
	//	ownedMember+=ReturnParameter?
	//	redefinition=RedefinitionClause?
	public AlfGrammarAccess.OperationDeclarationElements getOperationDeclarationAccess() {
		return gaAlf.getOperationDeclarationAccess();
	}
	
	public ParserRule getOperationDeclarationRule() {
		return getOperationDeclarationAccess().getRule();
	}

	//OperationDefinitionOrStub OperationDefinition:
	//	OperationDeclaration (isStub?=';' | body=Block)
	public AlfGrammarAccess.OperationDefinitionOrStubElements getOperationDefinitionOrStubAccess() {
		return gaAlf.getOperationDefinitionOrStubAccess();
	}
	
	public ParserRule getOperationDefinitionOrStubRule() {
		return getOperationDefinitionOrStubAccess().getRule();
	}

	//RedefinitionClause QualifiedNameList:
	//	'redefines' QualifiedNameList
	public AlfGrammarAccess.RedefinitionClauseElements getRedefinitionClauseAccess() {
		return gaAlf.getRedefinitionClauseAccess();
	}
	
	public ParserRule getRedefinitionClauseRule() {
		return getRedefinitionClauseAccess().getRule();
	}

	/// * RECEPTIONS * / ReceptionDefinition:
	//	'receive' signalName=QualifiedName ';'
	//	// TODO: name = signal.nameBinding->last().name
	//;
	public AlfGrammarAccess.ReceptionDefinitionElements getReceptionDefinitionAccess() {
		return gaAlf.getReceptionDefinitionAccess();
	}
	
	public ParserRule getReceptionDefinitionRule() {
		return getReceptionDefinitionAccess().getRule();
	}

	//SignalReceptionDeclaration SignalReceptionDefinition:
	//	'receive' 'signal' name=Name specialization=SpecializationClause?
	public AlfGrammarAccess.SignalReceptionDeclarationElements getSignalReceptionDeclarationAccess() {
		return gaAlf.getSignalReceptionDeclarationAccess();
	}
	
	public ParserRule getSignalReceptionDeclarationRule() {
		return getSignalReceptionDeclarationAccess().getRule();
	}

	//SignalReceptionDefinitionOrStub SignalReceptionDefinition:
	//	SignalReceptionDeclaration (isStub?=';' | '{' ownedMember+=StructuredMember* '}')
	public AlfGrammarAccess.SignalReceptionDefinitionOrStubElements getSignalReceptionDefinitionOrStubAccess() {
		return gaAlf.getSignalReceptionDefinitionOrStubAccess();
	}
	
	public ParserRule getSignalReceptionDefinitionOrStubRule() {
		return getSignalReceptionDefinitionOrStubAccess().getRule();
	}

	/// ***************
	// * NAMES        *
	// *************** / Name:
	//	ID | UNRESTRICTED_NAME;
	public AlfGrammarAccess.NameElements getNameAccess() {
		return gaAlf.getNameAccess();
	}
	
	public ParserRule getNameRule() {
		return getNameAccess().getRule();
	}

	//QualifiedName:
	//	UnqualifiedName (('::' nameBinding+=NameBinding)+ | ('.' nameBinding+=NameBinding)+)?;
	public AlfGrammarAccess.QualifiedNameElements getQualifiedNameAccess() {
		return gaAlf.getQualifiedNameAccess();
	}
	
	public ParserRule getQualifiedNameRule() {
		return getQualifiedNameAccess().getRule();
	}

	//PotentiallyAmbiguousQualifiedName QualifiedName:
	//	UnqualifiedName (('::' nameBinding+=NameBinding)+ | isAmbiguous?='.' nameBinding+=NameBinding ('.'
	//	nameBinding+=NameBinding)*)?
	public AlfGrammarAccess.PotentiallyAmbiguousQualifiedNameElements getPotentiallyAmbiguousQualifiedNameAccess() {
		return gaAlf.getPotentiallyAmbiguousQualifiedNameAccess();
	}
	
	public ParserRule getPotentiallyAmbiguousQualifiedNameRule() {
		return getPotentiallyAmbiguousQualifiedNameAccess().getRule();
	}

	//ColonQualifiedName QualifiedName:
	//	UnqualifiedName ('::' nameBinding+=NameBinding)+
	public AlfGrammarAccess.ColonQualifiedNameElements getColonQualifiedNameAccess() {
		return gaAlf.getColonQualifiedNameAccess();
	}
	
	public ParserRule getColonQualifiedNameRule() {
		return getColonQualifiedNameAccess().getRule();
	}

	//DotQualifiedName QualifiedName:
	//	UnqualifiedName ('.' nameBinding+=NameBinding)+
	public AlfGrammarAccess.DotQualifiedNameElements getDotQualifiedNameAccess() {
		return gaAlf.getDotQualifiedNameAccess();
	}
	
	public ParserRule getDotQualifiedNameRule() {
		return getDotQualifiedNameAccess().getRule();
	}

	//UnqualifiedName QualifiedName:
	//	nameBinding+=NameBinding
	public AlfGrammarAccess.UnqualifiedNameElements getUnqualifiedNameAccess() {
		return gaAlf.getUnqualifiedNameAccess();
	}
	
	public ParserRule getUnqualifiedNameRule() {
		return getUnqualifiedNameAccess().getRule();
	}

	//NameBinding:
	//	name=Name binding=TemplateBinding?;
	public AlfGrammarAccess.NameBindingElements getNameBindingAccess() {
		return gaAlf.getNameBindingAccess();
	}
	
	public ParserRule getNameBindingRule() {
		return getNameBindingAccess().getRule();
	}

	/// *
	//QualifiedNameWithoutBinding :
	//	// unqualified = UnqualifiedName (nameCompletion = (ColonQualifiedNameCompletion | DotQualifiedNameCompletion))?
	//	unqualified = Name (nameCompletion = (ColonQualifiedNameCompletionWithoutBinding))?
	//;
	// * / / *
	//ColonQualifiedNameCompletionWithoutBinding : 
	//	( '::' names+=Name)+
	//;
	// * / / * Unbounded lookahead required here * / TemplateBinding:
	//	'<' (NamedTemplateBinding | PositionalTemplateBinding) '>';
	public AlfGrammarAccess.TemplateBindingElements getTemplateBindingAccess() {
		return gaAlf.getTemplateBindingAccess();
	}
	
	public ParserRule getTemplateBindingRule() {
		return getTemplateBindingAccess().getRule();
	}

	//PositionalTemplateBinding:
	//	argumentName+=QualifiedName (',' argumentName+=QualifiedName)*;
	public AlfGrammarAccess.PositionalTemplateBindingElements getPositionalTemplateBindingAccess() {
		return gaAlf.getPositionalTemplateBindingAccess();
	}
	
	public ParserRule getPositionalTemplateBindingRule() {
		return getPositionalTemplateBindingAccess().getRule();
	}

	//NamedTemplateBinding:
	//	substitution+=TemplateParameterSubstitution (',' substitution+=TemplateParameterSubstitution)*;
	public AlfGrammarAccess.NamedTemplateBindingElements getNamedTemplateBindingAccess() {
		return gaAlf.getNamedTemplateBindingAccess();
	}
	
	public ParserRule getNamedTemplateBindingRule() {
		return getNamedTemplateBindingAccess().getRule();
	}

	//TemplateParameterSubstitution:
	//	parameterName=Name "=>" argumentName=QualifiedName;
	public AlfGrammarAccess.TemplateParameterSubstitutionElements getTemplateParameterSubstitutionAccess() {
		return gaAlf.getTemplateParameterSubstitutionAccess();
	}
	
	public ParserRule getTemplateParameterSubstitutionRule() {
		return getTemplateParameterSubstitutionAccess().getRule();
	}

	/// ***************
	// * EXPRESSIONS *
	// *************** / Expression:
	//	AssignmentExpression | ConditionalExpression;
	public AlfGrammarAccess.ExpressionElements getExpressionAccess() {
		return gaAlf.getExpressionAccess();
	}
	
	public ParserRule getExpressionRule() {
		return getExpressionAccess().getRule();
	}

	/// * PRIMARY EXPRESSIONS * / PrimaryExpression Expression:
	//	BaseExpression ({FeatureReference.expression=current} '.' nameBinding=NameBinding
	//	{FeatureInvocationExpression.target=current} tuple=Tuple | {FeatureReference.expression=current} '.'
	//	nameBinding=NameBinding {PropertyAccessExpression.featureReference=current} |
	//	{ExtentOrExpression.nonNameExpression=current} '->' ({SequenceOperationExpression.primary=current}
	//	operation=QualifiedName tuple=Tuple
	//	| {SequenceReductionExpression.primary=current} 'reduce' isOrdered?='ordered'? behaviorName=QualifiedName
	//	// CHANGE: Made SequenceExpansionExpression concrete.
	//	| {SequenceExpansionExpression.primary=current} operation=ID variable=Name '(' argument=Expression ')') |
	//	{SequenceAccessExpression.primary=current} index=Index)*
	public AlfGrammarAccess.PrimaryExpressionElements getPrimaryExpressionAccess() {
		return gaAlf.getPrimaryExpressionAccess();
	}
	
	public ParserRule getPrimaryExpressionRule() {
		return getPrimaryExpressionAccess().getRule();
	}

	////NonNamePrimaryExpression returns Expression :
	////  NonNameBaseExpression |
	////  BaseExpression
	////  // CHANGE: Made FeatureReference and ExtentOrExpression subtypes of Expression.
	////  ( {FeatureReference.expression = current} '.' nameBinding = NameBinding {FeatureInvocationExpression.target = current} tuple = Tuple |
	////    {FeatureReference.expression = current} '.' nameBinding = NameBinding {PropertyAccessExpression.featureReference = current} | 
	////    {ExtentOrExpression.nonNameExpression = current} '->' 
	////      ( {SequenceOperationExpression.primary = current} operation = QualifiedName tuple = Tuple
	////      | {SequenceReductionExpression.primary = current} 'reduce' ( isOrdered ?= 'ordered' )? behaviorName = QualifiedName 
	////      // CHANGE: Made SequenceExpansionExpression concrete.
	////      | {SequenceExpansionExpression.primary = current} operation = ID variable = Name '(' argument = Expression ')'
	////      ) | 
	////    {SequenceAccessExpression.primary = current} index = Index
	////  )+
	////;
	//BaseExpression Expression:
	//	LiteralExpression | ThisExpression | SuperInvocationExpression | InstanceCreationOrSequenceConstructionExpression |
	//	ClassExtentExpression | LinkOperationExpression | SequenceConstructionExpression |
	//	SequenceOperationOrReductionOrExpansionExpression | BehaviorInvocationExpression | NameExpression |
	//	ParenthesizedExpression
	public AlfGrammarAccess.BaseExpressionElements getBaseExpressionAccess() {
		return gaAlf.getBaseExpressionAccess();
	}
	
	public ParserRule getBaseExpressionRule() {
		return getBaseExpressionAccess().getRule();
	}

	/// * LITERAL EXPRESSIONS * / LiteralExpression:
	//	BooleanLiteralExpression | NaturalLiteralExpression | UnboundedLiteralExpression | StringLiteralExpression;
	public AlfGrammarAccess.LiteralExpressionElements getLiteralExpressionAccess() {
		return gaAlf.getLiteralExpressionAccess();
	}
	
	public ParserRule getLiteralExpressionRule() {
		return getLiteralExpressionAccess().getRule();
	}

	//BooleanLiteralExpression:
	//	image=BOOLEAN_VALUE;
	public AlfGrammarAccess.BooleanLiteralExpressionElements getBooleanLiteralExpressionAccess() {
		return gaAlf.getBooleanLiteralExpressionAccess();
	}
	
	public ParserRule getBooleanLiteralExpressionRule() {
		return getBooleanLiteralExpressionAccess().getRule();
	}

	//NaturalLiteralExpression:
	//	image=NATURAL_VALUE;
	public AlfGrammarAccess.NaturalLiteralExpressionElements getNaturalLiteralExpressionAccess() {
		return gaAlf.getNaturalLiteralExpressionAccess();
	}
	
	public ParserRule getNaturalLiteralExpressionRule() {
		return getNaturalLiteralExpressionAccess().getRule();
	}

	//UnboundedLiteralExpression:
	//	{UnboundedLiteralExpression} '*';
	public AlfGrammarAccess.UnboundedLiteralExpressionElements getUnboundedLiteralExpressionAccess() {
		return gaAlf.getUnboundedLiteralExpressionAccess();
	}
	
	public ParserRule getUnboundedLiteralExpressionRule() {
		return getUnboundedLiteralExpressionAccess().getRule();
	}

	//StringLiteralExpression:
	//	image=STRING;
	public AlfGrammarAccess.StringLiteralExpressionElements getStringLiteralExpressionAccess() {
		return gaAlf.getStringLiteralExpressionAccess();
	}
	
	public ParserRule getStringLiteralExpressionRule() {
		return getStringLiteralExpressionAccess().getRule();
	}

	/// * Name EXPRESSIONS * / NameExpression:
	//	name=PotentiallyAmbiguousQualifiedName;
	public AlfGrammarAccess.NameExpressionElements getNameExpressionAccess() {
		return gaAlf.getNameExpressionAccess();
	}
	
	public ParserRule getNameExpressionRule() {
		return getNameExpressionAccess().getRule();
	}

	/// * THIS EXPRESSIONS * / ThisExpression Expression:
	//	{FeatureInvocationExpression} 'this' tuple=Tuple | {ThisExpression} 'this'
	public AlfGrammarAccess.ThisExpressionElements getThisExpressionAccess() {
		return gaAlf.getThisExpressionAccess();
	}
	
	public ParserRule getThisExpressionRule() {
		return getThisExpressionAccess().getRule();
	}

	/// * PARENTHESIZED EXPRESSIONS * / ParenthesizedExpression Expression:
	//	'(' Expression ')'
	public AlfGrammarAccess.ParenthesizedExpressionElements getParenthesizedExpressionAccess() {
		return gaAlf.getParenthesizedExpressionAccess();
	}
	
	public ParserRule getParenthesizedExpressionRule() {
		return getParenthesizedExpressionAccess().getRule();
	}

	/// * PROPERTY ACCESS EXPRESSIONS * / //FeatureReference :
	////  expression = PrimaryExpression // '.' nameBinding = NameBinding
	////;
	////FeatureTargetExpression returns Expression :
	////  NonNamePrimaryExpression | NameTargetExpression
	////;
	////
	////NameTargetExpression returns NameExpression :
	////  name = ColonQualifiedName
	////;
	/// * INVOCATION EXPRESSIONS * / BehaviorInvocationExpression:
	//	target=PotentiallyAmbiguousQualifiedName tuple=Tuple;
	public AlfGrammarAccess.BehaviorInvocationExpressionElements getBehaviorInvocationExpressionAccess() {
		return gaAlf.getBehaviorInvocationExpressionAccess();
	}
	
	public ParserRule getBehaviorInvocationExpressionRule() {
		return getBehaviorInvocationExpressionAccess().getRule();
	}

	//Tuple:
	/// * {Tuple}'(' ( namedTupleExpressionList = NamedTupleExpressionList | ( positionalTupleExpressionList = PositionalTupleExpressionList )? ) ')' * /
	//	'(' (NamedTupleExpressionList | PositionalTupleExpressionList) ')';
	public AlfGrammarAccess.TupleElements getTupleAccess() {
		return gaAlf.getTupleAccess();
	}
	
	public ParserRule getTupleRule() {
		return getTupleAccess().getRule();
	}

	//PositionalTupleExpressionList PositionalTuple:
	//	{PositionalTuple} (expression+=Expression (',' expression+=Expression)*)?
	public AlfGrammarAccess.PositionalTupleExpressionListElements getPositionalTupleExpressionListAccess() {
		return gaAlf.getPositionalTupleExpressionListAccess();
	}
	
	public ParserRule getPositionalTupleExpressionListRule() {
		return getPositionalTupleExpressionListAccess().getRule();
	}

	//NamedTupleExpressionList NamedTuple:
	//	namedExpression+=NamedExpression (',' namedExpression+=NamedExpression)*
	public AlfGrammarAccess.NamedTupleExpressionListElements getNamedTupleExpressionListAccess() {
		return gaAlf.getNamedTupleExpressionListAccess();
	}
	
	public ParserRule getNamedTupleExpressionListRule() {
		return getNamedTupleExpressionListAccess().getRule();
	}

	//NamedExpression:
	//	name=Name '=>' expression=Expression;
	public AlfGrammarAccess.NamedExpressionElements getNamedExpressionAccess() {
		return gaAlf.getNamedExpressionAccess();
	}
	
	public ParserRule getNamedExpressionRule() {
		return getNamedExpressionAccess().getRule();
	}

	//SuperInvocationExpression:
	//	'super' ('.' target=QualifiedName)? tuple=Tuple;
	public AlfGrammarAccess.SuperInvocationExpressionElements getSuperInvocationExpressionAccess() {
		return gaAlf.getSuperInvocationExpressionAccess();
	}
	
	public ParserRule getSuperInvocationExpressionRule() {
		return getSuperInvocationExpressionAccess().getRule();
	}

	/// * INSTANCE CREATION EXPRESSIONS * / InstanceCreationOrSequenceConstructionExpression Expression:
	//	'new' ({SequenceConstructionExpression} typeName=QualifiedName hasMultiplicity?=MultiplicityIndicator? '{'
	//	elements=SequenceElements? '}' | {InstanceCreationExpression} constructor=QualifiedName tuple=Tuple)
	public AlfGrammarAccess.InstanceCreationOrSequenceConstructionExpressionElements getInstanceCreationOrSequenceConstructionExpressionAccess() {
		return gaAlf.getInstanceCreationOrSequenceConstructionExpressionAccess();
	}
	
	public ParserRule getInstanceCreationOrSequenceConstructionExpressionRule() {
		return getInstanceCreationOrSequenceConstructionExpressionAccess().getRule();
	}

	/// * LINK OPERATION EXPRESSIONS * / LinkOperationExpression:
	//	associationName=PotentiallyAmbiguousQualifiedName '.' operation=LinkOperation tuple=LinkOperationTuple;
	public AlfGrammarAccess.LinkOperationExpressionElements getLinkOperationExpressionAccess() {
		return gaAlf.getLinkOperationExpressionAccess();
	}
	
	public ParserRule getLinkOperationExpressionRule() {
		return getLinkOperationExpressionAccess().getRule();
	}

	//LinkOperation:
	//	'createLink' | 'destroyLink' | 'clearAssoc';
	public AlfGrammarAccess.LinkOperationElements getLinkOperationAccess() {
		return gaAlf.getLinkOperationAccess();
	}
	
	public ParserRule getLinkOperationRule() {
		return getLinkOperationAccess().getRule();
	}

	//LinkOperationTuple Tuple:
	//	'(' (IndexedNamedTupleExpressionList | PositionalTupleExpressionList) ')'
	public AlfGrammarAccess.LinkOperationTupleElements getLinkOperationTupleAccess() {
		return gaAlf.getLinkOperationTupleAccess();
	}
	
	public ParserRule getLinkOperationTupleRule() {
		return getLinkOperationTupleAccess().getRule();
	}

	//IndexedNamedTupleExpressionList NamedTuple:
	//	namedExpression+=IndexedNamedExpression (',' namedExpression+=IndexedNamedExpression)*
	public AlfGrammarAccess.IndexedNamedTupleExpressionListElements getIndexedNamedTupleExpressionListAccess() {
		return gaAlf.getIndexedNamedTupleExpressionListAccess();
	}
	
	public ParserRule getIndexedNamedTupleExpressionListRule() {
		return getIndexedNamedTupleExpressionListAccess().getRule();
	}

	//IndexedNamedExpression NamedExpression:
	//	name=Name index=Index? '=>' expression=Expression
	public AlfGrammarAccess.IndexedNamedExpressionElements getIndexedNamedExpressionAccess() {
		return gaAlf.getIndexedNamedExpressionAccess();
	}
	
	public ParserRule getIndexedNamedExpressionRule() {
		return getIndexedNamedExpressionAccess().getRule();
	}

	/// * CLASS EXTENT EXPRESSIONS * / ClassExtentExpression:
	//	className=PotentiallyAmbiguousQualifiedName '.' 'allInstances' '(' ')';
	public AlfGrammarAccess.ClassExtentExpressionElements getClassExtentExpressionAccess() {
		return gaAlf.getClassExtentExpressionAccess();
	}
	
	public ParserRule getClassExtentExpressionRule() {
		return getClassExtentExpressionAccess().getRule();
	}

	/// * SEQUENCE CONSTRUCTION EXPRESSIONS * / SequenceConstructionExpression:
	//	(isAny?='any' | typeName=QualifiedName) hasMultiplicity?=MultiplicityIndicator? '{' elements=SequenceElements? '}' |
	//	hasMultiplicity?='null';
	public AlfGrammarAccess.SequenceConstructionExpressionElements getSequenceConstructionExpressionAccess() {
		return gaAlf.getSequenceConstructionExpressionAccess();
	}
	
	public ParserRule getSequenceConstructionExpressionRule() {
		return getSequenceConstructionExpressionAccess().getRule();
	}

	//MultiplicityIndicator:
	//	'[' ']';
	public AlfGrammarAccess.MultiplicityIndicatorElements getMultiplicityIndicatorAccess() {
		return gaAlf.getMultiplicityIndicatorAccess();
	}
	
	public ParserRule getMultiplicityIndicatorRule() {
		return getMultiplicityIndicatorAccess().getRule();
	}

	//SequenceElements:
	//	SequenceRange | SequenceExpressionList;
	public AlfGrammarAccess.SequenceElementsElements getSequenceElementsAccess() {
		return gaAlf.getSequenceElementsAccess();
	}
	
	public ParserRule getSequenceElementsRule() {
		return getSequenceElementsAccess().getRule();
	}

	//SequenceRange:
	//	rangeLower=Expression '..' rangeUpper=Expression;
	public AlfGrammarAccess.SequenceRangeElements getSequenceRangeAccess() {
		return gaAlf.getSequenceRangeAccess();
	}
	
	public ParserRule getSequenceRangeRule() {
		return getSequenceRangeAccess().getRule();
	}

	//SequenceExpressionList:
	//	element+=SequenceElement (',' element+=SequenceElement)* ','?;
	public AlfGrammarAccess.SequenceExpressionListElements getSequenceExpressionListAccess() {
		return gaAlf.getSequenceExpressionListAccess();
	}
	
	public ParserRule getSequenceExpressionListRule() {
		return getSequenceExpressionListAccess().getRule();
	}

	//SequenceElement Expression:
	//	Expression | SequenceInitializationExpression
	public AlfGrammarAccess.SequenceElementElements getSequenceElementAccess() {
		return gaAlf.getSequenceElementAccess();
	}
	
	public ParserRule getSequenceElementRule() {
		return getSequenceElementAccess().getRule();
	}

	//SequenceInitializationExpression SequenceConstructionExpression:
	//	'new'? '{' elements=SequenceElements '}'
	public AlfGrammarAccess.SequenceInitializationExpressionElements getSequenceInitializationExpressionAccess() {
		return gaAlf.getSequenceInitializationExpressionAccess();
	}
	
	public ParserRule getSequenceInitializationExpressionRule() {
		return getSequenceInitializationExpressionAccess().getRule();
	}

	/// * SEQUENCE ACCESS EXPRESSIONS * / Index Expression:
	//	'[' Expression ']'
	public AlfGrammarAccess.IndexElements getIndexAccess() {
		return gaAlf.getIndexAccess();
	}
	
	public ParserRule getIndexRule() {
		return getIndexAccess().getRule();
	}

	/// * SEQUENCE OPERATION, REDUCTION AND EXPANSION EXPRESSIONS * / // NOTE: This only covers the case when the primary is a class extent shorthand.
	//SequenceOperationOrReductionOrExpansionExpression Expression:
	//	{ExtentOrExpression} name=PotentiallyAmbiguousQualifiedName '->' ({SequenceOperationExpression.primary=current}
	//	operation=QualifiedName tuple=Tuple
	//	| {SequenceReductionExpression.primary=current} 'reduce' isOrdered?='ordered'? behaviorName=QualifiedName
	//	// CHANGE: Made SequenceExpansionExpression concrete.
	//	| {SequenceExpansionExpression.primary=current} operation=ID variable=Name '(' argument=Expression ')')
	public AlfGrammarAccess.SequenceOperationOrReductionOrExpansionExpressionElements getSequenceOperationOrReductionOrExpansionExpressionAccess() {
		return gaAlf.getSequenceOperationOrReductionOrExpansionExpressionAccess();
	}
	
	public ParserRule getSequenceOperationOrReductionOrExpansionExpressionRule() {
		return getSequenceOperationOrReductionOrExpansionExpressionAccess().getRule();
	}

	/// * INCREMENT OR DECREMENT EXPRESSIONS * / PrefixExpression IncrementOrDecrementExpression:
	//	operator=AffixOperator operand=LeftHandSide
	public AlfGrammarAccess.PrefixExpressionElements getPrefixExpressionAccess() {
		return gaAlf.getPrefixExpressionAccess();
	}
	
	public ParserRule getPrefixExpressionRule() {
		return getPrefixExpressionAccess().getRule();
	}

	//AffixOperator:
	//	'++' | '--';
	public AlfGrammarAccess.AffixOperatorElements getAffixOperatorAccess() {
		return gaAlf.getAffixOperatorAccess();
	}
	
	public ParserRule getAffixOperatorRule() {
		return getAffixOperatorAccess().getRule();
	}

	/// * UNARY EXPRESSIONS * / UnaryExpression Expression:
	//	PostfixOrCastExpression | NonPostfixNonCastUnaryExpression
	public AlfGrammarAccess.UnaryExpressionElements getUnaryExpressionAccess() {
		return gaAlf.getUnaryExpressionAccess();
	}
	
	public ParserRule getUnaryExpressionRule() {
		return getUnaryExpressionAccess().getRule();
	}

	//PostfixOrCastExpression Expression:
	//	PostfixExpression | CastExpression | PrimaryExpression
	public AlfGrammarAccess.PostfixOrCastExpressionElements getPostfixOrCastExpressionAccess() {
		return gaAlf.getPostfixOrCastExpressionAccess();
	}
	
	public ParserRule getPostfixOrCastExpressionRule() {
		return getPostfixOrCastExpressionAccess().getRule();
	}

	//PostfixExpression IncrementOrDecrementExpression:
	//	operand=LeftHandSide operator=AffixOperator
	public AlfGrammarAccess.PostfixExpressionElements getPostfixExpressionAccess() {
		return gaAlf.getPostfixExpressionAccess();
	}
	
	public ParserRule getPostfixExpressionRule() {
		return getPostfixExpressionAccess().getRule();
	}

	//NonPostfixNonCastUnaryExpression Expression:
	//	PrefixExpression | NumericUnaryExpression | BooleanUnaryExpression | BitStringUnaryExpression | IsolationExpression
	public AlfGrammarAccess.NonPostfixNonCastUnaryExpressionElements getNonPostfixNonCastUnaryExpressionAccess() {
		return gaAlf.getNonPostfixNonCastUnaryExpressionAccess();
	}
	
	public ParserRule getNonPostfixNonCastUnaryExpressionRule() {
		return getNonPostfixNonCastUnaryExpressionAccess().getRule();
	}

	//BooleanUnaryExpression:
	//	operator='!' operand=UnaryExpression;
	public AlfGrammarAccess.BooleanUnaryExpressionElements getBooleanUnaryExpressionAccess() {
		return gaAlf.getBooleanUnaryExpressionAccess();
	}
	
	public ParserRule getBooleanUnaryExpressionRule() {
		return getBooleanUnaryExpressionAccess().getRule();
	}

	//BitStringUnaryExpression:
	//	operator='~' operand=UnaryExpression;
	public AlfGrammarAccess.BitStringUnaryExpressionElements getBitStringUnaryExpressionAccess() {
		return gaAlf.getBitStringUnaryExpressionAccess();
	}
	
	public ParserRule getBitStringUnaryExpressionRule() {
		return getBitStringUnaryExpressionAccess().getRule();
	}

	//NumericUnaryExpression:
	//	operator=NumericUnaryOperator operand=UnaryExpression;
	public AlfGrammarAccess.NumericUnaryExpressionElements getNumericUnaryExpressionAccess() {
		return gaAlf.getNumericUnaryExpressionAccess();
	}
	
	public ParserRule getNumericUnaryExpressionRule() {
		return getNumericUnaryExpressionAccess().getRule();
	}

	//NumericUnaryOperator:
	//	'+' | '-';
	public AlfGrammarAccess.NumericUnaryOperatorElements getNumericUnaryOperatorAccess() {
		return gaAlf.getNumericUnaryOperatorAccess();
	}
	
	public ParserRule getNumericUnaryOperatorRule() {
		return getNumericUnaryOperatorAccess().getRule();
	}

	//IsolationExpression:
	//	operator='$' operand=UnaryExpression;
	public AlfGrammarAccess.IsolationExpressionElements getIsolationExpressionAccess() {
		return gaAlf.getIsolationExpressionAccess();
	}
	
	public ParserRule getIsolationExpressionRule() {
		return getIsolationExpressionAccess().getRule();
	}

	//CastExpression: // CHANGE: Added isAny attribute to CastExpression in order to allow Xtext serialization.
	//	'(' (isAny?='any' | typeName=QualifiedName) ')' operand=CastCompletion;
	public AlfGrammarAccess.CastExpressionElements getCastExpressionAccess() {
		return gaAlf.getCastExpressionAccess();
	}
	
	public ParserRule getCastExpressionRule() {
		return getCastExpressionAccess().getRule();
	}

	//CastCompletion Expression:
	//	PostfixOrCastExpression | BooleanUnaryExpression | BitStringUnaryExpression | IsolationExpression
	public AlfGrammarAccess.CastCompletionElements getCastCompletionAccess() {
		return gaAlf.getCastCompletionAccess();
	}
	
	public ParserRule getCastCompletionRule() {
		return getCastCompletionAccess().getRule();
	}

	/// * ARITHMETIC EXPRESSIONS * / MultiplicativeExpression Expression:
	//	UnaryExpression ({ArithmeticExpression.operand1=current} operator=MultiplicativeOperator operand2=UnaryExpression)*
	public AlfGrammarAccess.MultiplicativeExpressionElements getMultiplicativeExpressionAccess() {
		return gaAlf.getMultiplicativeExpressionAccess();
	}
	
	public ParserRule getMultiplicativeExpressionRule() {
		return getMultiplicativeExpressionAccess().getRule();
	}

	//MultiplicativeOperator:
	//	'*' | '/' | '%';
	public AlfGrammarAccess.MultiplicativeOperatorElements getMultiplicativeOperatorAccess() {
		return gaAlf.getMultiplicativeOperatorAccess();
	}
	
	public ParserRule getMultiplicativeOperatorRule() {
		return getMultiplicativeOperatorAccess().getRule();
	}

	//AdditiveExpression Expression:
	//	MultiplicativeExpression ({ArithmeticExpression.operand1=current} operator=AdditiveOperator
	//	operand2=MultiplicativeExpression)*
	public AlfGrammarAccess.AdditiveExpressionElements getAdditiveExpressionAccess() {
		return gaAlf.getAdditiveExpressionAccess();
	}
	
	public ParserRule getAdditiveExpressionRule() {
		return getAdditiveExpressionAccess().getRule();
	}

	//AdditiveOperator:
	//	'+' | '-';
	public AlfGrammarAccess.AdditiveOperatorElements getAdditiveOperatorAccess() {
		return gaAlf.getAdditiveOperatorAccess();
	}
	
	public ParserRule getAdditiveOperatorRule() {
		return getAdditiveOperatorAccess().getRule();
	}

	/// * SHIFT EXPRESSIONS * / ShiftExpression Expression:
	//	AdditiveExpression ({ShiftExpression.operand1=current} operator=ShiftOperator operand2=AdditiveExpression)*
	public AlfGrammarAccess.ShiftExpressionElements getShiftExpressionAccess() {
		return gaAlf.getShiftExpressionAccess();
	}
	
	public ParserRule getShiftExpressionRule() {
		return getShiftExpressionAccess().getRule();
	}

	//ShiftOperator:
	//	'<<' | '>>' | '>>>';
	public AlfGrammarAccess.ShiftOperatorElements getShiftOperatorAccess() {
		return gaAlf.getShiftOperatorAccess();
	}
	
	public ParserRule getShiftOperatorRule() {
		return getShiftOperatorAccess().getRule();
	}

	/// * RELATIONAL EXPRESSIONS * / RelationalExpression Expression:
	//	ShiftExpression ({RelationalExpression.operand1=current} operator=RelationalOperator operand2=ShiftExpression)?
	public AlfGrammarAccess.RelationalExpressionElements getRelationalExpressionAccess() {
		return gaAlf.getRelationalExpressionAccess();
	}
	
	public ParserRule getRelationalExpressionRule() {
		return getRelationalExpressionAccess().getRule();
	}

	//RelationalOperator:
	//	'<' | '>' | '<=' | '>=';
	public AlfGrammarAccess.RelationalOperatorElements getRelationalOperatorAccess() {
		return gaAlf.getRelationalOperatorAccess();
	}
	
	public ParserRule getRelationalOperatorRule() {
		return getRelationalOperatorAccess().getRule();
	}

	/// * CLASSIFICATION EXPRESSIONS * / ClassificationExpression Expression:
	//	RelationalExpression ({ClassificationExpression.operand=current} operator=ClassificationOperator
	//	typeName=QualifiedName)?
	public AlfGrammarAccess.ClassificationExpressionElements getClassificationExpressionAccess() {
		return gaAlf.getClassificationExpressionAccess();
	}
	
	public ParserRule getClassificationExpressionRule() {
		return getClassificationExpressionAccess().getRule();
	}

	//ClassificationOperator:
	//	'instanceof' | 'hastype';
	public AlfGrammarAccess.ClassificationOperatorElements getClassificationOperatorAccess() {
		return gaAlf.getClassificationOperatorAccess();
	}
	
	public ParserRule getClassificationOperatorRule() {
		return getClassificationOperatorAccess().getRule();
	}

	/// * EQUALITY EXPRESSIONS * / EqualityExpression Expression:
	//	ClassificationExpression ({EqualityExpression.operand1=current} operator=EqualityOperator
	//	operand2=ClassificationExpression)*
	public AlfGrammarAccess.EqualityExpressionElements getEqualityExpressionAccess() {
		return gaAlf.getEqualityExpressionAccess();
	}
	
	public ParserRule getEqualityExpressionRule() {
		return getEqualityExpressionAccess().getRule();
	}

	//EqualityOperator:
	//	'==' | '!=';
	public AlfGrammarAccess.EqualityOperatorElements getEqualityOperatorAccess() {
		return gaAlf.getEqualityOperatorAccess();
	}
	
	public ParserRule getEqualityOperatorRule() {
		return getEqualityOperatorAccess().getRule();
	}

	/// * LOGICAL EXPRESSIONS * / AndExpression Expression:
	//	EqualityExpression ({LogicalExpression.operand1=current} operator='&' operand2=EqualityExpression)*
	public AlfGrammarAccess.AndExpressionElements getAndExpressionAccess() {
		return gaAlf.getAndExpressionAccess();
	}
	
	public ParserRule getAndExpressionRule() {
		return getAndExpressionAccess().getRule();
	}

	//ExclusiveOrExpression Expression:
	//	AndExpression ({LogicalExpression.operand1=current} operator='^' operand2=AndExpression)*
	public AlfGrammarAccess.ExclusiveOrExpressionElements getExclusiveOrExpressionAccess() {
		return gaAlf.getExclusiveOrExpressionAccess();
	}
	
	public ParserRule getExclusiveOrExpressionRule() {
		return getExclusiveOrExpressionAccess().getRule();
	}

	//InclusiveOrExpression Expression:
	//	ExclusiveOrExpression ({LogicalExpression.operand1=current} operator='|' operand2=ExclusiveOrExpression)*
	public AlfGrammarAccess.InclusiveOrExpressionElements getInclusiveOrExpressionAccess() {
		return gaAlf.getInclusiveOrExpressionAccess();
	}
	
	public ParserRule getInclusiveOrExpressionRule() {
		return getInclusiveOrExpressionAccess().getRule();
	}

	/// * CONDITIONAL LOGICAL EXPRESSIONS * / ConditionalAndExpression Expression:
	//	InclusiveOrExpression ({ConditionalLogicalExpression.operand1=current} operator='&&' operand2=InclusiveOrExpression)*
	public AlfGrammarAccess.ConditionalAndExpressionElements getConditionalAndExpressionAccess() {
		return gaAlf.getConditionalAndExpressionAccess();
	}
	
	public ParserRule getConditionalAndExpressionRule() {
		return getConditionalAndExpressionAccess().getRule();
	}

	//ConditionalOrExpression Expression:
	//	ConditionalAndExpression ({ConditionalLogicalExpression.operand1=current} operator='||'
	//	operand2=ConditionalAndExpression)*
	public AlfGrammarAccess.ConditionalOrExpressionElements getConditionalOrExpressionAccess() {
		return gaAlf.getConditionalOrExpressionAccess();
	}
	
	public ParserRule getConditionalOrExpressionRule() {
		return getConditionalOrExpressionAccess().getRule();
	}

	/// * CONDITIONAL-TEST EXPRESSIONS * / ConditionalExpression Expression:
	//	ConditionalOrExpression ({ConditionalTestExpression.operand1=current}
	//	'?' operand2=Expression ':' operand3=ConditionalExpression)?
	public AlfGrammarAccess.ConditionalExpressionElements getConditionalExpressionAccess() {
		return gaAlf.getConditionalExpressionAccess();
	}
	
	public ParserRule getConditionalExpressionRule() {
		return getConditionalExpressionAccess().getRule();
	}

	/// * ASSIGNMENT EXPRESSIONS * / AssignmentExpression:
	//	leftHandSide=LeftHandSide operator=AssignmentOperator rightHandSide=Expression;
	public AlfGrammarAccess.AssignmentExpressionElements getAssignmentExpressionAccess() {
		return gaAlf.getAssignmentExpressionAccess();
	}
	
	public ParserRule getAssignmentExpressionRule() {
		return getAssignmentExpressionAccess().getRule();
	}

	//LeftHandSide:
	//	NameLeftHandSide | FeatureLeftHandSide // ( index = Index )? |
	//	//  "(" LeftHandSide ")"
	//;
	public AlfGrammarAccess.LeftHandSideElements getLeftHandSideAccess() {
		return gaAlf.getLeftHandSideAccess();
	}
	
	public ParserRule getLeftHandSideRule() {
		return getLeftHandSideAccess().getRule();
	}

	//NameLeftHandSide:
	//	target=PotentiallyAmbiguousQualifiedName index=Index?;
	public AlfGrammarAccess.NameLeftHandSideElements getNameLeftHandSideAccess() {
		return gaAlf.getNameLeftHandSideAccess();
	}
	
	public ParserRule getNameLeftHandSideRule() {
		return getNameLeftHandSideAccess().getRule();
	}

	//FeatureLeftHandSide:
	//	expression=PrimaryExpression;
	public AlfGrammarAccess.FeatureLeftHandSideElements getFeatureLeftHandSideAccess() {
		return gaAlf.getFeatureLeftHandSideAccess();
	}
	
	public ParserRule getFeatureLeftHandSideRule() {
		return getFeatureLeftHandSideAccess().getRule();
	}

	//AssignmentOperator:
	//	'=' | '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '>>>=';
	public AlfGrammarAccess.AssignmentOperatorElements getAssignmentOperatorAccess() {
		return gaAlf.getAssignmentOperatorAccess();
	}
	
	public ParserRule getAssignmentOperatorRule() {
		return getAssignmentOperatorAccess().getRule();
	}

	/// **************
	// * STATEMENTS *
	// ************** / StatementSequence Block:
	//	{Block} statement+=DocumentedStatement*
	public AlfGrammarAccess.StatementSequenceElements getStatementSequenceAccess() {
		return gaAlf.getStatementSequenceAccess();
	}
	
	public ParserRule getStatementSequenceRule() {
		return getStatementSequenceAccess().getRule();
	}

	//DocumentedStatement AnnotatedStatement:
	//	AnnotatedStatement
	public AlfGrammarAccess.DocumentedStatementElements getDocumentedStatementAccess() {
		return gaAlf.getDocumentedStatementAccess();
	}
	
	public ParserRule getDocumentedStatementRule() {
		return getDocumentedStatementAccess().getRule();
	}

	//Statement:
	//	InLineStatement | BlockStatement | EmptyStatement | LocalNameDeclarationStatement | ExpressionStatement | IfStatement
	//	| SwitchStatement | WhileStatement | ForStatement | DoStatement | BreakStatement | ReturnStatement | AcceptStatement
	//	| ClassifyStatement;
	public AlfGrammarAccess.StatementElements getStatementAccess() {
		return gaAlf.getStatementAccess();
	}
	
	public ParserRule getStatementRule() {
		return getStatementAccess().getRule();
	}

	/// * BLOCK * / Block:
	//	{Block} '{' statement+=DocumentedStatement* '}';
	public AlfGrammarAccess.BlockElements getBlockAccess() {
		return gaAlf.getBlockAccess();
	}
	
	public ParserRule getBlockRule() {
		return getBlockAccess().getRule();
	}

	/// * ANNOTATED STATEMENTS * / AnnotatedStatement:
	//	documentation+=DOCUMENTATION_COMMENT?
	//	// CHANGE: Include text line in annotation statement.
	//	annotation+=STATEMENT_ANNOTATION*
	//	// ( '//@' annotation += Annotation ( '@' annotation += Annotation )+ '\r'? '\n' )*
	//	statement=Statement;
	public AlfGrammarAccess.AnnotatedStatementElements getAnnotatedStatementAccess() {
		return gaAlf.getAnnotatedStatementAccess();
	}
	
	public ParserRule getAnnotatedStatementRule() {
		return getAnnotatedStatementAccess().getRule();
	}

	/// *
	//Annotation : 
	//	identifier = ID ( '(' argument += Name ( ',' argument += Name )* ')' )?
	//;
	// * / / * IN-LINE STATEMENTS * / InLineStatement:
	//	code=INLINE_STATEMENT
	//	//'/ *@' 'inline' '(' language = Name ')' '* /'
	//;
	public AlfGrammarAccess.InLineStatementElements getInLineStatementAccess() {
		return gaAlf.getInLineStatementAccess();
	}
	
	public ParserRule getInLineStatementRule() {
		return getInLineStatementAccess().getRule();
	}

	/// * BLOCK STATEMENTS * / BlockStatement:
	//	block=Block;
	public AlfGrammarAccess.BlockStatementElements getBlockStatementAccess() {
		return gaAlf.getBlockStatementAccess();
	}
	
	public ParserRule getBlockStatementRule() {
		return getBlockStatementAccess().getRule();
	}

	/// * EMPTY STATEMENTS * / EmptyStatement:
	//	{EmptyStatement}
	//	';';
	public AlfGrammarAccess.EmptyStatementElements getEmptyStatementAccess() {
		return gaAlf.getEmptyStatementAccess();
	}
	
	public ParserRule getEmptyStatementRule() {
		return getEmptyStatementAccess().getRule();
	}

	/// * LOCAL NAME DECLARATION STATEMENTS * / LocalNameDeclarationStatement:
	//	('let' name=Name ':' (isAny?='any' | typeName=QualifiedName) hasMultiplicity?=MultiplicityIndicator? | (isAny?='any'
	//	| typeName=QualifiedName) hasMultiplicity?=MultiplicityIndicator? name=Name)
	//	'=' expression=InitializationExpression ';';
	public AlfGrammarAccess.LocalNameDeclarationStatementElements getLocalNameDeclarationStatementAccess() {
		return gaAlf.getLocalNameDeclarationStatementAccess();
	}
	
	public ParserRule getLocalNameDeclarationStatementRule() {
		return getLocalNameDeclarationStatementAccess().getRule();
	}

	//InitializationExpression Expression:
	//	Expression
	//	| SequenceInitializationExpression
	//	| InstanceInitializationExpression
	public AlfGrammarAccess.InitializationExpressionElements getInitializationExpressionAccess() {
		return gaAlf.getInitializationExpressionAccess();
	}
	
	public ParserRule getInitializationExpressionRule() {
		return getInitializationExpressionAccess().getRule();
	}

	//InstanceInitializationExpression InstanceCreationExpression:
	//	'new' tuple=Tuple
	public AlfGrammarAccess.InstanceInitializationExpressionElements getInstanceInitializationExpressionAccess() {
		return gaAlf.getInstanceInitializationExpressionAccess();
	}
	
	public ParserRule getInstanceInitializationExpressionRule() {
		return getInstanceInitializationExpressionAccess().getRule();
	}

	/// * EXPRESSION STATEMENTS * / ExpressionStatement:
	//	expression=Expression ';';
	public AlfGrammarAccess.ExpressionStatementElements getExpressionStatementAccess() {
		return gaAlf.getExpressionStatementAccess();
	}
	
	public ParserRule getExpressionStatementRule() {
		return getExpressionStatementAccess().getRule();
	}

	/// * IF STATEMENTS * / IfStatement:
	//	'if' nonFinalClauses+=ConcurrentClauses ('else' 'if' nonFinalClauses+=ConcurrentClauses)* ('else'
	//	finalClause=Block)?;
	public AlfGrammarAccess.IfStatementElements getIfStatementAccess() {
		return gaAlf.getIfStatementAccess();
	}
	
	public ParserRule getIfStatementRule() {
		return getIfStatementAccess().getRule();
	}

	//ConcurrentClauses:
	//	clause+=NonFinalClause ('or' 'if' clause+=NonFinalClause)*;
	public AlfGrammarAccess.ConcurrentClausesElements getConcurrentClausesAccess() {
		return gaAlf.getConcurrentClausesAccess();
	}
	
	public ParserRule getConcurrentClausesRule() {
		return getConcurrentClausesAccess().getRule();
	}

	//NonFinalClause:
	//	'(' condition=Expression ')' body=Block;
	public AlfGrammarAccess.NonFinalClauseElements getNonFinalClauseAccess() {
		return gaAlf.getNonFinalClauseAccess();
	}
	
	public ParserRule getNonFinalClauseRule() {
		return getNonFinalClauseAccess().getRule();
	}

	/// * SWITCH STATEMENTS * / SwitchStatement:
	//	'switch' '(' expression=Expression ')'
	//	'{' nonDefaultClause+=SwitchClause*
	//	defaultClause=SwitchDefaultClause? '}';
	public AlfGrammarAccess.SwitchStatementElements getSwitchStatementAccess() {
		return gaAlf.getSwitchStatementAccess();
	}
	
	public ParserRule getSwitchStatementRule() {
		return getSwitchStatementAccess().getRule();
	}

	//SwitchClause:
	//	case+=SwitchCase case+=SwitchCase*
	//	block=NonEmptyStatementSequence;
	public AlfGrammarAccess.SwitchClauseElements getSwitchClauseAccess() {
		return gaAlf.getSwitchClauseAccess();
	}
	
	public ParserRule getSwitchClauseRule() {
		return getSwitchClauseAccess().getRule();
	}

	//SwitchCase Expression:
	//	'case' Expression ':'
	public AlfGrammarAccess.SwitchCaseElements getSwitchCaseAccess() {
		return gaAlf.getSwitchCaseAccess();
	}
	
	public ParserRule getSwitchCaseRule() {
		return getSwitchCaseAccess().getRule();
	}

	//SwitchDefaultClause Block:
	//	'default' ':' NonEmptyStatementSequence
	public AlfGrammarAccess.SwitchDefaultClauseElements getSwitchDefaultClauseAccess() {
		return gaAlf.getSwitchDefaultClauseAccess();
	}
	
	public ParserRule getSwitchDefaultClauseRule() {
		return getSwitchDefaultClauseAccess().getRule();
	}

	//NonEmptyStatementSequence Block:
	//	statement+=DocumentedStatement+
	public AlfGrammarAccess.NonEmptyStatementSequenceElements getNonEmptyStatementSequenceAccess() {
		return gaAlf.getNonEmptyStatementSequenceAccess();
	}
	
	public ParserRule getNonEmptyStatementSequenceRule() {
		return getNonEmptyStatementSequenceAccess().getRule();
	}

	/// * WHILE STATEMENTS * / WhileStatement:
	//	'while' '(' condition=Expression ')' body=Block;
	public AlfGrammarAccess.WhileStatementElements getWhileStatementAccess() {
		return gaAlf.getWhileStatementAccess();
	}
	
	public ParserRule getWhileStatementRule() {
		return getWhileStatementAccess().getRule();
	}

	/// * DO STATEMENTS * / DoStatement:
	//	'do' body=Block 'while' '(' condition=Expression ')' ';';
	public AlfGrammarAccess.DoStatementElements getDoStatementAccess() {
		return gaAlf.getDoStatementAccess();
	}
	
	public ParserRule getDoStatementRule() {
		return getDoStatementAccess().getRule();
	}

	/// * FOR STATEMENTS * / ForStatement:
	//	'for' '(' variableDefinition+=LoopVariableDefinition (',' variableDefinition+=LoopVariableDefinition)* ')'
	//	body=Block;
	public AlfGrammarAccess.ForStatementElements getForStatementAccess() {
		return gaAlf.getForStatementAccess();
	}
	
	public ParserRule getForStatementRule() {
		return getForStatementAccess().getRule();
	}

	//LoopVariableDefinition:
	//	variable=Name typeIsInferred?='in' expression1=Expression ('..' expression2=Expression)? | (isAny?='any' |
	//	typeName=QualifiedName) variable=Name ':' expression1=Expression;
	public AlfGrammarAccess.LoopVariableDefinitionElements getLoopVariableDefinitionAccess() {
		return gaAlf.getLoopVariableDefinitionAccess();
	}
	
	public ParserRule getLoopVariableDefinitionRule() {
		return getLoopVariableDefinitionAccess().getRule();
	}

	/// * BREAK STATEMENTS * / BreakStatement:
	//	{BreakStatement}
	//	'break' ';';
	public AlfGrammarAccess.BreakStatementElements getBreakStatementAccess() {
		return gaAlf.getBreakStatementAccess();
	}
	
	public ParserRule getBreakStatementRule() {
		return getBreakStatementAccess().getRule();
	}

	/// * RETURN STATEMENTS * / ReturnStatement:
	//	{ReturnStatement}
	//	'return' expression=Expression? ';';
	public AlfGrammarAccess.ReturnStatementElements getReturnStatementAccess() {
		return gaAlf.getReturnStatementAccess();
	}
	
	public ParserRule getReturnStatementRule() {
		return getReturnStatementAccess().getRule();
	}

	/// * ACCEPT STATEMENTS * / AcceptStatement:
	//	acceptBlock+=AcceptClause ';' | acceptBlock+=AcceptBlock ('or' acceptBlock+=AcceptBlock)*;
	public AlfGrammarAccess.AcceptStatementElements getAcceptStatementAccess() {
		return gaAlf.getAcceptStatementAccess();
	}
	
	public ParserRule getAcceptStatementRule() {
		return getAcceptStatementAccess().getRule();
	}

	//AcceptBlock:
	//	AcceptClause block=Block;
	public AlfGrammarAccess.AcceptBlockElements getAcceptBlockAccess() {
		return gaAlf.getAcceptBlockAccess();
	}
	
	public ParserRule getAcceptBlockRule() {
		return getAcceptBlockAccess().getRule();
	}

	//AcceptClause AcceptBlock:
	//	'accept' '(' (name=Name ':')? signalNames=QualifiedNameList ')'
	public AlfGrammarAccess.AcceptClauseElements getAcceptClauseAccess() {
		return gaAlf.getAcceptClauseAccess();
	}
	
	public ParserRule getAcceptClauseRule() {
		return getAcceptClauseAccess().getRule();
	}

	/// * CLASSIFY STATEMENTS * / ClassifyStatement:
	//	'classify' expression=Expression (fromList=ClassificationFromClause toList=ClassificationToClause? |
	//	isReclassifyAll?=ReclassifyAllClause? toList=ClassificationToClause)
	//	';';
	public AlfGrammarAccess.ClassifyStatementElements getClassifyStatementAccess() {
		return gaAlf.getClassifyStatementAccess();
	}
	
	public ParserRule getClassifyStatementRule() {
		return getClassifyStatementAccess().getRule();
	}

	//ClassificationFromClause QualifiedNameList:
	//	'from' QualifiedNameList
	public AlfGrammarAccess.ClassificationFromClauseElements getClassificationFromClauseAccess() {
		return gaAlf.getClassificationFromClauseAccess();
	}
	
	public ParserRule getClassificationFromClauseRule() {
		return getClassificationFromClauseAccess().getRule();
	}

	//ClassificationToClause QualifiedNameList:
	//	'to' QualifiedNameList
	public AlfGrammarAccess.ClassificationToClauseElements getClassificationToClauseAccess() {
		return gaAlf.getClassificationToClauseAccess();
	}
	
	public ParserRule getClassificationToClauseRule() {
		return getClassificationToClauseAccess().getRule();
	}

	//ReclassifyAllClause:
	//	'from' '*';
	public AlfGrammarAccess.ReclassifyAllClauseElements getReclassifyAllClauseAccess() {
		return gaAlf.getReclassifyAllClauseAccess();
	}
	
	public ParserRule getReclassifyAllClauseRule() {
		return getReclassifyAllClauseAccess().getRule();
	}

	//QualifiedNameList:
	//	name+=QualifiedName (',' name+=QualifiedName)*;
	public AlfGrammarAccess.QualifiedNameListElements getQualifiedNameListAccess() {
		return gaAlf.getQualifiedNameListAccess();
	}
	
	public ParserRule getQualifiedNameListRule() {
		return getQualifiedNameListAccess().getRule();
	}

	//terminal BOOLEAN_VALUE:
	//	'true' | 'false';
	public TerminalRule getBOOLEAN_VALUERule() {
		return gaAlf.getBOOLEAN_VALUERule();
	} 

	//terminal NATURAL_VALUE:
	//	('0' | '1'..'9' ('_'? '0'..'9')*) | ('0b' | '0B') '0'..'1' ('_'? '0'..'1')* | ('0x' | '0X') ('0'..'9' | 'a'..'f' |
	//	'A'..'F') ('_'? ('0'..'9' | 'a'..'f' | 'A'..'F'))* | '0' '_'? '0'..'7' ('_'? '0'..'7')*;
	public TerminalRule getNATURAL_VALUERule() {
		return gaAlf.getNATURAL_VALUERule();
	} 

	//terminal ID:
	//	('a'..'z' | 'A'..'Z' | '_') ('a'..'z' | 'A'..'Z' | '_' | '0'..'9')*;
	public TerminalRule getIDRule() {
		return gaAlf.getIDRule();
	} 

	//terminal UNRESTRICTED_NAME:
	//	'\'' ('\\' ('b' | 't' | 'n' | 'f' | 'r' | '"' | "'" | '\\') | !('\\' | '\''))* '\'';
	public TerminalRule getUNRESTRICTED_NAMERule() {
		return gaAlf.getUNRESTRICTED_NAMERule();
	} 

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

	//terminal DOCUMENTATION_COMMENT:
	//	'/ **'->'* /';
	public TerminalRule getDOCUMENTATION_COMMENTRule() {
		return gaAlf.getDOCUMENTATION_COMMENTRule();
	} 

	//terminal STATEMENT_ANNOTATION:
	//	'//@'->'\n'
	//	//  '//@' WS? ID (WS? '(' WS? (ID | UNRESTRICTED_NAME) (WS? ',' WS? (ID | UNRESTRICTED_NAME))* WS? ')')? 
	//	//  (WS? '@' WS? ID (WS? '(' WS? (ID | UNRESTRICTED_NAME) (WS? ',' WS? (ID | UNRESTRICTED_NAME))* WS? ')')?)* (' '|'\t')* ('\r'? '\n')
	//;
	public TerminalRule getSTATEMENT_ANNOTATIONRule() {
		return gaAlf.getSTATEMENT_ANNOTATIONRule();
	} 

	//terminal INLINE_STATEMENT:
	//	'/ *@inline(' (ID | UNRESTRICTED_NAME) ')'->'* /';
	public TerminalRule getINLINE_STATEMENTRule() {
		return gaAlf.getINLINE_STATEMENTRule();
	} 

	//terminal ML_COMMENT:
	//	'/ *' !('*' | '@')->'* /';
	public TerminalRule getML_COMMENTRule() {
		return gaAlf.getML_COMMENTRule();
	} 

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

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