/**
*/
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;
/**
* The Adapter Factory for the model. It provides an adapter createXXX
method for
* each class of the model.
* @see rba.core.RBACorePackage
* @generated
*/
public class RBACoreAdapterFactory extends AdapterFactoryImpl {
/**
* The cached model package.
*
* @generated
*/
protected static RBACorePackage modelPackage;
/**
* Creates an instance of the adapter factory.
*
* @generated
*/
public RBACoreAdapterFactory() {
if (modelPackage == null) {
modelPackage = RBACorePackage.eINSTANCE;
}
}
/**
* Returns whether this factory is applicable for the type of the object.
* This implementation
* returns true
if the object is either the model's package or is an instance object of the model.
* @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 createXXX
methods.
*
* @generated
*/
protected RBACoreSwitch modelSwitch = new RBACoreSwitch() {
@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 target
.
*
* @param target the object to adapt.
* @return the adapter for the target
.
* @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 Model Element}'.
* 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.
* @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 Named Element}'.
* 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.
* @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 Abstract Allocatable}'. 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.
* @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 Allocatable}'.
*
* 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.
* @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 Allocatable Set}'. 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.
* @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 Project}'.
* 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.
* @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 Packagable Element}'. 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.
* @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 Package}'.
* 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.
* @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 Stereotype}'.
*
* 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.
* @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 Tag}'.
*
* 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.
*
* @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 Rule Object}'.
*
* 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.
* @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 Abstract Content}'. 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.
* @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 Abstract Scene}'. 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.
* @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 Scene}'.
* 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.
* @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 Content}'.
* 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.
* @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 Content Set}'.
*
* 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.
* @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 Content State}'.
* 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.
* @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 Abstract Property}'. 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.
* @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 Integer Property}'. 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.
* @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 Abstract Constraint}'. 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.
* @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 Constraint}'.
*
* 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.
* @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 Expression}'.
*
* 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.
* @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 Let Statement}'.
* 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.
* @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 Complex Expression}'. 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.
* @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 Operator}'.
* 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.
* @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 Is Type Of}'.
*
* 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.
* @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 Object Reference}'. 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.
* @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 Previous Modifier}'. 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.
* @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 Greater Than Operator}'. 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.
* @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 Much Greater Than Operator}'.
* 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.
* @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 Lower Than Operator}'. 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.
* @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 Comparison Operator}'. 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.
* @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 Equal To Operator}'. 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.
* @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 Comparison And}'. 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.
* @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 Logical Operator}'. 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.
* @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 And Operator}'.
* 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.
* @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 Or Operator}'.
*
* 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.
* @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 Not Operator}'.
* 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.
* @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 Is Equal To Operator}'. 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.
* @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 Is Greater Than Operator}'.
* 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.
* @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 Is Lower Than Operator}'. 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.
* @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 Is Greater Than Equal Operator}'.
* 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.
* @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 Is Lower Than Equal Operator}'.
* 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.
* @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 Arithmetic Operator}'. 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.
* @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 Plus Operator}'.
* 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.
* @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 Implies Operator}'. 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.
* @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 Content Operator}'. 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.
* @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 Is Active}'.
* 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.
* @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 Get Allocatables}'. 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.
* @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 Has Been Displayed}'. 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.
* @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 Active State}'.
* 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.
* @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 Object Compare}'. 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.
* @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 That Of Operator}'. 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.
* @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 Value Expression}'. 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.
* @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 Max Value}'.
* 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.
* @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 Min Value}'.
* 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.
* @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 None Value}'.
*
* 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.
* @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 Standard Value}'. 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.
* @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 Integer Value}'.
* 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.
* @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 Enum Expression}'. 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.
* @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 Loser Type Expression}'. 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.
* @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 Arbitration Policy Expression}'.
* 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.
* @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 Set Expression}'. 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.
* @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 Set Operator}'.
* 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.
* @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 Size Operator}'.
* 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.
* @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 Exists Operator}'. 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.
* @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 For All Operator}'. 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.
* @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 Max Operator}'.
* 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.
* @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 Min Operator}'.
* 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.
* @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 Select Operator}'. 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.
* @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 Set Of Operator}'. 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.
* @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 Lambda Expression}'. 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.
* @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 Variable}'.
* 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.
* @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 Lambda Context}'. 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.
* @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 If Statement}'.
* 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.
* @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 Scene Operator}'. 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.
* @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 Is On}'.
* 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.
* @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 Allocatable Operator}'. 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.
* @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 Allocated Content}'. 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.
* @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 Content Value}'.
* 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.
* @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 Get Contents List}'. 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.
* @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 Active Contents}'. 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.
* @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 Property Operator}'. 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.
* @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 Get Property}'.
* 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.
* @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 State Value}'.
*
* 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.
* @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 Has Come Later Than}'. 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.
* @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 Has Come Earlier Than}'. 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.
* @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 Sugar Expression}'. 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.
* @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 Sugar Expression Base}'. 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.
* @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 Object Compare Not}'. 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.
* @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 Is Allocated To}'. 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.
* @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 Is Changed}'.
*
* 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.
* @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 Is Translated To}'. 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.
* @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 Get State}'.
* 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.
* @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 Content State Operator}'.
* 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.
* @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 Null Expression}'.
*
* 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.
*
* @return the new adapter.
* @see rba.core.NullExpression
* @generated
*/
public Adapter createNullExpressionAdapter() {
return null;
}
/**
* Creates a new adapter for the default case.
* This default implementation returns null.
* @return the new adapter.
* @generated
*/
public Adapter createEObjectAdapter() {
return null;
}
} // RBACoreAdapterFactory