diff options
Diffstat (limited to 'rba.model.core/src/rba/core/util/RBACoreAdapterFactory.java')
| -rw-r--r-- | rba.model.core/src/rba/core/util/RBACoreAdapterFactory.java | 1861 |
1 files changed, 1861 insertions, 0 deletions
diff --git a/rba.model.core/src/rba/core/util/RBACoreAdapterFactory.java b/rba.model.core/src/rba/core/util/RBACoreAdapterFactory.java new file mode 100644 index 0000000..715cc9a --- /dev/null +++ b/rba.model.core/src/rba/core/util/RBACoreAdapterFactory.java @@ -0,0 +1,1861 @@ +/** + */ +package rba.core.util; + +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notifier; + +import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl; + +import org.eclipse.emf.ecore.EObject; +import rba.core.AbstractAllocatable; +import rba.core.AbstractConstraint; +import rba.core.AbstractContent; +import rba.core.AbstractProperty; +import rba.core.AbstractScene; +import rba.core.ActiveContents; +import rba.core.ActiveState; +import rba.core.Allocatable; +import rba.core.AllocatableOperator; +import rba.core.AllocatableSet; +import rba.core.AllocatedContent; +import rba.core.AndOperator; +import rba.core.ArbitrationPolicyExpression; +import rba.core.ArithmeticOperator; +import rba.core.ComparisonAnd; +import rba.core.ComparisonOperator; +import rba.core.ComplexExpression; +import rba.core.Constraint; +import rba.core.Content; +import rba.core.ContentOperator; +import rba.core.ContentSet; +import rba.core.ContentState; +import rba.core.ContentStateOperator; +import rba.core.ContentValue; +import rba.core.EnumExpression; +import rba.core.EqualToOperator; +import rba.core.ExistsOperator; +import rba.core.Expression; +import rba.core.ForAllOperator; +import rba.core.GetAllocatables; +import rba.core.GetContentsList; +import rba.core.GetProperty; +import rba.core.GetState; +import rba.core.GreaterThanOperator; +import rba.core.HasBeenDisplayed; +import rba.core.HasComeEarlierThan; +import rba.core.HasComeLaterThan; +import rba.core.IfStatement; +import rba.core.ImpliesOperator; +import rba.core.IntegerProperty; +import rba.core.IntegerValue; +import rba.core.IsActive; +import rba.core.IsAllocatedTo; +import rba.core.IsChanged; +import rba.core.IsEqualToOperator; +import rba.core.IsGreaterThanEqualOperator; +import rba.core.IsGreaterThanOperator; +import rba.core.IsLowerThanEqualOperator; +import rba.core.IsLowerThanOperator; +import rba.core.IsOn; +import rba.core.IsTranslatedTo; +import rba.core.IsTypeOf; +import rba.core.LambdaContext; +import rba.core.LambdaExpression; +import rba.core.LetStatement; +import rba.core.LogicalOperator; +import rba.core.LoserTypeExpression; +import rba.core.LowerThanOperator; +import rba.core.MaxOperator; +import rba.core.MaxValue; +import rba.core.MinOperator; +import rba.core.MinValue; +import rba.core.ModelElement; +import rba.core.MuchGreaterThanOperator; +import rba.core.NamedElement; +import rba.core.NoneValue; +import rba.core.NotOperator; +import rba.core.NullExpression; +import rba.core.ObjectCompare; +import rba.core.ObjectCompareNot; +import rba.core.ObjectReference; +import rba.core.Operator; +import rba.core.OrOperator; +import rba.core.PackagableElement; +import rba.core.PlusOperator; +import rba.core.PreviousModifier; +import rba.core.Project; +import rba.core.PropertyOperator; +import rba.core.RBACorePackage; +import rba.core.RuleObject; +import rba.core.Scene; +import rba.core.SceneOperator; +import rba.core.SelectOperator; +import rba.core.SetExpression; +import rba.core.SetOfOperator; +import rba.core.SetOperator; +import rba.core.SizeOperator; +import rba.core.StandardValue; +import rba.core.StateValue; +import rba.core.Stereotype; +import rba.core.SugarExpression; +import rba.core.SugarExpressionBase; +import rba.core.Tag; +import rba.core.ThatOfOperator; +import rba.core.ValueExpression; +import rba.core.Variable; + +/** + * <!-- begin-user-doc --> The <b>Adapter Factory</b> for the model. It provides an adapter <code>createXXX</code> method for + * each class of the model. <!-- end-user-doc --> + * @see rba.core.RBACorePackage + * @generated + */ +public class RBACoreAdapterFactory extends AdapterFactoryImpl { + /** + * The cached model package. + * <!-- begin-user-doc --> <!-- end-user-doc --> + * @generated + */ + protected static RBACorePackage modelPackage; + + /** + * Creates an instance of the adapter factory. + * <!-- begin-user-doc --> <!-- end-user-doc --> + * @generated + */ + public RBACoreAdapterFactory() { + if (modelPackage == null) { + modelPackage = RBACorePackage.eINSTANCE; + } + } + + /** + * Returns whether this factory is applicable for the type of the object. + * <!-- begin-user-doc --> This implementation + * returns <code>true</code> if the object is either the model's package or is an instance object of the model. <!-- + * end-user-doc --> + * @return whether this factory is applicable for the type of the object. + * @generated + */ + @Override + public boolean isFactoryForType(Object object) { + if (object == modelPackage) { + return true; + } + if (object instanceof EObject) { + return ((EObject) object).eClass().getEPackage() == modelPackage; + } + return false; + } + + /** + * The switch that delegates to the <code>createXXX</code> methods. + * <!-- begin-user-doc --> <!-- end-user-doc --> + * @generated + */ + protected RBACoreSwitch<Adapter> modelSwitch = new RBACoreSwitch<Adapter>() { + @Override + public Adapter caseModelElement(ModelElement object) { + return createModelElementAdapter(); + } + + @Override + public Adapter caseNamedElement(NamedElement object) { + return createNamedElementAdapter(); + } + + @Override + public Adapter caseAbstractAllocatable(AbstractAllocatable object) { + return createAbstractAllocatableAdapter(); + } + + @Override + public Adapter caseAllocatable(Allocatable object) { + return createAllocatableAdapter(); + } + + @Override + public Adapter caseAllocatableSet(AllocatableSet object) { + return createAllocatableSetAdapter(); + } + + @Override + public Adapter caseProject(Project object) { + return createProjectAdapter(); + } + + @Override + public Adapter casePackagableElement(PackagableElement object) { + return createPackagableElementAdapter(); + } + + @Override + public Adapter casePackage(rba.core.Package object) { + return createPackageAdapter(); + } + + @Override + public Adapter caseStereotype(Stereotype object) { + return createStereotypeAdapter(); + } + + @Override + public Adapter caseTag(Tag object) { + return createTagAdapter(); + } + + @Override + public Adapter caseRuleObject(RuleObject object) { + return createRuleObjectAdapter(); + } + + @Override + public Adapter caseAbstractContent(AbstractContent object) { + return createAbstractContentAdapter(); + } + + @Override + public Adapter caseAbstractScene(AbstractScene object) { + return createAbstractSceneAdapter(); + } + + @Override + public Adapter caseScene(Scene object) { + return createSceneAdapter(); + } + + @Override + public Adapter caseContent(Content object) { + return createContentAdapter(); + } + + @Override + public Adapter caseContentSet(ContentSet object) { + return createContentSetAdapter(); + } + + @Override + public Adapter caseContentState(ContentState object) { + return createContentStateAdapter(); + } + + @Override + public Adapter caseAbstractProperty(AbstractProperty object) { + return createAbstractPropertyAdapter(); + } + + @Override + public Adapter caseIntegerProperty(IntegerProperty object) { + return createIntegerPropertyAdapter(); + } + + @Override + public Adapter caseAbstractConstraint(AbstractConstraint object) { + return createAbstractConstraintAdapter(); + } + + @Override + public Adapter caseConstraint(Constraint object) { + return createConstraintAdapter(); + } + + @Override + public Adapter caseExpression(Expression object) { + return createExpressionAdapter(); + } + + @Override + public Adapter caseLetStatement(LetStatement object) { + return createLetStatementAdapter(); + } + + @Override + public Adapter caseComplexExpression(ComplexExpression object) { + return createComplexExpressionAdapter(); + } + + @Override + public Adapter caseOperator(Operator object) { + return createOperatorAdapter(); + } + + @Override + public Adapter caseIsTypeOf(IsTypeOf object) { + return createIsTypeOfAdapter(); + } + + @Override + public Adapter caseObjectReference(ObjectReference object) { + return createObjectReferenceAdapter(); + } + + @Override + public Adapter casePreviousModifier(PreviousModifier object) { + return createPreviousModifierAdapter(); + } + + @Override + public Adapter caseGreaterThanOperator(GreaterThanOperator object) { + return createGreaterThanOperatorAdapter(); + } + + @Override + public Adapter caseMuchGreaterThanOperator(MuchGreaterThanOperator object) { + return createMuchGreaterThanOperatorAdapter(); + } + + @Override + public Adapter caseLowerThanOperator(LowerThanOperator object) { + return createLowerThanOperatorAdapter(); + } + + @Override + public Adapter caseComparisonOperator(ComparisonOperator object) { + return createComparisonOperatorAdapter(); + } + + @Override + public Adapter caseEqualToOperator(EqualToOperator object) { + return createEqualToOperatorAdapter(); + } + + @Override + public Adapter caseComparisonAnd(ComparisonAnd object) { + return createComparisonAndAdapter(); + } + + @Override + public Adapter caseLogicalOperator(LogicalOperator object) { + return createLogicalOperatorAdapter(); + } + + @Override + public Adapter caseAndOperator(AndOperator object) { + return createAndOperatorAdapter(); + } + + @Override + public Adapter caseOrOperator(OrOperator object) { + return createOrOperatorAdapter(); + } + + @Override + public Adapter caseNotOperator(NotOperator object) { + return createNotOperatorAdapter(); + } + + @Override + public Adapter caseIsEqualToOperator(IsEqualToOperator object) { + return createIsEqualToOperatorAdapter(); + } + + @Override + public Adapter caseIsGreaterThanOperator(IsGreaterThanOperator object) { + return createIsGreaterThanOperatorAdapter(); + } + + @Override + public Adapter caseIsLowerThanOperator(IsLowerThanOperator object) { + return createIsLowerThanOperatorAdapter(); + } + + @Override + public Adapter caseIsGreaterThanEqualOperator(IsGreaterThanEqualOperator object) { + return createIsGreaterThanEqualOperatorAdapter(); + } + + @Override + public Adapter caseIsLowerThanEqualOperator(IsLowerThanEqualOperator object) { + return createIsLowerThanEqualOperatorAdapter(); + } + + @Override + public Adapter caseArithmeticOperator(ArithmeticOperator object) { + return createArithmeticOperatorAdapter(); + } + + @Override + public Adapter casePlusOperator(PlusOperator object) { + return createPlusOperatorAdapter(); + } + + @Override + public Adapter caseImpliesOperator(ImpliesOperator object) { + return createImpliesOperatorAdapter(); + } + + @Override + public Adapter caseContentOperator(ContentOperator object) { + return createContentOperatorAdapter(); + } + + @Override + public Adapter caseIsActive(IsActive object) { + return createIsActiveAdapter(); + } + + @Override + public Adapter caseGetAllocatables(GetAllocatables object) { + return createGetAllocatablesAdapter(); + } + + @Override + public Adapter caseHasBeenDisplayed(HasBeenDisplayed object) { + return createHasBeenDisplayedAdapter(); + } + + @Override + public Adapter caseActiveState(ActiveState object) { + return createActiveStateAdapter(); + } + + @Override + public Adapter caseObjectCompare(ObjectCompare object) { + return createObjectCompareAdapter(); + } + + @Override + public Adapter caseThatOfOperator(ThatOfOperator object) { + return createThatOfOperatorAdapter(); + } + + @Override + public Adapter caseValueExpression(ValueExpression object) { + return createValueExpressionAdapter(); + } + + @Override + public Adapter caseMaxValue(MaxValue object) { + return createMaxValueAdapter(); + } + + @Override + public Adapter caseMinValue(MinValue object) { + return createMinValueAdapter(); + } + + @Override + public Adapter caseNoneValue(NoneValue object) { + return createNoneValueAdapter(); + } + + @Override + public Adapter caseStandardValue(StandardValue object) { + return createStandardValueAdapter(); + } + + @Override + public Adapter caseIntegerValue(IntegerValue object) { + return createIntegerValueAdapter(); + } + + @Override + public Adapter caseEnumExpression(EnumExpression object) { + return createEnumExpressionAdapter(); + } + + @Override + public Adapter caseLoserTypeExpression(LoserTypeExpression object) { + return createLoserTypeExpressionAdapter(); + } + + @Override + public Adapter caseArbitrationPolicyExpression(ArbitrationPolicyExpression object) { + return createArbitrationPolicyExpressionAdapter(); + } + + @Override + public Adapter caseSetExpression(SetExpression object) { + return createSetExpressionAdapter(); + } + + @Override + public Adapter caseSetOperator(SetOperator object) { + return createSetOperatorAdapter(); + } + + @Override + public Adapter caseSizeOperator(SizeOperator object) { + return createSizeOperatorAdapter(); + } + + @Override + public Adapter caseExistsOperator(ExistsOperator object) { + return createExistsOperatorAdapter(); + } + + @Override + public Adapter caseForAllOperator(ForAllOperator object) { + return createForAllOperatorAdapter(); + } + + @Override + public Adapter caseMaxOperator(MaxOperator object) { + return createMaxOperatorAdapter(); + } + + @Override + public Adapter caseMinOperator(MinOperator object) { + return createMinOperatorAdapter(); + } + + @Override + public Adapter caseSelectOperator(SelectOperator object) { + return createSelectOperatorAdapter(); + } + + @Override + public Adapter caseSetOfOperator(SetOfOperator object) { + return createSetOfOperatorAdapter(); + } + + @Override + public Adapter caseLambdaExpression(LambdaExpression object) { + return createLambdaExpressionAdapter(); + } + + @Override + public Adapter caseVariable(Variable object) { + return createVariableAdapter(); + } + + @Override + public Adapter caseLambdaContext(LambdaContext object) { + return createLambdaContextAdapter(); + } + + @Override + public Adapter caseIfStatement(IfStatement object) { + return createIfStatementAdapter(); + } + + @Override + public Adapter caseSceneOperator(SceneOperator object) { + return createSceneOperatorAdapter(); + } + + @Override + public Adapter caseIsOn(IsOn object) { + return createIsOnAdapter(); + } + + @Override + public Adapter caseAllocatableOperator(AllocatableOperator object) { + return createAllocatableOperatorAdapter(); + } + + @Override + public Adapter caseAllocatedContent(AllocatedContent object) { + return createAllocatedContentAdapter(); + } + + @Override + public Adapter caseContentValue(ContentValue object) { + return createContentValueAdapter(); + } + + @Override + public Adapter caseGetContentsList(GetContentsList object) { + return createGetContentsListAdapter(); + } + + @Override + public Adapter caseActiveContents(ActiveContents object) { + return createActiveContentsAdapter(); + } + + @Override + public Adapter casePropertyOperator(PropertyOperator object) { + return createPropertyOperatorAdapter(); + } + + @Override + public Adapter caseGetProperty(GetProperty object) { + return createGetPropertyAdapter(); + } + + @Override + public Adapter caseStateValue(StateValue object) { + return createStateValueAdapter(); + } + + @Override + public Adapter caseHasComeLaterThan(HasComeLaterThan object) { + return createHasComeLaterThanAdapter(); + } + + @Override + public Adapter caseHasComeEarlierThan(HasComeEarlierThan object) { + return createHasComeEarlierThanAdapter(); + } + + @Override + public Adapter caseSugarExpression(SugarExpression object) { + return createSugarExpressionAdapter(); + } + + @Override + public Adapter caseSugarExpressionBase(SugarExpressionBase object) { + return createSugarExpressionBaseAdapter(); + } + + @Override + public Adapter caseObjectCompareNot(ObjectCompareNot object) { + return createObjectCompareNotAdapter(); + } + + @Override + public Adapter caseIsAllocatedTo(IsAllocatedTo object) { + return createIsAllocatedToAdapter(); + } + + @Override + public Adapter caseIsChanged(IsChanged object) { + return createIsChangedAdapter(); + } + + @Override + public Adapter caseIsTranslatedTo(IsTranslatedTo object) { + return createIsTranslatedToAdapter(); + } + + @Override + public Adapter caseGetState(GetState object) { + return createGetStateAdapter(); + } + + @Override + public Adapter caseContentStateOperator(ContentStateOperator object) { + return createContentStateOperatorAdapter(); + } + + @Override + public Adapter caseNullExpression(NullExpression object) { + return createNullExpressionAdapter(); + } + + @Override + public Adapter defaultCase(EObject object) { + return createEObjectAdapter(); + } + }; + + /** + * Creates an adapter for the <code>target</code>. + * <!-- begin-user-doc --> <!-- end-user-doc --> + * @param target the object to adapt. + * @return the adapter for the <code>target</code>. + * @generated + */ + @Override + public Adapter createAdapter(Notifier target) { + return modelSwitch.doSwitch((EObject) target); + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ModelElement <em>Model Element</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ModelElement + * @generated + */ + public Adapter createModelElementAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.NamedElement <em>Named Element</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.NamedElement + * @generated + */ + public Adapter createNamedElementAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.AbstractAllocatable <em>Abstract Allocatable</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.AbstractAllocatable + * @generated + */ + public Adapter createAbstractAllocatableAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.Allocatable <em>Allocatable</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.Allocatable + * @generated + */ + public Adapter createAllocatableAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.AllocatableSet <em>Allocatable Set</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.AllocatableSet + * @generated + */ + public Adapter createAllocatableSetAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.Project <em>Project</em>}'. + * <!-- begin-user-doc --> This + * default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when inheritance + * will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.Project + * @generated + */ + public Adapter createProjectAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.PackagableElement <em>Packagable Element</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.PackagableElement + * @generated + */ + public Adapter createPackagableElementAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.Package <em>Package</em>}'. + * <!-- begin-user-doc --> This + * default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when inheritance + * will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.Package + * @generated + */ + public Adapter createPackageAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.Stereotype <em>Stereotype</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.Stereotype + * @generated + */ + public Adapter createStereotypeAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.Tag <em>Tag</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.Tag + * @generated + */ + public Adapter createTagAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.RuleObject <em>Rule Object</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.RuleObject + * @generated + */ + public Adapter createRuleObjectAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.AbstractContent <em>Abstract Content</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.AbstractContent + * @generated + */ + public Adapter createAbstractContentAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.AbstractScene <em>Abstract Scene</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.AbstractScene + * @generated + */ + public Adapter createAbstractSceneAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.Scene <em>Scene</em>}'. + * <!-- begin-user-doc --> This + * default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when inheritance + * will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.Scene + * @generated + */ + public Adapter createSceneAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.Content <em>Content</em>}'. + * <!-- begin-user-doc --> This + * default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when inheritance + * will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.Content + * @generated + */ + public Adapter createContentAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ContentSet <em>Content Set</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ContentSet + * @generated + */ + public Adapter createContentSetAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ContentState <em>Content State</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ContentState + * @generated + */ + public Adapter createContentStateAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.AbstractProperty <em>Abstract Property</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.AbstractProperty + * @generated + */ + public Adapter createAbstractPropertyAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.IntegerProperty <em>Integer Property</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.IntegerProperty + * @generated + */ + public Adapter createIntegerPropertyAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.AbstractConstraint <em>Abstract Constraint</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.AbstractConstraint + * @generated + */ + public Adapter createAbstractConstraintAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.Constraint <em>Constraint</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.Constraint + * @generated + */ + public Adapter createConstraintAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.Expression <em>Expression</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.Expression + * @generated + */ + public Adapter createExpressionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.LetStatement <em>Let Statement</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.LetStatement + * @generated + */ + public Adapter createLetStatementAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ComplexExpression <em>Complex Expression</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ComplexExpression + * @generated + */ + public Adapter createComplexExpressionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.Operator <em>Operator</em>}'. + * <!-- begin-user-doc --> This + * default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when inheritance + * will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.Operator + * @generated + */ + public Adapter createOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.IsTypeOf <em>Is Type Of</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.IsTypeOf + * @generated + */ + public Adapter createIsTypeOfAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ObjectReference <em>Object Reference</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ObjectReference + * @generated + */ + public Adapter createObjectReferenceAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.PreviousModifier <em>Previous Modifier</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.PreviousModifier + * @generated + */ + public Adapter createPreviousModifierAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.GreaterThanOperator <em>Greater Than Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.GreaterThanOperator + * @generated + */ + public Adapter createGreaterThanOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.MuchGreaterThanOperator <em>Much Greater Than Operator</em>}'. + * <!-- begin-user-doc --> This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.MuchGreaterThanOperator + * @generated + */ + public Adapter createMuchGreaterThanOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.LowerThanOperator <em>Lower Than Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.LowerThanOperator + * @generated + */ + public Adapter createLowerThanOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ComparisonOperator <em>Comparison Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ComparisonOperator + * @generated + */ + public Adapter createComparisonOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.EqualToOperator <em>Equal To Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.EqualToOperator + * @generated + */ + public Adapter createEqualToOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ComparisonAnd <em>Comparison And</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ComparisonAnd + * @generated + */ + public Adapter createComparisonAndAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.LogicalOperator <em>Logical Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.LogicalOperator + * @generated + */ + public Adapter createLogicalOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.AndOperator <em>And Operator</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.AndOperator + * @generated + */ + public Adapter createAndOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.OrOperator <em>Or Operator</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.OrOperator + * @generated + */ + public Adapter createOrOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.NotOperator <em>Not Operator</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.NotOperator + * @generated + */ + public Adapter createNotOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.IsEqualToOperator <em>Is Equal To Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.IsEqualToOperator + * @generated + */ + public Adapter createIsEqualToOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.IsGreaterThanOperator <em>Is Greater Than Operator</em>}'. + * <!-- begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to + * ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.IsGreaterThanOperator + * @generated + */ + public Adapter createIsGreaterThanOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.IsLowerThanOperator <em>Is Lower Than Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.IsLowerThanOperator + * @generated + */ + public Adapter createIsLowerThanOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.IsGreaterThanEqualOperator <em>Is Greater Than Equal Operator</em>}'. + * <!-- begin-user-doc --> This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.IsGreaterThanEqualOperator + * @generated + */ + public Adapter createIsGreaterThanEqualOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.IsLowerThanEqualOperator <em>Is Lower Than Equal Operator</em>}'. + * <!-- begin-user-doc --> This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.IsLowerThanEqualOperator + * @generated + */ + public Adapter createIsLowerThanEqualOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ArithmeticOperator <em>Arithmetic Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ArithmeticOperator + * @generated + */ + public Adapter createArithmeticOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.PlusOperator <em>Plus Operator</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.PlusOperator + * @generated + */ + public Adapter createPlusOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ImpliesOperator <em>Implies Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ImpliesOperator + * @generated + */ + public Adapter createImpliesOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ContentOperator <em>Content Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ContentOperator + * @generated + */ + public Adapter createContentOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.IsActive <em>Is Active</em>}'. + * <!-- begin-user-doc --> This + * default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when inheritance + * will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.IsActive + * @generated + */ + public Adapter createIsActiveAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.GetAllocatables <em>Get Allocatables</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.GetAllocatables + * @generated + */ + public Adapter createGetAllocatablesAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.HasBeenDisplayed <em>Has Been Displayed</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.HasBeenDisplayed + * @generated + */ + public Adapter createHasBeenDisplayedAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ActiveState <em>Active State</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ActiveState + * @generated + */ + public Adapter createActiveStateAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ObjectCompare <em>Object Compare</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ObjectCompare + * @generated + */ + public Adapter createObjectCompareAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ThatOfOperator <em>That Of Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ThatOfOperator + * @generated + */ + public Adapter createThatOfOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ValueExpression <em>Value Expression</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ValueExpression + * @generated + */ + public Adapter createValueExpressionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.MaxValue <em>Max Value</em>}'. + * <!-- begin-user-doc --> This + * default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when inheritance + * will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.MaxValue + * @generated + */ + public Adapter createMaxValueAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.MinValue <em>Min Value</em>}'. + * <!-- begin-user-doc --> This + * default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when inheritance + * will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.MinValue + * @generated + */ + public Adapter createMinValueAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.NoneValue <em>None Value</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.NoneValue + * @generated + */ + public Adapter createNoneValueAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.StandardValue <em>Standard Value</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.StandardValue + * @generated + */ + public Adapter createStandardValueAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.IntegerValue <em>Integer Value</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.IntegerValue + * @generated + */ + public Adapter createIntegerValueAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.EnumExpression <em>Enum Expression</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.EnumExpression + * @generated + */ + public Adapter createEnumExpressionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.LoserTypeExpression <em>Loser Type Expression</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.LoserTypeExpression + * @generated + */ + public Adapter createLoserTypeExpressionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ArbitrationPolicyExpression <em>Arbitration Policy Expression</em>}'. + * <!-- begin-user-doc --> This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ArbitrationPolicyExpression + * @generated + */ + public Adapter createArbitrationPolicyExpressionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.SetExpression <em>Set Expression</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.SetExpression + * @generated + */ + public Adapter createSetExpressionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.SetOperator <em>Set Operator</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.SetOperator + * @generated + */ + public Adapter createSetOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.SizeOperator <em>Size Operator</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.SizeOperator + * @generated + */ + public Adapter createSizeOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ExistsOperator <em>Exists Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ExistsOperator + * @generated + */ + public Adapter createExistsOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ForAllOperator <em>For All Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ForAllOperator + * @generated + */ + public Adapter createForAllOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.MaxOperator <em>Max Operator</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.MaxOperator + * @generated + */ + public Adapter createMaxOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.MinOperator <em>Min Operator</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.MinOperator + * @generated + */ + public Adapter createMinOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.SelectOperator <em>Select Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.SelectOperator + * @generated + */ + public Adapter createSelectOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.SetOfOperator <em>Set Of Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.SetOfOperator + * @generated + */ + public Adapter createSetOfOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.LambdaExpression <em>Lambda Expression</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.LambdaExpression + * @generated + */ + public Adapter createLambdaExpressionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.Variable <em>Variable</em>}'. + * <!-- begin-user-doc --> This + * default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when inheritance + * will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.Variable + * @generated + */ + public Adapter createVariableAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.LambdaContext <em>Lambda Context</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.LambdaContext + * @generated + */ + public Adapter createLambdaContextAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.IfStatement <em>If Statement</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.IfStatement + * @generated + */ + public Adapter createIfStatementAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.SceneOperator <em>Scene Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.SceneOperator + * @generated + */ + public Adapter createSceneOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.IsOn <em>Is On</em>}'. + * <!-- begin-user-doc --> This default + * implementation returns null so that we can easily ignore cases; it's useful to ignore a case when inheritance will catch + * all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.IsOn + * @generated + */ + public Adapter createIsOnAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.AllocatableOperator <em>Allocatable Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.AllocatableOperator + * @generated + */ + public Adapter createAllocatableOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.AllocatedContent <em>Allocated Content</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.AllocatedContent + * @generated + */ + public Adapter createAllocatedContentAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ContentValue <em>Content Value</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ContentValue + * @generated + */ + public Adapter createContentValueAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.GetContentsList <em>Get Contents List</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.GetContentsList + * @generated + */ + public Adapter createGetContentsListAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ActiveContents <em>Active Contents</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ActiveContents + * @generated + */ + public Adapter createActiveContentsAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.PropertyOperator <em>Property Operator</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.PropertyOperator + * @generated + */ + public Adapter createPropertyOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.GetProperty <em>Get Property</em>}'. + * <!-- begin-user-doc + * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.GetProperty + * @generated + */ + public Adapter createGetPropertyAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.StateValue <em>State Value</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.StateValue + * @generated + */ + public Adapter createStateValueAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.HasComeLaterThan <em>Has Come Later Than</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.HasComeLaterThan + * @generated + */ + public Adapter createHasComeLaterThanAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.HasComeEarlierThan <em>Has Come Earlier Than</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.HasComeEarlierThan + * @generated + */ + public Adapter createHasComeEarlierThanAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.SugarExpression <em>Sugar Expression</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.SugarExpression + * @generated + */ + public Adapter createSugarExpressionAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.SugarExpressionBase <em>Sugar Expression Base</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.SugarExpressionBase + * @generated + */ + public Adapter createSugarExpressionBaseAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ObjectCompareNot <em>Object Compare Not</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ObjectCompareNot + * @generated + */ + public Adapter createObjectCompareNotAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.IsAllocatedTo <em>Is Allocated To</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.IsAllocatedTo + * @generated + */ + public Adapter createIsAllocatedToAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.IsChanged <em>Is Changed</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when + * inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.IsChanged + * @generated + */ + public Adapter createIsChangedAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.IsTranslatedTo <em>Is Translated To</em>}'. <!-- + * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a + * case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.IsTranslatedTo + * @generated + */ + public Adapter createIsTranslatedToAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.GetState <em>Get State</em>}'. + * <!-- begin-user-doc --> This + * default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when inheritance + * will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.GetState + * @generated + */ + public Adapter createGetStateAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.ContentStateOperator <em>Content State Operator</em>}'. + * <!-- begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to + * ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.ContentStateOperator + * @generated + */ + public Adapter createContentStateOperatorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link rba.core.NullExpression <em>Null Expression</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * <!-- end-user-doc --> + * @return the new adapter. + * @see rba.core.NullExpression + * @generated + */ + public Adapter createNullExpressionAdapter() { + return null; + } + + /** + * Creates a new adapter for the default case. + * <!-- begin-user-doc --> This default implementation returns null. <!-- + * end-user-doc --> + * @return the new adapter. + * @generated + */ + public Adapter createEObjectAdapter() { + return null; + } + +} // RBACoreAdapterFactory |