| /******************************************************************************* |
| * Copyright (c) 2010, 2018 Willink Transformations and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v2.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v20.html |
| * |
| * Contributors: |
| * E.D.Willink - Initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.ocl.pivot.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 org.eclipse.jdt.annotation.Nullable; |
| import org.eclipse.ocl.pivot.Annotation; |
| import org.eclipse.ocl.pivot.AnyType; |
| import org.eclipse.ocl.pivot.AssociationClass; |
| import org.eclipse.ocl.pivot.AssociationClassCallExp; |
| import org.eclipse.ocl.pivot.BagType; |
| import org.eclipse.ocl.pivot.Behavior; |
| import org.eclipse.ocl.pivot.BooleanLiteralExp; |
| import org.eclipse.ocl.pivot.CallExp; |
| import org.eclipse.ocl.pivot.CallOperationAction; |
| import org.eclipse.ocl.pivot.CollectionItem; |
| import org.eclipse.ocl.pivot.CollectionLiteralExp; |
| import org.eclipse.ocl.pivot.CollectionLiteralPart; |
| import org.eclipse.ocl.pivot.CollectionRange; |
| import org.eclipse.ocl.pivot.CollectionType; |
| import org.eclipse.ocl.pivot.Comment; |
| import org.eclipse.ocl.pivot.CompleteClass; |
| import org.eclipse.ocl.pivot.CompleteEnvironment; |
| import org.eclipse.ocl.pivot.CompleteModel; |
| import org.eclipse.ocl.pivot.CompletePackage; |
| import org.eclipse.ocl.pivot.ConnectionPointReference; |
| import org.eclipse.ocl.pivot.Constraint; |
| import org.eclipse.ocl.pivot.DataType; |
| import org.eclipse.ocl.pivot.Detail; |
| import org.eclipse.ocl.pivot.DynamicBehavior; |
| import org.eclipse.ocl.pivot.DynamicElement; |
| import org.eclipse.ocl.pivot.DynamicProperty; |
| import org.eclipse.ocl.pivot.DynamicType; |
| import org.eclipse.ocl.pivot.DynamicValueSpecification; |
| import org.eclipse.ocl.pivot.Element; |
| import org.eclipse.ocl.pivot.ElementExtension; |
| import org.eclipse.ocl.pivot.EnumLiteralExp; |
| import org.eclipse.ocl.pivot.Enumeration; |
| import org.eclipse.ocl.pivot.EnumerationLiteral; |
| import org.eclipse.ocl.pivot.ExpressionInOCL; |
| import org.eclipse.ocl.pivot.Feature; |
| import org.eclipse.ocl.pivot.FeatureCallExp; |
| import org.eclipse.ocl.pivot.FinalState; |
| import org.eclipse.ocl.pivot.IfExp; |
| import org.eclipse.ocl.pivot.Import; |
| import org.eclipse.ocl.pivot.InstanceSpecification; |
| import org.eclipse.ocl.pivot.IntegerLiteralExp; |
| import org.eclipse.ocl.pivot.InvalidLiteralExp; |
| import org.eclipse.ocl.pivot.InvalidType; |
| import org.eclipse.ocl.pivot.IterableType; |
| import org.eclipse.ocl.pivot.IterateExp; |
| import org.eclipse.ocl.pivot.Iteration; |
| import org.eclipse.ocl.pivot.IteratorExp; |
| import org.eclipse.ocl.pivot.IteratorVariable; |
| import org.eclipse.ocl.pivot.LambdaType; |
| import org.eclipse.ocl.pivot.LanguageExpression; |
| import org.eclipse.ocl.pivot.LetExp; |
| import org.eclipse.ocl.pivot.LetVariable; |
| import org.eclipse.ocl.pivot.Library; |
| import org.eclipse.ocl.pivot.LiteralExp; |
| import org.eclipse.ocl.pivot.LoopExp; |
| import org.eclipse.ocl.pivot.MapLiteralExp; |
| import org.eclipse.ocl.pivot.MapLiteralPart; |
| import org.eclipse.ocl.pivot.MapType; |
| import org.eclipse.ocl.pivot.MessageExp; |
| import org.eclipse.ocl.pivot.MessageType; |
| import org.eclipse.ocl.pivot.Model; |
| import org.eclipse.ocl.pivot.NamedElement; |
| import org.eclipse.ocl.pivot.Namespace; |
| import org.eclipse.ocl.pivot.NavigationCallExp; |
| import org.eclipse.ocl.pivot.NullLiteralExp; |
| import org.eclipse.ocl.pivot.NumericLiteralExp; |
| import org.eclipse.ocl.pivot.OCLExpression; |
| import org.eclipse.ocl.pivot.Operation; |
| import org.eclipse.ocl.pivot.OperationCallExp; |
| import org.eclipse.ocl.pivot.OppositePropertyCallExp; |
| import org.eclipse.ocl.pivot.OrderedSetType; |
| import org.eclipse.ocl.pivot.OrphanCompletePackage; |
| import org.eclipse.ocl.pivot.Parameter; |
| import org.eclipse.ocl.pivot.ParameterVariable; |
| import org.eclipse.ocl.pivot.PivotPackage; |
| import org.eclipse.ocl.pivot.Precedence; |
| import org.eclipse.ocl.pivot.PrimitiveCompletePackage; |
| import org.eclipse.ocl.pivot.PrimitiveLiteralExp; |
| import org.eclipse.ocl.pivot.PrimitiveType; |
| import org.eclipse.ocl.pivot.Profile; |
| import org.eclipse.ocl.pivot.ProfileApplication; |
| import org.eclipse.ocl.pivot.Property; |
| import org.eclipse.ocl.pivot.PropertyCallExp; |
| import org.eclipse.ocl.pivot.Pseudostate; |
| import org.eclipse.ocl.pivot.RealLiteralExp; |
| import org.eclipse.ocl.pivot.ReferringElement; |
| import org.eclipse.ocl.pivot.Region; |
| import org.eclipse.ocl.pivot.ResultVariable; |
| import org.eclipse.ocl.pivot.SelfType; |
| import org.eclipse.ocl.pivot.SendSignalAction; |
| import org.eclipse.ocl.pivot.SequenceType; |
| import org.eclipse.ocl.pivot.SetType; |
| import org.eclipse.ocl.pivot.ShadowExp; |
| import org.eclipse.ocl.pivot.ShadowPart; |
| import org.eclipse.ocl.pivot.Signal; |
| import org.eclipse.ocl.pivot.Slot; |
| import org.eclipse.ocl.pivot.StandardLibrary; |
| import org.eclipse.ocl.pivot.State; |
| import org.eclipse.ocl.pivot.StateExp; |
| import org.eclipse.ocl.pivot.StateMachine; |
| import org.eclipse.ocl.pivot.Stereotype; |
| import org.eclipse.ocl.pivot.StereotypeExtender; |
| import org.eclipse.ocl.pivot.StringLiteralExp; |
| import org.eclipse.ocl.pivot.TemplateBinding; |
| import org.eclipse.ocl.pivot.TemplateParameter; |
| import org.eclipse.ocl.pivot.TemplateParameterSubstitution; |
| import org.eclipse.ocl.pivot.TemplateSignature; |
| import org.eclipse.ocl.pivot.TemplateableElement; |
| import org.eclipse.ocl.pivot.Transition; |
| import org.eclipse.ocl.pivot.Trigger; |
| import org.eclipse.ocl.pivot.TupleLiteralExp; |
| import org.eclipse.ocl.pivot.TupleLiteralPart; |
| import org.eclipse.ocl.pivot.TupleType; |
| import org.eclipse.ocl.pivot.Type; |
| import org.eclipse.ocl.pivot.TypeExp; |
| import org.eclipse.ocl.pivot.TypedElement; |
| import org.eclipse.ocl.pivot.UnlimitedNaturalLiteralExp; |
| import org.eclipse.ocl.pivot.UnspecifiedValueExp; |
| import org.eclipse.ocl.pivot.ValueSpecification; |
| import org.eclipse.ocl.pivot.Variable; |
| import org.eclipse.ocl.pivot.VariableDeclaration; |
| import org.eclipse.ocl.pivot.VariableExp; |
| import org.eclipse.ocl.pivot.Vertex; |
| import org.eclipse.ocl.pivot.VoidType; |
| import org.eclipse.ocl.pivot.WildcardType; |
| import org.eclipse.ocl.pivot.utilities.MorePivotable; |
| import org.eclipse.ocl.pivot.utilities.Nameable; |
| import org.eclipse.ocl.pivot.utilities.Pivotable; |
| |
| /** |
| * <!-- 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 org.eclipse.ocl.pivot.PivotPackage |
| * @generated |
| */ |
| public class PivotAdapterFactory |
| extends AdapterFactoryImpl { |
| |
| /** |
| * The cached model package. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| protected static PivotPackage modelPackage; |
| |
| /** |
| * Creates an instance of the adapter factory. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public PivotAdapterFactory() { |
| if (modelPackage == null) |
| { |
| modelPackage = PivotPackage.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 PivotSwitch<@Nullable Adapter> modelSwitch = new PivotSwitch<@Nullable Adapter>() |
| { |
| @Override |
| public Adapter caseAnnotation(Annotation object) |
| { |
| return createAnnotationAdapter(); |
| } |
| @Override |
| public Adapter caseAnyType(AnyType object) |
| { |
| return createAnyTypeAdapter(); |
| } |
| @Override |
| public Adapter caseAssociationClass(AssociationClass object) |
| { |
| return createAssociationClassAdapter(); |
| } |
| @Override |
| public Adapter caseAssociationClassCallExp(AssociationClassCallExp object) |
| { |
| return createAssociationClassCallExpAdapter(); |
| } |
| @Override |
| public Adapter caseBagType(BagType object) |
| { |
| return createBagTypeAdapter(); |
| } |
| @Override |
| public Adapter caseBehavior(Behavior object) |
| { |
| return createBehaviorAdapter(); |
| } |
| @Override |
| public Adapter caseBooleanLiteralExp(BooleanLiteralExp object) |
| { |
| return createBooleanLiteralExpAdapter(); |
| } |
| @Override |
| public Adapter caseCallExp(CallExp object) |
| { |
| return createCallExpAdapter(); |
| } |
| @Override |
| public Adapter caseCallOperationAction(CallOperationAction object) |
| { |
| return createCallOperationActionAdapter(); |
| } |
| @Override |
| public Adapter caseClass(org.eclipse.ocl.pivot.Class object) |
| { |
| return createClassAdapter(); |
| } |
| @Override |
| public Adapter caseCollectionItem(CollectionItem object) |
| { |
| return createCollectionItemAdapter(); |
| } |
| @Override |
| public Adapter caseCollectionLiteralExp(CollectionLiteralExp object) |
| { |
| return createCollectionLiteralExpAdapter(); |
| } |
| @Override |
| public Adapter caseCollectionLiteralPart(CollectionLiteralPart object) |
| { |
| return createCollectionLiteralPartAdapter(); |
| } |
| @Override |
| public Adapter caseCollectionRange(CollectionRange object) |
| { |
| return createCollectionRangeAdapter(); |
| } |
| @Override |
| public Adapter caseCollectionType(CollectionType object) |
| { |
| return createCollectionTypeAdapter(); |
| } |
| @Override |
| public Adapter caseComment(Comment object) |
| { |
| return createCommentAdapter(); |
| } |
| @Override |
| public Adapter caseCompleteClass(CompleteClass object) |
| { |
| return createCompleteClassAdapter(); |
| } |
| @Override |
| public Adapter caseCompleteEnvironment(CompleteEnvironment object) |
| { |
| return createCompleteEnvironmentAdapter(); |
| } |
| @Override |
| public Adapter caseCompleteModel(CompleteModel object) |
| { |
| return createCompleteModelAdapter(); |
| } |
| @Override |
| public Adapter caseCompletePackage(CompletePackage object) |
| { |
| return createCompletePackageAdapter(); |
| } |
| @Override |
| public Adapter caseConnectionPointReference(ConnectionPointReference object) |
| { |
| return createConnectionPointReferenceAdapter(); |
| } |
| @Override |
| public Adapter caseConstraint(Constraint object) |
| { |
| return createConstraintAdapter(); |
| } |
| @Override |
| public Adapter caseDataType(DataType object) |
| { |
| return createDataTypeAdapter(); |
| } |
| @Override |
| public Adapter caseDetail(Detail object) |
| { |
| return createDetailAdapter(); |
| } |
| @Override |
| public Adapter caseDynamicBehavior(DynamicBehavior object) |
| { |
| return createDynamicBehaviorAdapter(); |
| } |
| @Override |
| public Adapter caseDynamicElement(DynamicElement object) |
| { |
| return createDynamicElementAdapter(); |
| } |
| @Override |
| public Adapter caseDynamicProperty(DynamicProperty object) |
| { |
| return createDynamicPropertyAdapter(); |
| } |
| @Override |
| public Adapter caseDynamicType(DynamicType object) |
| { |
| return createDynamicTypeAdapter(); |
| } |
| @Override |
| public Adapter caseDynamicValueSpecification(DynamicValueSpecification object) |
| { |
| return createDynamicValueSpecificationAdapter(); |
| } |
| @Override |
| public Adapter caseElement(Element object) |
| { |
| return createElementAdapter(); |
| } |
| @Override |
| public Adapter caseElementExtension(ElementExtension object) |
| { |
| return createElementExtensionAdapter(); |
| } |
| @Override |
| public Adapter caseEnumLiteralExp(EnumLiteralExp object) |
| { |
| return createEnumLiteralExpAdapter(); |
| } |
| @Override |
| public Adapter caseEnumeration(Enumeration object) |
| { |
| return createEnumerationAdapter(); |
| } |
| @Override |
| public Adapter caseEnumerationLiteral(EnumerationLiteral object) |
| { |
| return createEnumerationLiteralAdapter(); |
| } |
| @Override |
| public Adapter caseExpressionInOCL(ExpressionInOCL object) |
| { |
| return createExpressionInOCLAdapter(); |
| } |
| @Override |
| public Adapter caseFeature(Feature object) |
| { |
| return createFeatureAdapter(); |
| } |
| @Override |
| public Adapter caseFeatureCallExp(FeatureCallExp object) |
| { |
| return createFeatureCallExpAdapter(); |
| } |
| @Override |
| public Adapter caseFinalState(FinalState object) |
| { |
| return createFinalStateAdapter(); |
| } |
| @Override |
| public Adapter caseIfExp(IfExp object) |
| { |
| return createIfExpAdapter(); |
| } |
| @Override |
| public Adapter caseImport(Import object) |
| { |
| return createImportAdapter(); |
| } |
| @Override |
| public Adapter caseInstanceSpecification(InstanceSpecification object) |
| { |
| return createInstanceSpecificationAdapter(); |
| } |
| @Override |
| public Adapter caseIntegerLiteralExp(IntegerLiteralExp object) |
| { |
| return createIntegerLiteralExpAdapter(); |
| } |
| @Override |
| public Adapter caseInvalidLiteralExp(InvalidLiteralExp object) |
| { |
| return createInvalidLiteralExpAdapter(); |
| } |
| @Override |
| public Adapter caseInvalidType(InvalidType object) |
| { |
| return createInvalidTypeAdapter(); |
| } |
| @Override |
| public Adapter caseIterableType(IterableType object) |
| { |
| return createIterableTypeAdapter(); |
| } |
| @Override |
| public Adapter caseIterateExp(IterateExp object) |
| { |
| return createIterateExpAdapter(); |
| } |
| @Override |
| public Adapter caseIteration(Iteration object) |
| { |
| return createIterationAdapter(); |
| } |
| @Override |
| public Adapter caseIteratorExp(IteratorExp object) |
| { |
| return createIteratorExpAdapter(); |
| } |
| @Override |
| public Adapter caseIteratorVariable(IteratorVariable object) |
| { |
| return createIteratorVariableAdapter(); |
| } |
| @Override |
| public Adapter caseLambdaType(LambdaType object) |
| { |
| return createLambdaTypeAdapter(); |
| } |
| @Override |
| public Adapter caseLanguageExpression(LanguageExpression object) |
| { |
| return createLanguageExpressionAdapter(); |
| } |
| @Override |
| public Adapter caseLetExp(LetExp object) |
| { |
| return createLetExpAdapter(); |
| } |
| @Override |
| public Adapter caseLetVariable(LetVariable object) |
| { |
| return createLetVariableAdapter(); |
| } |
| @Override |
| public Adapter caseLibrary(Library object) |
| { |
| return createLibraryAdapter(); |
| } |
| @Override |
| public Adapter caseLiteralExp(LiteralExp object) |
| { |
| return createLiteralExpAdapter(); |
| } |
| @Override |
| public Adapter caseLoopExp(LoopExp object) |
| { |
| return createLoopExpAdapter(); |
| } |
| @Override |
| public Adapter caseMapLiteralExp(MapLiteralExp object) |
| { |
| return createMapLiteralExpAdapter(); |
| } |
| @Override |
| public Adapter caseMapLiteralPart(MapLiteralPart object) |
| { |
| return createMapLiteralPartAdapter(); |
| } |
| @Override |
| public Adapter caseMapType(MapType object) |
| { |
| return createMapTypeAdapter(); |
| } |
| @Override |
| public Adapter caseMessageExp(MessageExp object) |
| { |
| return createMessageExpAdapter(); |
| } |
| @Override |
| public Adapter caseMessageType(MessageType object) |
| { |
| return createMessageTypeAdapter(); |
| } |
| @Override |
| public Adapter caseModel(Model object) |
| { |
| return createModelAdapter(); |
| } |
| @Override |
| public Adapter caseMorePivotable(MorePivotable object) |
| { |
| return createMorePivotableAdapter(); |
| } |
| @Override |
| public Adapter caseNameable(Nameable object) |
| { |
| return createNameableAdapter(); |
| } |
| @Override |
| public Adapter caseNamedElement(NamedElement object) |
| { |
| return createNamedElementAdapter(); |
| } |
| @Override |
| public Adapter caseNamespace(Namespace object) |
| { |
| return createNamespaceAdapter(); |
| } |
| @Override |
| public Adapter caseNavigationCallExp(NavigationCallExp object) |
| { |
| return createNavigationCallExpAdapter(); |
| } |
| @Override |
| public Adapter caseNullLiteralExp(NullLiteralExp object) |
| { |
| return createNullLiteralExpAdapter(); |
| } |
| @Override |
| public Adapter caseNumericLiteralExp(NumericLiteralExp object) |
| { |
| return createNumericLiteralExpAdapter(); |
| } |
| @Override |
| public Adapter caseOCLExpression(OCLExpression object) |
| { |
| return createOCLExpressionAdapter(); |
| } |
| @Override |
| public Adapter caseOperation(Operation object) |
| { |
| return createOperationAdapter(); |
| } |
| @Override |
| public Adapter caseOperationCallExp(OperationCallExp object) |
| { |
| return createOperationCallExpAdapter(); |
| } |
| @Override |
| public Adapter caseOppositePropertyCallExp(OppositePropertyCallExp object) |
| { |
| return createOppositePropertyCallExpAdapter(); |
| } |
| @Override |
| public Adapter caseOrderedSetType(OrderedSetType object) |
| { |
| return createOrderedSetTypeAdapter(); |
| } |
| @Override |
| public Adapter caseOrphanCompletePackage(OrphanCompletePackage object) |
| { |
| return createOrphanCompletePackageAdapter(); |
| } |
| @Override |
| public Adapter casePackage(org.eclipse.ocl.pivot.Package object) |
| { |
| return createPackageAdapter(); |
| } |
| @Override |
| public Adapter caseParameter(Parameter object) |
| { |
| return createParameterAdapter(); |
| } |
| @Override |
| public Adapter caseParameterVariable(ParameterVariable object) |
| { |
| return createParameterVariableAdapter(); |
| } |
| @Override |
| public Adapter casePivotable(Pivotable object) |
| { |
| return createPivotableAdapter(); |
| } |
| @Override |
| public Adapter casePrecedence(Precedence object) |
| { |
| return createPrecedenceAdapter(); |
| } |
| @Override |
| public Adapter casePrimitiveCompletePackage(PrimitiveCompletePackage object) |
| { |
| return createPrimitiveCompletePackageAdapter(); |
| } |
| @Override |
| public Adapter casePrimitiveLiteralExp(PrimitiveLiteralExp object) |
| { |
| return createPrimitiveLiteralExpAdapter(); |
| } |
| @Override |
| public Adapter casePrimitiveType(PrimitiveType object) |
| { |
| return createPrimitiveTypeAdapter(); |
| } |
| @Override |
| public Adapter caseProfile(Profile object) |
| { |
| return createProfileAdapter(); |
| } |
| @Override |
| public Adapter caseProfileApplication(ProfileApplication object) |
| { |
| return createProfileApplicationAdapter(); |
| } |
| @Override |
| public Adapter caseProperty(Property object) |
| { |
| return createPropertyAdapter(); |
| } |
| @Override |
| public Adapter casePropertyCallExp(PropertyCallExp object) |
| { |
| return createPropertyCallExpAdapter(); |
| } |
| @Override |
| public Adapter casePseudostate(Pseudostate object) |
| { |
| return createPseudostateAdapter(); |
| } |
| @Override |
| public Adapter caseRealLiteralExp(RealLiteralExp object) |
| { |
| return createRealLiteralExpAdapter(); |
| } |
| @Override |
| public Adapter caseReferringElement(ReferringElement object) |
| { |
| return createReferringElementAdapter(); |
| } |
| @Override |
| public Adapter caseRegion(Region object) |
| { |
| return createRegionAdapter(); |
| } |
| @Override |
| public Adapter caseResultVariable(ResultVariable object) |
| { |
| return createResultVariableAdapter(); |
| } |
| @Override |
| public Adapter caseSelfType(SelfType object) |
| { |
| return createSelfTypeAdapter(); |
| } |
| @Override |
| public Adapter caseSendSignalAction(SendSignalAction object) |
| { |
| return createSendSignalActionAdapter(); |
| } |
| @Override |
| public Adapter caseSequenceType(SequenceType object) |
| { |
| return createSequenceTypeAdapter(); |
| } |
| @Override |
| public Adapter caseSetType(SetType object) |
| { |
| return createSetTypeAdapter(); |
| } |
| @Override |
| public Adapter caseShadowExp(ShadowExp object) |
| { |
| return createShadowExpAdapter(); |
| } |
| @Override |
| public Adapter caseShadowPart(ShadowPart object) |
| { |
| return createShadowPartAdapter(); |
| } |
| @Override |
| public Adapter caseSignal(Signal object) |
| { |
| return createSignalAdapter(); |
| } |
| @Override |
| public Adapter caseSlot(Slot object) |
| { |
| return createSlotAdapter(); |
| } |
| @Override |
| public Adapter caseStandardLibrary(StandardLibrary object) |
| { |
| return createStandardLibraryAdapter(); |
| } |
| @Override |
| public Adapter caseState(State object) |
| { |
| return createStateAdapter(); |
| } |
| @Override |
| public Adapter caseStateExp(StateExp object) |
| { |
| return createStateExpAdapter(); |
| } |
| @Override |
| public Adapter caseStateMachine(StateMachine object) |
| { |
| return createStateMachineAdapter(); |
| } |
| @Override |
| public Adapter caseStereotype(Stereotype object) |
| { |
| return createStereotypeAdapter(); |
| } |
| @Override |
| public Adapter caseStereotypeExtender(StereotypeExtender object) |
| { |
| return createStereotypeExtenderAdapter(); |
| } |
| @Override |
| public Adapter caseStringLiteralExp(StringLiteralExp object) |
| { |
| return createStringLiteralExpAdapter(); |
| } |
| @Override |
| public Adapter caseTemplateBinding(TemplateBinding object) |
| { |
| return createTemplateBindingAdapter(); |
| } |
| @Override |
| public Adapter caseTemplateParameter(TemplateParameter object) |
| { |
| return createTemplateParameterAdapter(); |
| } |
| @Override |
| public Adapter caseTemplateParameterSubstitution(TemplateParameterSubstitution object) |
| { |
| return createTemplateParameterSubstitutionAdapter(); |
| } |
| @Override |
| public Adapter caseTemplateSignature(TemplateSignature object) |
| { |
| return createTemplateSignatureAdapter(); |
| } |
| @Override |
| public Adapter caseTemplateableElement(TemplateableElement object) |
| { |
| return createTemplateableElementAdapter(); |
| } |
| @Override |
| public Adapter caseTransition(Transition object) |
| { |
| return createTransitionAdapter(); |
| } |
| @Override |
| public Adapter caseTrigger(Trigger object) |
| { |
| return createTriggerAdapter(); |
| } |
| @Override |
| public Adapter caseTupleLiteralExp(TupleLiteralExp object) |
| { |
| return createTupleLiteralExpAdapter(); |
| } |
| @Override |
| public Adapter caseTupleLiteralPart(TupleLiteralPart object) |
| { |
| return createTupleLiteralPartAdapter(); |
| } |
| @Override |
| public Adapter caseTupleType(TupleType object) |
| { |
| return createTupleTypeAdapter(); |
| } |
| @Override |
| public Adapter caseType(Type object) |
| { |
| return createTypeAdapter(); |
| } |
| @Override |
| public Adapter caseTypeExp(TypeExp object) |
| { |
| return createTypeExpAdapter(); |
| } |
| @Override |
| public Adapter caseTypedElement(TypedElement object) |
| { |
| return createTypedElementAdapter(); |
| } |
| @Override |
| public Adapter caseUnlimitedNaturalLiteralExp(UnlimitedNaturalLiteralExp object) |
| { |
| return createUnlimitedNaturalLiteralExpAdapter(); |
| } |
| @Override |
| public Adapter caseUnspecifiedValueExp(UnspecifiedValueExp object) |
| { |
| return createUnspecifiedValueExpAdapter(); |
| } |
| @Override |
| public Adapter caseValueSpecification(ValueSpecification object) |
| { |
| return createValueSpecificationAdapter(); |
| } |
| @Override |
| public Adapter caseVariable(Variable object) |
| { |
| return createVariableAdapter(); |
| } |
| @Override |
| public Adapter caseVariableDeclaration(VariableDeclaration object) |
| { |
| return createVariableDeclarationAdapter(); |
| } |
| @Override |
| public Adapter caseVariableExp(VariableExp object) |
| { |
| return createVariableExpAdapter(); |
| } |
| @Override |
| public Adapter caseVertex(Vertex object) |
| { |
| return createVertexAdapter(); |
| } |
| @Override |
| public Adapter caseVisitable(Visitable object) |
| { |
| return createVisitableAdapter(); |
| } |
| @Override |
| public Adapter caseVoidType(VoidType object) |
| { |
| return createVoidTypeAdapter(); |
| } |
| @Override |
| public Adapter caseWildcardType(WildcardType object) |
| { |
| return createWildcardTypeAdapter(); |
| } |
| @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 org.eclipse.ocl.pivot.Annotation <em>Annotation</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 org.eclipse.ocl.pivot.Annotation |
| * @generated |
| */ |
| public Adapter createAnnotationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.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 org.eclipse.ocl.pivot.NamedElement |
| * @generated |
| */ |
| public Adapter createNamedElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Element <em>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 org.eclipse.ocl.pivot.Element |
| * @generated |
| */ |
| public Adapter createElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.ElementExtension <em>Element Extension</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 org.eclipse.ocl.pivot.ElementExtension |
| * @generated |
| */ |
| public Adapter createElementExtensionAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.BagType <em>Bag Type</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 org.eclipse.ocl.pivot.BagType |
| * @generated |
| */ |
| public Adapter createBagTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Behavior <em>Behavior</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 org.eclipse.ocl.pivot.Behavior |
| * @generated |
| */ |
| public Adapter createBehaviorAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.CollectionType <em>Collection Type</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 org.eclipse.ocl.pivot.CollectionType |
| * @generated |
| */ |
| public Adapter createCollectionTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.DataType <em>Data Type</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 org.eclipse.ocl.pivot.DataType |
| * @generated |
| */ |
| public Adapter createDataTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.BooleanLiteralExp <em>Boolean Literal Exp</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 org.eclipse.ocl.pivot.BooleanLiteralExp |
| * @generated |
| */ |
| public Adapter createBooleanLiteralExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.PrimitiveLiteralExp <em>Primitive Literal Exp</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 org.eclipse.ocl.pivot.PrimitiveLiteralExp |
| * @generated |
| */ |
| public Adapter createPrimitiveLiteralExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.LiteralExp <em>Literal Exp</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 org.eclipse.ocl.pivot.LiteralExp |
| * @generated |
| */ |
| public Adapter createLiteralExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.CallOperationAction <em>Call Operation Action</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 org.eclipse.ocl.pivot.CallOperationAction |
| * @generated |
| */ |
| public Adapter createCallOperationActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.CollectionItem <em>Collection Item</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 org.eclipse.ocl.pivot.CollectionItem |
| * @generated |
| */ |
| public Adapter createCollectionItemAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.CollectionLiteralPart <em>Collection Literal Part</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 org.eclipse.ocl.pivot.CollectionLiteralPart |
| * @generated |
| */ |
| public Adapter createCollectionLiteralPartAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.CollectionLiteralExp <em>Collection Literal Exp</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 org.eclipse.ocl.pivot.CollectionLiteralExp |
| * @generated |
| */ |
| public Adapter createCollectionLiteralExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.CollectionRange <em>Collection Range</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 org.eclipse.ocl.pivot.CollectionRange |
| * @generated |
| */ |
| public Adapter createCollectionRangeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.EnumLiteralExp <em>Enum Literal Exp</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 org.eclipse.ocl.pivot.EnumLiteralExp |
| * @generated |
| */ |
| public Adapter createEnumLiteralExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.EnumerationLiteral <em>Enumeration Literal</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 org.eclipse.ocl.pivot.EnumerationLiteral |
| * @generated |
| */ |
| public Adapter createEnumerationLiteralAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.ExpressionInOCL <em>Expression In OCL</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 org.eclipse.ocl.pivot.ExpressionInOCL |
| * @generated |
| */ |
| public Adapter createExpressionInOCLAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Enumeration <em>Enumeration</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 org.eclipse.ocl.pivot.Enumeration |
| * @generated |
| */ |
| public Adapter createEnumerationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Feature <em>Feature</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 org.eclipse.ocl.pivot.Feature |
| * @generated |
| */ |
| public Adapter createFeatureAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.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 org.eclipse.ocl.pivot.Variable |
| * @generated |
| */ |
| public Adapter createVariableAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.IfExp <em>If Exp</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 org.eclipse.ocl.pivot.IfExp |
| * @generated |
| */ |
| public Adapter createIfExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Import <em>Import</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 org.eclipse.ocl.pivot.Import |
| * @generated |
| */ |
| public Adapter createImportAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.InstanceSpecification <em>Instance Specification</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 org.eclipse.ocl.pivot.InstanceSpecification |
| * @generated |
| */ |
| public Adapter createInstanceSpecificationAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.IntegerLiteralExp <em>Integer Literal Exp</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 org.eclipse.ocl.pivot.IntegerLiteralExp |
| * @generated |
| */ |
| public Adapter createIntegerLiteralExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.NumericLiteralExp <em>Numeric Literal Exp</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 org.eclipse.ocl.pivot.NumericLiteralExp |
| * @generated |
| */ |
| public Adapter createNumericLiteralExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.OCLExpression <em>OCL 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 org.eclipse.ocl.pivot.OCLExpression |
| * @generated |
| */ |
| public Adapter createOCLExpressionAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.InvalidLiteralExp <em>Invalid Literal Exp</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 org.eclipse.ocl.pivot.InvalidLiteralExp |
| * @generated |
| */ |
| public Adapter createInvalidLiteralExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.InvalidType <em>Invalid Type</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 org.eclipse.ocl.pivot.InvalidType |
| * @generated |
| */ |
| public Adapter createInvalidTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.IterableType <em>Iterable Type</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 org.eclipse.ocl.pivot.IterableType |
| * @generated |
| */ |
| public Adapter createIterableTypeAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.IterateExp <em>Iterate Exp</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 org.eclipse.ocl.pivot.IterateExp |
| * @generated |
| */ |
| public Adapter createIterateExpAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Iteration <em>Iteration</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 org.eclipse.ocl.pivot.Iteration |
| * @generated |
| */ |
| public Adapter createIterationAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.IteratorExp <em>Iterator Exp</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 org.eclipse.ocl.pivot.IteratorExp |
| * @generated |
| */ |
| public Adapter createIteratorExpAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.IteratorVariable <em>Iterator 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. |
| * @since 1.3 |
| * <!-- end-user-doc --> |
| * @return the new adapter. |
| * @see org.eclipse.ocl.pivot.IteratorVariable |
| * @generated |
| */ |
| public Adapter createIteratorVariableAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.LambdaType <em>Lambda Type</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 org.eclipse.ocl.pivot.LambdaType |
| * @generated |
| */ |
| public Adapter createLambdaTypeAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.LanguageExpression <em>Language 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 org.eclipse.ocl.pivot.LanguageExpression |
| * @generated |
| */ |
| public Adapter createLanguageExpressionAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.LetExp <em>Let Exp</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 org.eclipse.ocl.pivot.LetExp |
| * @generated |
| */ |
| public Adapter createLetExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.LetVariable <em>Let 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. |
| * @since 1.3 |
| * <!-- end-user-doc --> |
| * @return the new adapter. |
| * @see org.eclipse.ocl.pivot.LetVariable |
| * @generated |
| */ |
| public Adapter createLetVariableAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Library <em>Library</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 org.eclipse.ocl.pivot.Library |
| * @generated |
| */ |
| public Adapter createLibraryAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.LoopExp <em>Loop Exp</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 org.eclipse.ocl.pivot.LoopExp |
| * @generated |
| */ |
| public Adapter createLoopExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.MapLiteralExp <em>Map Literal Exp</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 org.eclipse.ocl.pivot.MapLiteralExp |
| * @generated |
| */ |
| public Adapter createMapLiteralExpAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.MapLiteralPart <em>Map Literal Part</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 org.eclipse.ocl.pivot.MapLiteralPart |
| * @generated |
| */ |
| public Adapter createMapLiteralPartAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.MapType <em>Map Type</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 org.eclipse.ocl.pivot.MapType |
| * @generated |
| */ |
| public Adapter createMapTypeAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.MessageExp <em>Message Exp</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 org.eclipse.ocl.pivot.MessageExp |
| * @generated |
| */ |
| public Adapter createMessageExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.SendSignalAction <em>Send Signal Action</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 org.eclipse.ocl.pivot.SendSignalAction |
| * @generated |
| */ |
| public Adapter createSendSignalActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Signal <em>Signal</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 org.eclipse.ocl.pivot.Signal |
| * @generated |
| */ |
| public Adapter createSignalAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Slot <em>Slot</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 org.eclipse.ocl.pivot.Slot |
| * @generated |
| */ |
| public Adapter createSlotAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.StandardLibrary <em>Standard Library</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 org.eclipse.ocl.pivot.StandardLibrary |
| * @generated |
| */ |
| public Adapter createStandardLibraryAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.MessageType <em>Message Type</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 org.eclipse.ocl.pivot.MessageType |
| * @generated |
| */ |
| public Adapter createMessageTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Model <em>Model</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 org.eclipse.ocl.pivot.Model |
| * @generated |
| */ |
| public Adapter createModelAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.utilities.MorePivotable <em>More Pivotable</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 org.eclipse.ocl.pivot.utilities.MorePivotable |
| * @generated |
| */ |
| public Adapter createMorePivotableAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.NullLiteralExp <em>Null Literal Exp</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 org.eclipse.ocl.pivot.NullLiteralExp |
| * @generated |
| */ |
| public Adapter createNullLiteralExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.OperationCallExp <em>Operation Call Exp</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 org.eclipse.ocl.pivot.OperationCallExp |
| * @generated |
| */ |
| public Adapter createOperationCallExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.OrderedSetType <em>Ordered Set Type</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 org.eclipse.ocl.pivot.OrderedSetType |
| * @generated |
| */ |
| public Adapter createOrderedSetTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.OrphanCompletePackage <em>Orphan Complete 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 org.eclipse.ocl.pivot.OrphanCompletePackage |
| * @generated |
| */ |
| public Adapter createOrphanCompletePackageAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.PrimitiveType <em>Primitive Type</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 org.eclipse.ocl.pivot.PrimitiveType |
| * @generated |
| */ |
| public Adapter createPrimitiveTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Profile <em>Profile</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 org.eclipse.ocl.pivot.Profile |
| * @generated |
| */ |
| public Adapter createProfileAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.ProfileApplication <em>Profile Application</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 org.eclipse.ocl.pivot.ProfileApplication |
| * @generated |
| */ |
| public Adapter createProfileApplicationAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.PropertyCallExp <em>Property Call Exp</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 org.eclipse.ocl.pivot.PropertyCallExp |
| * @generated |
| */ |
| public Adapter createPropertyCallExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Pseudostate <em>Pseudostate</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 org.eclipse.ocl.pivot.Pseudostate |
| * @generated |
| */ |
| public Adapter createPseudostateAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.RealLiteralExp <em>Real Literal Exp</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 org.eclipse.ocl.pivot.RealLiteralExp |
| * @generated |
| */ |
| public Adapter createRealLiteralExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.ReferringElement <em>Referring 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 org.eclipse.ocl.pivot.ReferringElement |
| * @generated |
| */ |
| public Adapter createReferringElementAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Region <em>Region</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 org.eclipse.ocl.pivot.Region |
| * @generated |
| */ |
| public Adapter createRegionAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.ResultVariable <em>Result 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. |
| * @since 1.3 |
| * <!-- end-user-doc --> |
| * @return the new adapter. |
| * @see org.eclipse.ocl.pivot.ResultVariable |
| * @generated |
| */ |
| public Adapter createResultVariableAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.SelfType <em>Self Type</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 org.eclipse.ocl.pivot.SelfType |
| * @generated |
| */ |
| public Adapter createSelfTypeAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.SequenceType <em>Sequence Type</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 org.eclipse.ocl.pivot.SequenceType |
| * @generated |
| */ |
| public Adapter createSequenceTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.SetType <em>Set Type</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 org.eclipse.ocl.pivot.SetType |
| * @generated |
| */ |
| public Adapter createSetTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.ShadowExp <em>Shadow Exp</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 org.eclipse.ocl.pivot.ShadowExp |
| * @generated |
| */ |
| public Adapter createShadowExpAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.ShadowPart <em>Shadow Part</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 org.eclipse.ocl.pivot.ShadowPart |
| * @generated |
| */ |
| public Adapter createShadowPartAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.State <em>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 org.eclipse.ocl.pivot.State |
| * @generated |
| */ |
| public Adapter createStateAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.StateExp <em>State Exp</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 org.eclipse.ocl.pivot.StateExp |
| * @generated |
| */ |
| public Adapter createStateExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.StateMachine <em>State Machine</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 org.eclipse.ocl.pivot.StateMachine |
| * @generated |
| */ |
| public Adapter createStateMachineAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.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 org.eclipse.ocl.pivot.Stereotype |
| * @generated |
| */ |
| public Adapter createStereotypeAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.StereotypeExtender <em>Stereotype Extender</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 org.eclipse.ocl.pivot.StereotypeExtender |
| * @generated |
| */ |
| public Adapter createStereotypeExtenderAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.StringLiteralExp <em>String Literal Exp</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 org.eclipse.ocl.pivot.StringLiteralExp |
| * @generated |
| */ |
| public Adapter createStringLiteralExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.TupleLiteralExp <em>Tuple Literal Exp</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 org.eclipse.ocl.pivot.TupleLiteralExp |
| * @generated |
| */ |
| public Adapter createTupleLiteralExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.TupleLiteralPart <em>Tuple Literal Part</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 org.eclipse.ocl.pivot.TupleLiteralPart |
| * @generated |
| */ |
| public Adapter createTupleLiteralPartAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.TupleType <em>Tuple Type</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 org.eclipse.ocl.pivot.TupleType |
| * @generated |
| */ |
| public Adapter createTupleTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.TypeExp <em>Type Exp</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 org.eclipse.ocl.pivot.TypeExp |
| * @generated |
| */ |
| public Adapter createTypeExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.UnlimitedNaturalLiteralExp <em>Unlimited Natural Literal Exp</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 org.eclipse.ocl.pivot.UnlimitedNaturalLiteralExp |
| * @generated |
| */ |
| public Adapter createUnlimitedNaturalLiteralExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.UnspecifiedValueExp <em>Unspecified Value Exp</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 org.eclipse.ocl.pivot.UnspecifiedValueExp |
| * @generated |
| */ |
| public Adapter createUnspecifiedValueExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.VariableExp <em>Variable Exp</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 org.eclipse.ocl.pivot.VariableExp |
| * @generated |
| */ |
| public Adapter createVariableExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Vertex <em>Vertex</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 org.eclipse.ocl.pivot.Vertex |
| * @generated |
| */ |
| public Adapter createVertexAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.util.Visitable <em>Visitable</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 org.eclipse.ocl.pivot.util.Visitable |
| * @generated |
| */ |
| public Adapter createVisitableAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.VoidType <em>Void Type</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 org.eclipse.ocl.pivot.VoidType |
| * @generated |
| */ |
| public Adapter createVoidTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.WildcardType <em>Wildcard Type</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 org.eclipse.ocl.pivot.WildcardType |
| * @generated |
| */ |
| public Adapter createWildcardTypeAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.utilities.Pivotable <em>Pivotable</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 org.eclipse.ocl.pivot.utilities.Pivotable |
| * @generated |
| */ |
| public Adapter createPivotableAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Class <em>Class</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 org.eclipse.ocl.pivot.Class |
| * @generated |
| */ |
| public Adapter createClassAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Type <em>Type</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 org.eclipse.ocl.pivot.Type |
| * @generated |
| */ |
| public Adapter createTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.TemplateableElement <em>Templateable 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 org.eclipse.ocl.pivot.TemplateableElement |
| * @generated |
| */ |
| public Adapter createTemplateableElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Transition <em>Transition</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 org.eclipse.ocl.pivot.Transition |
| * @generated |
| */ |
| public Adapter createTransitionAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Trigger <em>Trigger</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 org.eclipse.ocl.pivot.Trigger |
| * @generated |
| */ |
| public Adapter createTriggerAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.TemplateBinding <em>Template Binding</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 org.eclipse.ocl.pivot.TemplateBinding |
| * @generated |
| */ |
| public Adapter createTemplateBindingAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.TemplateSignature <em>Template Signature</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 org.eclipse.ocl.pivot.TemplateSignature |
| * @generated |
| */ |
| public Adapter createTemplateSignatureAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.TemplateParameter <em>Template Parameter</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 org.eclipse.ocl.pivot.TemplateParameter |
| * @generated |
| */ |
| public Adapter createTemplateParameterAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.TemplateParameterSubstitution <em>Template Parameter Substitution</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 org.eclipse.ocl.pivot.TemplateParameterSubstitution |
| * @generated |
| */ |
| public Adapter createTemplateParameterSubstitutionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.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 org.eclipse.ocl.pivot.Package |
| * @generated |
| */ |
| public Adapter createPackageAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Namespace <em>Namespace</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 org.eclipse.ocl.pivot.Namespace |
| * @generated |
| */ |
| public Adapter createNamespaceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Precedence <em>Precedence</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 org.eclipse.ocl.pivot.Precedence |
| * @generated |
| */ |
| public Adapter createPrecedenceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.PrimitiveCompletePackage <em>Primitive Complete 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 org.eclipse.ocl.pivot.PrimitiveCompletePackage |
| * @generated |
| */ |
| public Adapter createPrimitiveCompletePackageAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Property <em>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 org.eclipse.ocl.pivot.Property |
| * @generated |
| */ |
| public Adapter createPropertyAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.TypedElement <em>Typed 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 org.eclipse.ocl.pivot.TypedElement |
| * @generated |
| */ |
| public Adapter createTypedElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.AssociationClass <em>Association Class</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 org.eclipse.ocl.pivot.AssociationClass |
| * @generated |
| */ |
| public Adapter createAssociationClassAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Operation <em>Operation</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 org.eclipse.ocl.pivot.Operation |
| * @generated |
| */ |
| public Adapter createOperationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Parameter <em>Parameter</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 org.eclipse.ocl.pivot.Parameter |
| * @generated |
| */ |
| public Adapter createParameterAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.ParameterVariable <em>Parameter 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. |
| * @since 1.3 |
| * <!-- end-user-doc --> |
| * @return the new adapter. |
| * @see org.eclipse.ocl.pivot.ParameterVariable |
| * @generated |
| */ |
| public Adapter createParameterVariableAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.VariableDeclaration <em>Variable Declaration</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 org.eclipse.ocl.pivot.VariableDeclaration |
| * @generated |
| */ |
| public Adapter createVariableDeclarationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.OppositePropertyCallExp <em>Opposite Property Call Exp</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 org.eclipse.ocl.pivot.OppositePropertyCallExp |
| * @generated |
| */ |
| public Adapter createOppositePropertyCallExpAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Comment <em>Comment</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 org.eclipse.ocl.pivot.Comment |
| * @generated |
| */ |
| public Adapter createCommentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.CompleteClass <em>Complete Class</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 org.eclipse.ocl.pivot.CompleteClass |
| * @generated |
| */ |
| public Adapter createCompleteClassAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.CompleteEnvironment <em>Complete Environment</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 org.eclipse.ocl.pivot.CompleteEnvironment |
| * @generated |
| */ |
| public Adapter createCompleteEnvironmentAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.CompleteModel <em>Complete Model</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 org.eclipse.ocl.pivot.CompleteModel |
| * @generated |
| */ |
| public Adapter createCompleteModelAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.CompletePackage <em>Complete 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 org.eclipse.ocl.pivot.CompletePackage |
| * @generated |
| */ |
| public Adapter createCompletePackageAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.ConnectionPointReference <em>Connection Point 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 org.eclipse.ocl.pivot.ConnectionPointReference |
| * @generated |
| */ |
| public Adapter createConnectionPointReferenceAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.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 org.eclipse.ocl.pivot.Constraint |
| * @generated |
| */ |
| public Adapter createConstraintAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.ValueSpecification <em>Value Specification</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 org.eclipse.ocl.pivot.ValueSpecification |
| * @generated |
| */ |
| public Adapter createValueSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.utilities.Nameable <em>Nameable</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 org.eclipse.ocl.pivot.utilities.Nameable |
| * @generated |
| */ |
| public Adapter createNameableAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.Detail <em>Detail</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 org.eclipse.ocl.pivot.Detail |
| * @generated |
| */ |
| public Adapter createDetailAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.DynamicBehavior <em>Dynamic Behavior</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 org.eclipse.ocl.pivot.DynamicBehavior |
| * @generated |
| */ |
| public Adapter createDynamicBehaviorAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.DynamicElement <em>Dynamic 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 org.eclipse.ocl.pivot.DynamicElement |
| * @generated |
| */ |
| public Adapter createDynamicElementAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.DynamicProperty <em>Dynamic 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 org.eclipse.ocl.pivot.DynamicProperty |
| * @generated |
| */ |
| public Adapter createDynamicPropertyAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.DynamicType <em>Dynamic Type</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 org.eclipse.ocl.pivot.DynamicType |
| * @generated |
| */ |
| public Adapter createDynamicTypeAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.DynamicValueSpecification <em>Dynamic Value Specification</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 org.eclipse.ocl.pivot.DynamicValueSpecification |
| * @generated |
| */ |
| public Adapter createDynamicValueSpecificationAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.AnyType <em>Any Type</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 org.eclipse.ocl.pivot.AnyType |
| * @generated |
| */ |
| public Adapter createAnyTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.AssociationClassCallExp <em>Association Class Call Exp</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 org.eclipse.ocl.pivot.AssociationClassCallExp |
| * @generated |
| */ |
| public Adapter createAssociationClassCallExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.NavigationCallExp <em>Navigation Call Exp</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 org.eclipse.ocl.pivot.NavigationCallExp |
| * @generated |
| */ |
| public Adapter createNavigationCallExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.FeatureCallExp <em>Feature Call Exp</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 org.eclipse.ocl.pivot.FeatureCallExp |
| * @generated |
| */ |
| public Adapter createFeatureCallExpAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.FinalState <em>Final 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 org.eclipse.ocl.pivot.FinalState |
| * @generated |
| */ |
| public Adapter createFinalStateAdapter() |
| { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.ocl.pivot.CallExp <em>Call Exp</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 org.eclipse.ocl.pivot.CallExp |
| * @generated |
| */ |
| public Adapter createCallExpAdapter() { |
| 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; |
| } |
| |
| } //PivotAdapterFactory |