| /* |
| * Copyright (c) 2003, 2004 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Common Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/cpl-v10.html |
| * |
| * Contributors: |
| * IBM - Initial API and implementation |
| * |
| * $Id: UML2AdapterFactory.java,v 1.11 2004/06/02 05:02:27 khussey Exp $ |
| */ |
| package org.eclipse.uml2.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.EModelElement; |
| import org.eclipse.emf.ecore.EObject; |
| |
| import org.eclipse.uml2.Abstraction; |
| import org.eclipse.uml2.AcceptCallAction; |
| import org.eclipse.uml2.AcceptEventAction; |
| import org.eclipse.uml2.Action; |
| import org.eclipse.uml2.Activity; |
| import org.eclipse.uml2.ActivityEdge; |
| import org.eclipse.uml2.ActivityFinalNode; |
| import org.eclipse.uml2.ActivityGroup; |
| import org.eclipse.uml2.ActivityNode; |
| import org.eclipse.uml2.ActivityParameterNode; |
| import org.eclipse.uml2.ActivityPartition; |
| import org.eclipse.uml2.Actor; |
| import org.eclipse.uml2.AddStructuralFeatureValueAction; |
| import org.eclipse.uml2.AddVariableValueAction; |
| import org.eclipse.uml2.AnyTrigger; |
| import org.eclipse.uml2.ApplyFunctionAction; |
| import org.eclipse.uml2.Artifact; |
| import org.eclipse.uml2.Association; |
| import org.eclipse.uml2.AssociationClass; |
| import org.eclipse.uml2.Behavior; |
| import org.eclipse.uml2.BehavioralFeature; |
| import org.eclipse.uml2.BehavioredClassifier; |
| import org.eclipse.uml2.BroadcastSignalAction; |
| import org.eclipse.uml2.CallAction; |
| import org.eclipse.uml2.CallBehaviorAction; |
| import org.eclipse.uml2.CallOperationAction; |
| import org.eclipse.uml2.CallTrigger; |
| import org.eclipse.uml2.CentralBufferNode; |
| import org.eclipse.uml2.ChangeTrigger; |
| import org.eclipse.uml2.Classifier; |
| import org.eclipse.uml2.ClassifierTemplateParameter; |
| import org.eclipse.uml2.Clause; |
| import org.eclipse.uml2.ClearAssociationAction; |
| import org.eclipse.uml2.ClearStructuralFeatureAction; |
| import org.eclipse.uml2.ClearVariableAction; |
| import org.eclipse.uml2.Collaboration; |
| import org.eclipse.uml2.CollaborationOccurrence; |
| import org.eclipse.uml2.CombinedFragment; |
| import org.eclipse.uml2.Comment; |
| import org.eclipse.uml2.CommunicationPath; |
| import org.eclipse.uml2.Component; |
| import org.eclipse.uml2.ConditionalNode; |
| import org.eclipse.uml2.ConnectableElement; |
| import org.eclipse.uml2.ConnectableElementTemplateParameter; |
| import org.eclipse.uml2.ConnectionPointReference; |
| import org.eclipse.uml2.Connector; |
| import org.eclipse.uml2.ConnectorEnd; |
| import org.eclipse.uml2.Constraint; |
| import org.eclipse.uml2.Continuation; |
| import org.eclipse.uml2.ControlFlow; |
| import org.eclipse.uml2.ControlNode; |
| import org.eclipse.uml2.CreateLinkAction; |
| import org.eclipse.uml2.CreateLinkObjectAction; |
| import org.eclipse.uml2.CreateObjectAction; |
| import org.eclipse.uml2.DataStoreNode; |
| import org.eclipse.uml2.DataType; |
| import org.eclipse.uml2.DecisionNode; |
| import org.eclipse.uml2.Dependency; |
| import org.eclipse.uml2.DeployedArtifact; |
| import org.eclipse.uml2.Deployment; |
| import org.eclipse.uml2.DeploymentSpecification; |
| import org.eclipse.uml2.DeploymentTarget; |
| import org.eclipse.uml2.DestroyLinkAction; |
| import org.eclipse.uml2.DestroyObjectAction; |
| import org.eclipse.uml2.Device; |
| import org.eclipse.uml2.DirectedRelationship; |
| import org.eclipse.uml2.Duration; |
| import org.eclipse.uml2.DurationConstraint; |
| import org.eclipse.uml2.DurationInterval; |
| import org.eclipse.uml2.DurationObservationAction; |
| import org.eclipse.uml2.Element; |
| import org.eclipse.uml2.ElementImport; |
| import org.eclipse.uml2.EncapsulatedClassifier; |
| import org.eclipse.uml2.Enumeration; |
| import org.eclipse.uml2.EnumerationLiteral; |
| import org.eclipse.uml2.EventOccurrence; |
| import org.eclipse.uml2.ExceptionHandler; |
| import org.eclipse.uml2.ExecutableNode; |
| import org.eclipse.uml2.ExecutionEnvironment; |
| import org.eclipse.uml2.ExecutionOccurrence; |
| import org.eclipse.uml2.ExpansionNode; |
| import org.eclipse.uml2.ExpansionRegion; |
| import org.eclipse.uml2.Expression; |
| import org.eclipse.uml2.Extend; |
| import org.eclipse.uml2.Extension; |
| import org.eclipse.uml2.ExtensionEnd; |
| import org.eclipse.uml2.ExtensionPoint; |
| import org.eclipse.uml2.Feature; |
| import org.eclipse.uml2.FinalNode; |
| import org.eclipse.uml2.FinalState; |
| import org.eclipse.uml2.FlowFinalNode; |
| import org.eclipse.uml2.ForkNode; |
| import org.eclipse.uml2.Gate; |
| import org.eclipse.uml2.GeneralOrdering; |
| import org.eclipse.uml2.Generalization; |
| import org.eclipse.uml2.GeneralizationSet; |
| import org.eclipse.uml2.Implementation; |
| import org.eclipse.uml2.Include; |
| import org.eclipse.uml2.InformationFlow; |
| import org.eclipse.uml2.InformationItem; |
| import org.eclipse.uml2.InitialNode; |
| import org.eclipse.uml2.InputPin; |
| import org.eclipse.uml2.InstanceSpecification; |
| import org.eclipse.uml2.InstanceValue; |
| import org.eclipse.uml2.Interaction; |
| import org.eclipse.uml2.InteractionConstraint; |
| import org.eclipse.uml2.InteractionFragment; |
| import org.eclipse.uml2.InteractionOccurrence; |
| import org.eclipse.uml2.InteractionOperand; |
| import org.eclipse.uml2.Interface; |
| import org.eclipse.uml2.InterruptibleActivityRegion; |
| import org.eclipse.uml2.Interval; |
| import org.eclipse.uml2.IntervalConstraint; |
| import org.eclipse.uml2.InvocationAction; |
| import org.eclipse.uml2.JoinNode; |
| import org.eclipse.uml2.Lifeline; |
| import org.eclipse.uml2.LinkAction; |
| import org.eclipse.uml2.LinkEndCreationData; |
| import org.eclipse.uml2.LinkEndData; |
| import org.eclipse.uml2.LiteralBoolean; |
| import org.eclipse.uml2.LiteralInteger; |
| import org.eclipse.uml2.LiteralNull; |
| import org.eclipse.uml2.LiteralSpecification; |
| import org.eclipse.uml2.LiteralString; |
| import org.eclipse.uml2.LiteralUnlimitedNatural; |
| import org.eclipse.uml2.LoopNode; |
| import org.eclipse.uml2.Manifestation; |
| import org.eclipse.uml2.MergeNode; |
| import org.eclipse.uml2.Message; |
| import org.eclipse.uml2.MessageEnd; |
| import org.eclipse.uml2.MessageTrigger; |
| import org.eclipse.uml2.Model; |
| import org.eclipse.uml2.MultiplicityElement; |
| import org.eclipse.uml2.NamedElement; |
| import org.eclipse.uml2.Namespace; |
| import org.eclipse.uml2.Node; |
| import org.eclipse.uml2.ObjectFlow; |
| import org.eclipse.uml2.ObjectNode; |
| import org.eclipse.uml2.OpaqueExpression; |
| import org.eclipse.uml2.Operation; |
| import org.eclipse.uml2.OperationTemplateParameter; |
| import org.eclipse.uml2.OutputPin; |
| import org.eclipse.uml2.PackageImport; |
| import org.eclipse.uml2.PackageMerge; |
| import org.eclipse.uml2.PackageableElement; |
| import org.eclipse.uml2.Parameter; |
| import org.eclipse.uml2.ParameterSet; |
| import org.eclipse.uml2.ParameterableClassifier; |
| import org.eclipse.uml2.ParameterableElement; |
| import org.eclipse.uml2.PartDecomposition; |
| import org.eclipse.uml2.Permission; |
| import org.eclipse.uml2.Pin; |
| import org.eclipse.uml2.Port; |
| import org.eclipse.uml2.PrimitiveFunction; |
| import org.eclipse.uml2.PrimitiveType; |
| import org.eclipse.uml2.Profile; |
| import org.eclipse.uml2.ProfileApplication; |
| import org.eclipse.uml2.Property; |
| import org.eclipse.uml2.ProtocolConformance; |
| import org.eclipse.uml2.ProtocolStateMachine; |
| import org.eclipse.uml2.ProtocolTransition; |
| import org.eclipse.uml2.Pseudostate; |
| import org.eclipse.uml2.QualifierValue; |
| import org.eclipse.uml2.RaiseExceptionAction; |
| import org.eclipse.uml2.ReadExtentAction; |
| import org.eclipse.uml2.ReadIsClassifiedObjectAction; |
| import org.eclipse.uml2.ReadLinkAction; |
| import org.eclipse.uml2.ReadLinkObjectEndAction; |
| import org.eclipse.uml2.ReadLinkObjectEndQualifierAction; |
| import org.eclipse.uml2.ReadSelfAction; |
| import org.eclipse.uml2.ReadStructuralFeatureAction; |
| import org.eclipse.uml2.ReadVariableAction; |
| import org.eclipse.uml2.Realization; |
| import org.eclipse.uml2.Reception; |
| import org.eclipse.uml2.ReclassifyObjectAction; |
| import org.eclipse.uml2.RedefinableElement; |
| import org.eclipse.uml2.RedefinableTemplateSignature; |
| import org.eclipse.uml2.Region; |
| import org.eclipse.uml2.Relationship; |
| import org.eclipse.uml2.RemoveStructuralFeatureValueAction; |
| import org.eclipse.uml2.RemoveVariableValueAction; |
| import org.eclipse.uml2.ReplyAction; |
| import org.eclipse.uml2.SendObjectAction; |
| import org.eclipse.uml2.SendSignalAction; |
| import org.eclipse.uml2.Signal; |
| import org.eclipse.uml2.SignalTrigger; |
| import org.eclipse.uml2.Slot; |
| import org.eclipse.uml2.StartOwnedBehaviorAction; |
| import org.eclipse.uml2.State; |
| import org.eclipse.uml2.StateInvariant; |
| import org.eclipse.uml2.StateMachine; |
| import org.eclipse.uml2.Stereotype; |
| import org.eclipse.uml2.Stop; |
| import org.eclipse.uml2.StringExpression; |
| import org.eclipse.uml2.StructuralFeature; |
| import org.eclipse.uml2.StructuralFeatureAction; |
| import org.eclipse.uml2.StructuredActivityNode; |
| import org.eclipse.uml2.StructuredClassifier; |
| import org.eclipse.uml2.Substitution; |
| import org.eclipse.uml2.TemplateBinding; |
| import org.eclipse.uml2.TemplateParameter; |
| import org.eclipse.uml2.TemplateParameterSubstitution; |
| import org.eclipse.uml2.TemplateSignature; |
| import org.eclipse.uml2.TemplateableClassifier; |
| import org.eclipse.uml2.TemplateableElement; |
| import org.eclipse.uml2.TestIdentityAction; |
| import org.eclipse.uml2.TimeConstraint; |
| import org.eclipse.uml2.TimeExpression; |
| import org.eclipse.uml2.TimeInterval; |
| import org.eclipse.uml2.TimeObservationAction; |
| import org.eclipse.uml2.TimeTrigger; |
| import org.eclipse.uml2.Transition; |
| import org.eclipse.uml2.Trigger; |
| import org.eclipse.uml2.Type; |
| import org.eclipse.uml2.TypedElement; |
| import org.eclipse.uml2.UML2Package; |
| import org.eclipse.uml2.Usage; |
| import org.eclipse.uml2.UseCase; |
| import org.eclipse.uml2.ValuePin; |
| import org.eclipse.uml2.ValueSpecification; |
| import org.eclipse.uml2.Variable; |
| import org.eclipse.uml2.VariableAction; |
| import org.eclipse.uml2.Vertex; |
| import org.eclipse.uml2.WriteLinkAction; |
| import org.eclipse.uml2.WriteStructuralFeatureAction; |
| import org.eclipse.uml2.WriteVariableAction; |
| |
| /** |
| * <!-- 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.uml2.UML2Package |
| * @generated |
| */ |
| public class UML2AdapterFactory extends AdapterFactoryImpl { |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public static final String copyright = "Copyright (c) 2003, 2004 IBM Corporation and others."; //$NON-NLS-1$ |
| |
| /** |
| * The cached model package. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| protected static UML2Package modelPackage; |
| |
| /** |
| * Creates an instance of the adapter factory. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public UML2AdapterFactory() { |
| if (modelPackage == null) { |
| modelPackage = UML2Package.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 |
| */ |
| public boolean isFactoryForType(Object object) { |
| if (object == modelPackage) { |
| return true; |
| } |
| if (object instanceof EObject) { |
| return ((EObject)object).eClass().getEPackage() == modelPackage; |
| } |
| return false; |
| } |
| |
| /** |
| * The switch the delegates to the <code>createXXX</code> methods. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| protected UML2Switch modelSwitch = |
| new UML2Switch() { |
| public Object caseElement(Element object) { |
| return createElementAdapter(); |
| } |
| public Object caseMultiplicityElement(MultiplicityElement object) { |
| return createMultiplicityElementAdapter(); |
| } |
| public Object caseDirectedRelationship(DirectedRelationship object) { |
| return createDirectedRelationshipAdapter(); |
| } |
| public Object caseRelationship(Relationship object) { |
| return createRelationshipAdapter(); |
| } |
| public Object caseOpaqueExpression(OpaqueExpression object) { |
| return createOpaqueExpressionAdapter(); |
| } |
| public Object caseValueSpecification(ValueSpecification object) { |
| return createValueSpecificationAdapter(); |
| } |
| public Object caseExpression(Expression object) { |
| return createExpressionAdapter(); |
| } |
| public Object caseComment(Comment object) { |
| return createCommentAdapter(); |
| } |
| public Object caseNamedElement(NamedElement object) { |
| return createNamedElementAdapter(); |
| } |
| public Object caseNamespace(Namespace object) { |
| return createNamespaceAdapter(); |
| } |
| public Object caseClass(org.eclipse.uml2.Class object) { |
| return createClassAdapter(); |
| } |
| public Object caseType(Type object) { |
| return createTypeAdapter(); |
| } |
| public Object caseProperty(Property object) { |
| return createPropertyAdapter(); |
| } |
| public Object caseOperation(Operation object) { |
| return createOperationAdapter(); |
| } |
| public Object caseTypedElement(TypedElement object) { |
| return createTypedElementAdapter(); |
| } |
| public Object caseParameter(Parameter object) { |
| return createParameterAdapter(); |
| } |
| public Object casePackage(org.eclipse.uml2.Package object) { |
| return createPackageAdapter(); |
| } |
| public Object caseEnumeration(Enumeration object) { |
| return createEnumerationAdapter(); |
| } |
| public Object caseDataType(DataType object) { |
| return createDataTypeAdapter(); |
| } |
| public Object caseEnumerationLiteral(EnumerationLiteral object) { |
| return createEnumerationLiteralAdapter(); |
| } |
| public Object casePrimitiveType(PrimitiveType object) { |
| return createPrimitiveTypeAdapter(); |
| } |
| public Object caseLiteralBoolean(LiteralBoolean object) { |
| return createLiteralBooleanAdapter(); |
| } |
| public Object caseLiteralSpecification(LiteralSpecification object) { |
| return createLiteralSpecificationAdapter(); |
| } |
| public Object caseLiteralString(LiteralString object) { |
| return createLiteralStringAdapter(); |
| } |
| public Object caseLiteralNull(LiteralNull object) { |
| return createLiteralNullAdapter(); |
| } |
| public Object caseLiteralInteger(LiteralInteger object) { |
| return createLiteralIntegerAdapter(); |
| } |
| public Object caseLiteralUnlimitedNatural(LiteralUnlimitedNatural object) { |
| return createLiteralUnlimitedNaturalAdapter(); |
| } |
| public Object caseClassifier(Classifier object) { |
| return createClassifierAdapter(); |
| } |
| public Object caseFeature(Feature object) { |
| return createFeatureAdapter(); |
| } |
| public Object caseConstraint(Constraint object) { |
| return createConstraintAdapter(); |
| } |
| public Object caseBehavioralFeature(BehavioralFeature object) { |
| return createBehavioralFeatureAdapter(); |
| } |
| public Object caseStructuralFeature(StructuralFeature object) { |
| return createStructuralFeatureAdapter(); |
| } |
| public Object caseRedefinableElement(RedefinableElement object) { |
| return createRedefinableElementAdapter(); |
| } |
| public Object caseGeneralization(Generalization object) { |
| return createGeneralizationAdapter(); |
| } |
| public Object caseInstanceSpecification(InstanceSpecification object) { |
| return createInstanceSpecificationAdapter(); |
| } |
| public Object caseSlot(Slot object) { |
| return createSlotAdapter(); |
| } |
| public Object caseInstanceValue(InstanceValue object) { |
| return createInstanceValueAdapter(); |
| } |
| public Object casePackageableElement(PackageableElement object) { |
| return createPackageableElementAdapter(); |
| } |
| public Object caseElementImport(ElementImport object) { |
| return createElementImportAdapter(); |
| } |
| public Object casePackageImport(PackageImport object) { |
| return createPackageImportAdapter(); |
| } |
| public Object caseAssociation(Association object) { |
| return createAssociationAdapter(); |
| } |
| public Object casePackageMerge(PackageMerge object) { |
| return createPackageMergeAdapter(); |
| } |
| public Object caseStereotype(Stereotype object) { |
| return createStereotypeAdapter(); |
| } |
| public Object caseProfile(Profile object) { |
| return createProfileAdapter(); |
| } |
| public Object caseProfileApplication(ProfileApplication object) { |
| return createProfileApplicationAdapter(); |
| } |
| public Object caseExtension(Extension object) { |
| return createExtensionAdapter(); |
| } |
| public Object caseExtensionEnd(ExtensionEnd object) { |
| return createExtensionEndAdapter(); |
| } |
| public Object caseInformationItem(InformationItem object) { |
| return createInformationItemAdapter(); |
| } |
| public Object caseInformationFlow(InformationFlow object) { |
| return createInformationFlowAdapter(); |
| } |
| public Object caseBehavior(Behavior object) { |
| return createBehaviorAdapter(); |
| } |
| public Object caseBehavioredClassifier(BehavioredClassifier object) { |
| return createBehavioredClassifierAdapter(); |
| } |
| public Object caseActivity(Activity object) { |
| return createActivityAdapter(); |
| } |
| public Object caseGeneralizationSet(GeneralizationSet object) { |
| return createGeneralizationSetAdapter(); |
| } |
| public Object caseModel(Model object) { |
| return createModelAdapter(); |
| } |
| public Object caseAssociationClass(AssociationClass object) { |
| return createAssociationClassAdapter(); |
| } |
| public Object casePermission(Permission object) { |
| return createPermissionAdapter(); |
| } |
| public Object caseDependency(Dependency object) { |
| return createDependencyAdapter(); |
| } |
| public Object caseUsage(Usage object) { |
| return createUsageAdapter(); |
| } |
| public Object caseAbstraction(Abstraction object) { |
| return createAbstractionAdapter(); |
| } |
| public Object caseRealization(Realization object) { |
| return createRealizationAdapter(); |
| } |
| public Object caseSubstitution(Substitution object) { |
| return createSubstitutionAdapter(); |
| } |
| public Object caseConnectorEnd(ConnectorEnd object) { |
| return createConnectorEndAdapter(); |
| } |
| public Object caseConnectableElement(ConnectableElement object) { |
| return createConnectableElementAdapter(); |
| } |
| public Object caseConnector(Connector object) { |
| return createConnectorAdapter(); |
| } |
| public Object caseStructuredClassifier(StructuredClassifier object) { |
| return createStructuredClassifierAdapter(); |
| } |
| public Object caseActivityEdge(ActivityEdge object) { |
| return createActivityEdgeAdapter(); |
| } |
| public Object caseActivityGroup(ActivityGroup object) { |
| return createActivityGroupAdapter(); |
| } |
| public Object caseActivityNode(ActivityNode object) { |
| return createActivityNodeAdapter(); |
| } |
| public Object caseAction(Action object) { |
| return createActionAdapter(); |
| } |
| public Object caseObjectNode(ObjectNode object) { |
| return createObjectNodeAdapter(); |
| } |
| public Object caseControlNode(ControlNode object) { |
| return createControlNodeAdapter(); |
| } |
| public Object caseControlFlow(ControlFlow object) { |
| return createControlFlowAdapter(); |
| } |
| public Object caseObjectFlow(ObjectFlow object) { |
| return createObjectFlowAdapter(); |
| } |
| public Object caseInitialNode(InitialNode object) { |
| return createInitialNodeAdapter(); |
| } |
| public Object caseFinalNode(FinalNode object) { |
| return createFinalNodeAdapter(); |
| } |
| public Object caseActivityFinalNode(ActivityFinalNode object) { |
| return createActivityFinalNodeAdapter(); |
| } |
| public Object caseDecisionNode(DecisionNode object) { |
| return createDecisionNodeAdapter(); |
| } |
| public Object caseMergeNode(MergeNode object) { |
| return createMergeNodeAdapter(); |
| } |
| public Object caseExecutableNode(ExecutableNode object) { |
| return createExecutableNodeAdapter(); |
| } |
| public Object caseOutputPin(OutputPin object) { |
| return createOutputPinAdapter(); |
| } |
| public Object caseInputPin(InputPin object) { |
| return createInputPinAdapter(); |
| } |
| public Object casePin(Pin object) { |
| return createPinAdapter(); |
| } |
| public Object caseActivityParameterNode(ActivityParameterNode object) { |
| return createActivityParameterNodeAdapter(); |
| } |
| public Object caseValuePin(ValuePin object) { |
| return createValuePinAdapter(); |
| } |
| public Object caseArtifact(Artifact object) { |
| return createArtifactAdapter(); |
| } |
| public Object caseManifestation(Manifestation object) { |
| return createManifestationAdapter(); |
| } |
| public Object caseInterface(Interface object) { |
| return createInterfaceAdapter(); |
| } |
| public Object caseImplementation(Implementation object) { |
| return createImplementationAdapter(); |
| } |
| public Object caseActor(Actor object) { |
| return createActorAdapter(); |
| } |
| public Object caseExtend(Extend object) { |
| return createExtendAdapter(); |
| } |
| public Object caseUseCase(UseCase object) { |
| return createUseCaseAdapter(); |
| } |
| public Object caseExtensionPoint(ExtensionPoint object) { |
| return createExtensionPointAdapter(); |
| } |
| public Object caseInclude(Include object) { |
| return createIncludeAdapter(); |
| } |
| public Object caseTemplateSignature(TemplateSignature object) { |
| return createTemplateSignatureAdapter(); |
| } |
| public Object caseTemplateParameter(TemplateParameter object) { |
| return createTemplateParameterAdapter(); |
| } |
| public Object caseTemplateableElement(TemplateableElement object) { |
| return createTemplateableElementAdapter(); |
| } |
| public Object caseStringExpression(StringExpression object) { |
| return createStringExpressionAdapter(); |
| } |
| public Object caseParameterableElement(ParameterableElement object) { |
| return createParameterableElementAdapter(); |
| } |
| public Object caseTemplateBinding(TemplateBinding object) { |
| return createTemplateBindingAdapter(); |
| } |
| public Object caseTemplateParameterSubstitution(TemplateParameterSubstitution object) { |
| return createTemplateParameterSubstitutionAdapter(); |
| } |
| public Object caseCollaboration(Collaboration object) { |
| return createCollaborationAdapter(); |
| } |
| public Object caseOperationTemplateParameter(OperationTemplateParameter object) { |
| return createOperationTemplateParameterAdapter(); |
| } |
| public Object caseClassifierTemplateParameter(ClassifierTemplateParameter object) { |
| return createClassifierTemplateParameterAdapter(); |
| } |
| public Object caseParameterableClassifier(ParameterableClassifier object) { |
| return createParameterableClassifierAdapter(); |
| } |
| public Object caseRedefinableTemplateSignature(RedefinableTemplateSignature object) { |
| return createRedefinableTemplateSignatureAdapter(); |
| } |
| public Object caseTemplateableClassifier(TemplateableClassifier object) { |
| return createTemplateableClassifierAdapter(); |
| } |
| public Object caseConnectableElementTemplateParameter(ConnectableElementTemplateParameter object) { |
| return createConnectableElementTemplateParameterAdapter(); |
| } |
| public Object caseCollaborationOccurrence(CollaborationOccurrence object) { |
| return createCollaborationOccurrenceAdapter(); |
| } |
| public Object casePort(Port object) { |
| return createPortAdapter(); |
| } |
| public Object caseEncapsulatedClassifier(EncapsulatedClassifier object) { |
| return createEncapsulatedClassifierAdapter(); |
| } |
| public Object caseInteraction(Interaction object) { |
| return createInteractionAdapter(); |
| } |
| public Object caseInteractionFragment(InteractionFragment object) { |
| return createInteractionFragmentAdapter(); |
| } |
| public Object caseLifeline(Lifeline object) { |
| return createLifelineAdapter(); |
| } |
| public Object caseMessage(Message object) { |
| return createMessageAdapter(); |
| } |
| public Object caseGeneralOrdering(GeneralOrdering object) { |
| return createGeneralOrderingAdapter(); |
| } |
| public Object caseMessageEnd(MessageEnd object) { |
| return createMessageEndAdapter(); |
| } |
| public Object caseEventOccurrence(EventOccurrence object) { |
| return createEventOccurrenceAdapter(); |
| } |
| public Object caseExecutionOccurrence(ExecutionOccurrence object) { |
| return createExecutionOccurrenceAdapter(); |
| } |
| public Object caseStateInvariant(StateInvariant object) { |
| return createStateInvariantAdapter(); |
| } |
| public Object caseStop(Stop object) { |
| return createStopAdapter(); |
| } |
| public Object caseVariable(Variable object) { |
| return createVariableAdapter(); |
| } |
| public Object caseStructuredActivityNode(StructuredActivityNode object) { |
| return createStructuredActivityNodeAdapter(); |
| } |
| public Object caseConditionalNode(ConditionalNode object) { |
| return createConditionalNodeAdapter(); |
| } |
| public Object caseClause(Clause object) { |
| return createClauseAdapter(); |
| } |
| public Object caseLoopNode(LoopNode object) { |
| return createLoopNodeAdapter(); |
| } |
| public Object caseCallTrigger(CallTrigger object) { |
| return createCallTriggerAdapter(); |
| } |
| public Object caseMessageTrigger(MessageTrigger object) { |
| return createMessageTriggerAdapter(); |
| } |
| public Object caseChangeTrigger(ChangeTrigger object) { |
| return createChangeTriggerAdapter(); |
| } |
| public Object caseTrigger(Trigger object) { |
| return createTriggerAdapter(); |
| } |
| public Object caseReception(Reception object) { |
| return createReceptionAdapter(); |
| } |
| public Object caseSignal(Signal object) { |
| return createSignalAdapter(); |
| } |
| public Object caseSignalTrigger(SignalTrigger object) { |
| return createSignalTriggerAdapter(); |
| } |
| public Object caseTimeTrigger(TimeTrigger object) { |
| return createTimeTriggerAdapter(); |
| } |
| public Object caseAnyTrigger(AnyTrigger object) { |
| return createAnyTriggerAdapter(); |
| } |
| public Object caseExpansionNode(ExpansionNode object) { |
| return createExpansionNodeAdapter(); |
| } |
| public Object caseExpansionRegion(ExpansionRegion object) { |
| return createExpansionRegionAdapter(); |
| } |
| public Object caseExceptionHandler(ExceptionHandler object) { |
| return createExceptionHandlerAdapter(); |
| } |
| public Object caseForkNode(ForkNode object) { |
| return createForkNodeAdapter(); |
| } |
| public Object caseJoinNode(JoinNode object) { |
| return createJoinNodeAdapter(); |
| } |
| public Object caseFlowFinalNode(FlowFinalNode object) { |
| return createFlowFinalNodeAdapter(); |
| } |
| public Object caseCentralBufferNode(CentralBufferNode object) { |
| return createCentralBufferNodeAdapter(); |
| } |
| public Object caseActivityPartition(ActivityPartition object) { |
| return createActivityPartitionAdapter(); |
| } |
| public Object caseCreateObjectAction(CreateObjectAction object) { |
| return createCreateObjectActionAdapter(); |
| } |
| public Object caseDestroyObjectAction(DestroyObjectAction object) { |
| return createDestroyObjectActionAdapter(); |
| } |
| public Object caseTestIdentityAction(TestIdentityAction object) { |
| return createTestIdentityActionAdapter(); |
| } |
| public Object caseReadSelfAction(ReadSelfAction object) { |
| return createReadSelfActionAdapter(); |
| } |
| public Object caseStructuralFeatureAction(StructuralFeatureAction object) { |
| return createStructuralFeatureActionAdapter(); |
| } |
| public Object caseReadStructuralFeatureAction(ReadStructuralFeatureAction object) { |
| return createReadStructuralFeatureActionAdapter(); |
| } |
| public Object caseWriteStructuralFeatureAction(WriteStructuralFeatureAction object) { |
| return createWriteStructuralFeatureActionAdapter(); |
| } |
| public Object caseClearStructuralFeatureAction(ClearStructuralFeatureAction object) { |
| return createClearStructuralFeatureActionAdapter(); |
| } |
| public Object caseRemoveStructuralFeatureValueAction(RemoveStructuralFeatureValueAction object) { |
| return createRemoveStructuralFeatureValueActionAdapter(); |
| } |
| public Object caseAddStructuralFeatureValueAction(AddStructuralFeatureValueAction object) { |
| return createAddStructuralFeatureValueActionAdapter(); |
| } |
| public Object caseLinkAction(LinkAction object) { |
| return createLinkActionAdapter(); |
| } |
| public Object caseLinkEndData(LinkEndData object) { |
| return createLinkEndDataAdapter(); |
| } |
| public Object caseReadLinkAction(ReadLinkAction object) { |
| return createReadLinkActionAdapter(); |
| } |
| public Object caseLinkEndCreationData(LinkEndCreationData object) { |
| return createLinkEndCreationDataAdapter(); |
| } |
| public Object caseCreateLinkAction(CreateLinkAction object) { |
| return createCreateLinkActionAdapter(); |
| } |
| public Object caseWriteLinkAction(WriteLinkAction object) { |
| return createWriteLinkActionAdapter(); |
| } |
| public Object caseDestroyLinkAction(DestroyLinkAction object) { |
| return createDestroyLinkActionAdapter(); |
| } |
| public Object caseClearAssociationAction(ClearAssociationAction object) { |
| return createClearAssociationActionAdapter(); |
| } |
| public Object caseVariableAction(VariableAction object) { |
| return createVariableActionAdapter(); |
| } |
| public Object caseReadVariableAction(ReadVariableAction object) { |
| return createReadVariableActionAdapter(); |
| } |
| public Object caseWriteVariableAction(WriteVariableAction object) { |
| return createWriteVariableActionAdapter(); |
| } |
| public Object caseClearVariableAction(ClearVariableAction object) { |
| return createClearVariableActionAdapter(); |
| } |
| public Object caseAddVariableValueAction(AddVariableValueAction object) { |
| return createAddVariableValueActionAdapter(); |
| } |
| public Object caseRemoveVariableValueAction(RemoveVariableValueAction object) { |
| return createRemoveVariableValueActionAdapter(); |
| } |
| public Object caseApplyFunctionAction(ApplyFunctionAction object) { |
| return createApplyFunctionActionAdapter(); |
| } |
| public Object casePrimitiveFunction(PrimitiveFunction object) { |
| return createPrimitiveFunctionAdapter(); |
| } |
| public Object caseCallAction(CallAction object) { |
| return createCallActionAdapter(); |
| } |
| public Object caseInvocationAction(InvocationAction object) { |
| return createInvocationActionAdapter(); |
| } |
| public Object caseSendSignalAction(SendSignalAction object) { |
| return createSendSignalActionAdapter(); |
| } |
| public Object caseBroadcastSignalAction(BroadcastSignalAction object) { |
| return createBroadcastSignalActionAdapter(); |
| } |
| public Object caseSendObjectAction(SendObjectAction object) { |
| return createSendObjectActionAdapter(); |
| } |
| public Object caseCallOperationAction(CallOperationAction object) { |
| return createCallOperationActionAdapter(); |
| } |
| public Object caseCallBehaviorAction(CallBehaviorAction object) { |
| return createCallBehaviorActionAdapter(); |
| } |
| public Object caseStateMachine(StateMachine object) { |
| return createStateMachineAdapter(); |
| } |
| public Object caseRegion(Region object) { |
| return createRegionAdapter(); |
| } |
| public Object casePseudostate(Pseudostate object) { |
| return createPseudostateAdapter(); |
| } |
| public Object caseState(State object) { |
| return createStateAdapter(); |
| } |
| public Object caseVertex(Vertex object) { |
| return createVertexAdapter(); |
| } |
| public Object caseConnectionPointReference(ConnectionPointReference object) { |
| return createConnectionPointReferenceAdapter(); |
| } |
| public Object caseTransition(Transition object) { |
| return createTransitionAdapter(); |
| } |
| public Object caseFinalState(FinalState object) { |
| return createFinalStateAdapter(); |
| } |
| public Object caseInteractionOccurrence(InteractionOccurrence object) { |
| return createInteractionOccurrenceAdapter(); |
| } |
| public Object caseGate(Gate object) { |
| return createGateAdapter(); |
| } |
| public Object casePartDecomposition(PartDecomposition object) { |
| return createPartDecompositionAdapter(); |
| } |
| public Object caseInteractionOperand(InteractionOperand object) { |
| return createInteractionOperandAdapter(); |
| } |
| public Object caseInteractionConstraint(InteractionConstraint object) { |
| return createInteractionConstraintAdapter(); |
| } |
| public Object caseCombinedFragment(CombinedFragment object) { |
| return createCombinedFragmentAdapter(); |
| } |
| public Object caseContinuation(Continuation object) { |
| return createContinuationAdapter(); |
| } |
| public Object caseComponent(Component object) { |
| return createComponentAdapter(); |
| } |
| public Object caseProtocolConformance(ProtocolConformance object) { |
| return createProtocolConformanceAdapter(); |
| } |
| public Object caseProtocolStateMachine(ProtocolStateMachine object) { |
| return createProtocolStateMachineAdapter(); |
| } |
| public Object caseProtocolTransition(ProtocolTransition object) { |
| return createProtocolTransitionAdapter(); |
| } |
| public Object caseTimeExpression(TimeExpression object) { |
| return createTimeExpressionAdapter(); |
| } |
| public Object caseDuration(Duration object) { |
| return createDurationAdapter(); |
| } |
| public Object caseTimeObservationAction(TimeObservationAction object) { |
| return createTimeObservationActionAdapter(); |
| } |
| public Object caseDurationInterval(DurationInterval object) { |
| return createDurationIntervalAdapter(); |
| } |
| public Object caseInterval(Interval object) { |
| return createIntervalAdapter(); |
| } |
| public Object caseTimeConstraint(TimeConstraint object) { |
| return createTimeConstraintAdapter(); |
| } |
| public Object caseIntervalConstraint(IntervalConstraint object) { |
| return createIntervalConstraintAdapter(); |
| } |
| public Object caseTimeInterval(TimeInterval object) { |
| return createTimeIntervalAdapter(); |
| } |
| public Object caseDurationObservationAction(DurationObservationAction object) { |
| return createDurationObservationActionAdapter(); |
| } |
| public Object caseDurationConstraint(DurationConstraint object) { |
| return createDurationConstraintAdapter(); |
| } |
| public Object caseDataStoreNode(DataStoreNode object) { |
| return createDataStoreNodeAdapter(); |
| } |
| public Object caseInterruptibleActivityRegion(InterruptibleActivityRegion object) { |
| return createInterruptibleActivityRegionAdapter(); |
| } |
| public Object caseParameterSet(ParameterSet object) { |
| return createParameterSetAdapter(); |
| } |
| public Object caseDeployment(Deployment object) { |
| return createDeploymentAdapter(); |
| } |
| public Object caseDeployedArtifact(DeployedArtifact object) { |
| return createDeployedArtifactAdapter(); |
| } |
| public Object caseDeploymentTarget(DeploymentTarget object) { |
| return createDeploymentTargetAdapter(); |
| } |
| public Object caseNode(Node object) { |
| return createNodeAdapter(); |
| } |
| public Object caseDevice(Device object) { |
| return createDeviceAdapter(); |
| } |
| public Object caseExecutionEnvironment(ExecutionEnvironment object) { |
| return createExecutionEnvironmentAdapter(); |
| } |
| public Object caseCommunicationPath(CommunicationPath object) { |
| return createCommunicationPathAdapter(); |
| } |
| public Object caseReadExtentAction(ReadExtentAction object) { |
| return createReadExtentActionAdapter(); |
| } |
| public Object caseReclassifyObjectAction(ReclassifyObjectAction object) { |
| return createReclassifyObjectActionAdapter(); |
| } |
| public Object caseReadIsClassifiedObjectAction(ReadIsClassifiedObjectAction object) { |
| return createReadIsClassifiedObjectActionAdapter(); |
| } |
| public Object caseStartOwnedBehaviorAction(StartOwnedBehaviorAction object) { |
| return createStartOwnedBehaviorActionAdapter(); |
| } |
| public Object caseQualifierValue(QualifierValue object) { |
| return createQualifierValueAdapter(); |
| } |
| public Object caseReadLinkObjectEndAction(ReadLinkObjectEndAction object) { |
| return createReadLinkObjectEndActionAdapter(); |
| } |
| public Object caseReadLinkObjectEndQualifierAction(ReadLinkObjectEndQualifierAction object) { |
| return createReadLinkObjectEndQualifierActionAdapter(); |
| } |
| public Object caseCreateLinkObjectAction(CreateLinkObjectAction object) { |
| return createCreateLinkObjectActionAdapter(); |
| } |
| public Object caseAcceptEventAction(AcceptEventAction object) { |
| return createAcceptEventActionAdapter(); |
| } |
| public Object caseAcceptCallAction(AcceptCallAction object) { |
| return createAcceptCallActionAdapter(); |
| } |
| public Object caseReplyAction(ReplyAction object) { |
| return createReplyActionAdapter(); |
| } |
| public Object caseRaiseExceptionAction(RaiseExceptionAction object) { |
| return createRaiseExceptionActionAdapter(); |
| } |
| public Object caseDeploymentSpecification(DeploymentSpecification object) { |
| return createDeploymentSpecificationAdapter(); |
| } |
| public Object caseEModelElement(EModelElement object) { |
| return createEModelElementAdapter(); |
| } |
| public Object 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 |
| */ |
| public Adapter createAdapter(Notifier target) { |
| return (Adapter)modelSwitch.doSwitch((EObject)target); |
| } |
| |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Element |
| * @generated |
| */ |
| public Adapter createElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.MultiplicityElement <em>Multiplicity 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.uml2.MultiplicityElement |
| * @generated |
| */ |
| public Adapter createMultiplicityElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.DirectedRelationship <em>Directed Relationship</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.uml2.DirectedRelationship |
| * @generated |
| */ |
| public Adapter createDirectedRelationshipAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Relationship <em>Relationship</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.uml2.Relationship |
| * @generated |
| */ |
| public Adapter createRelationshipAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.NamedElement |
| * @generated |
| */ |
| public Adapter createNamedElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Namespace |
| * @generated |
| */ |
| public Adapter createNamespaceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.OpaqueExpression <em>Opaque 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.uml2.OpaqueExpression |
| * @generated |
| */ |
| public Adapter createOpaqueExpressionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.ValueSpecification |
| * @generated |
| */ |
| public Adapter createValueSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Expression <em>Expression</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| * <!-- end-user-doc --> |
| * @return the new adapter. |
| * @see org.eclipse.uml2.Expression |
| * @generated |
| */ |
| public Adapter createExpressionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Comment |
| * @generated |
| */ |
| public Adapter createCommentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Class |
| * @generated |
| */ |
| public Adapter createClassAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Type |
| * @generated |
| */ |
| public Adapter createTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Property |
| * @generated |
| */ |
| public Adapter createPropertyAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Operation |
| * @generated |
| */ |
| public Adapter createOperationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.TypedElement |
| * @generated |
| */ |
| public Adapter createTypedElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Parameter |
| * @generated |
| */ |
| public Adapter createParameterAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Package |
| * @generated |
| */ |
| public Adapter createPackageAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Enumeration |
| * @generated |
| */ |
| public Adapter createEnumerationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.DataType |
| * @generated |
| */ |
| public Adapter createDataTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.EnumerationLiteral |
| * @generated |
| */ |
| public Adapter createEnumerationLiteralAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.PrimitiveType |
| * @generated |
| */ |
| public Adapter createPrimitiveTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.LiteralBoolean <em>Literal Boolean</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.uml2.LiteralBoolean |
| * @generated |
| */ |
| public Adapter createLiteralBooleanAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.LiteralSpecification <em>Literal 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.uml2.LiteralSpecification |
| * @generated |
| */ |
| public Adapter createLiteralSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.LiteralString <em>Literal String</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.uml2.LiteralString |
| * @generated |
| */ |
| public Adapter createLiteralStringAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.LiteralNull <em>Literal Null</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.uml2.LiteralNull |
| * @generated |
| */ |
| public Adapter createLiteralNullAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.LiteralInteger <em>Literal Integer</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.uml2.LiteralInteger |
| * @generated |
| */ |
| public Adapter createLiteralIntegerAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.LiteralUnlimitedNatural <em>Literal Unlimited Natural</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.uml2.LiteralUnlimitedNatural |
| * @generated |
| */ |
| public Adapter createLiteralUnlimitedNaturalAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Constraint |
| * @generated |
| */ |
| public Adapter createConstraintAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Classifier <em>Classifier</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.uml2.Classifier |
| * @generated |
| */ |
| public Adapter createClassifierAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Feature |
| * @generated |
| */ |
| public Adapter createFeatureAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.BehavioralFeature <em>Behavioral 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.uml2.BehavioralFeature |
| * @generated |
| */ |
| public Adapter createBehavioralFeatureAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.StructuralFeature <em>Structural 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.uml2.StructuralFeature |
| * @generated |
| */ |
| public Adapter createStructuralFeatureAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.RedefinableElement <em>Redefinable 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.uml2.RedefinableElement |
| * @generated |
| */ |
| public Adapter createRedefinableElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.InstanceSpecification |
| * @generated |
| */ |
| public Adapter createInstanceSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Slot |
| * @generated |
| */ |
| public Adapter createSlotAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.InstanceValue <em>Instance Value</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| * <!-- end-user-doc --> |
| * @return the new adapter. |
| * @see org.eclipse.uml2.InstanceValue |
| * @generated |
| */ |
| public Adapter createInstanceValueAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Generalization <em>Generalization</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.uml2.Generalization |
| * @generated |
| */ |
| public Adapter createGeneralizationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.PackageableElement <em>Packageable 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.uml2.PackageableElement |
| * @generated |
| */ |
| public Adapter createPackageableElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ElementImport <em>Element 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.uml2.ElementImport |
| * @generated |
| */ |
| public Adapter createElementImportAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.PackageImport <em>Package 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.uml2.PackageImport |
| * @generated |
| */ |
| public Adapter createPackageImportAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Association <em>Association</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.uml2.Association |
| * @generated |
| */ |
| public Adapter createAssociationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.PackageMerge <em>Package Merge</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.uml2.PackageMerge |
| * @generated |
| */ |
| public Adapter createPackageMergeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Stereotype |
| * @generated |
| */ |
| public Adapter createStereotypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Profile |
| * @generated |
| */ |
| public Adapter createProfileAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.ProfileApplication |
| * @generated |
| */ |
| public Adapter createProfileApplicationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Extension <em>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.uml2.Extension |
| * @generated |
| */ |
| public Adapter createExtensionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ExtensionEnd <em>Extension End</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.uml2.ExtensionEnd |
| * @generated |
| */ |
| public Adapter createExtensionEndAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Model |
| * @generated |
| */ |
| public Adapter createModelAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.InformationItem <em>Information 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.uml2.InformationItem |
| * @generated |
| */ |
| public Adapter createInformationItemAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.InformationFlow <em>Information Flow</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.uml2.InformationFlow |
| * @generated |
| */ |
| public Adapter createInformationFlowAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.AssociationClass |
| * @generated |
| */ |
| public Adapter createAssociationClassAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Permission <em>Permission</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.uml2.Permission |
| * @generated |
| */ |
| public Adapter createPermissionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Dependency <em>Dependency</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.uml2.Dependency |
| * @generated |
| */ |
| public Adapter createDependencyAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Usage <em>Usage</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.uml2.Usage |
| * @generated |
| */ |
| public Adapter createUsageAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Abstraction <em>Abstraction</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.uml2.Abstraction |
| * @generated |
| */ |
| public Adapter createAbstractionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Realization <em>Realization</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.uml2.Realization |
| * @generated |
| */ |
| public Adapter createRealizationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Substitution <em>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.uml2.Substitution |
| * @generated |
| */ |
| public Adapter createSubstitutionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Behavior |
| * @generated |
| */ |
| public Adapter createBehaviorAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.BehavioredClassifier <em>Behaviored Classifier</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.uml2.BehavioredClassifier |
| * @generated |
| */ |
| public Adapter createBehavioredClassifierAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Activity <em>Activity</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.uml2.Activity |
| * @generated |
| */ |
| public Adapter createActivityAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.GeneralizationSet <em>Generalization Set</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| * <!-- end-user-doc --> |
| * @return the new adapter. |
| * @see org.eclipse.uml2.GeneralizationSet |
| * @generated |
| */ |
| public Adapter createGeneralizationSetAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Artifact <em>Artifact</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.uml2.Artifact |
| * @generated |
| */ |
| public Adapter createArtifactAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Manifestation <em>Manifestation</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.uml2.Manifestation |
| * @generated |
| */ |
| public Adapter createManifestationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ActivityEdge <em>Activity Edge</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.uml2.ActivityEdge |
| * @generated |
| */ |
| public Adapter createActivityEdgeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ActivityGroup <em>Activity Group</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.uml2.ActivityGroup |
| * @generated |
| */ |
| public Adapter createActivityGroupAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ActivityNode <em>Activity Node</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.uml2.ActivityNode |
| * @generated |
| */ |
| public Adapter createActivityNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Action <em>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.uml2.Action |
| * @generated |
| */ |
| public Adapter createActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ObjectNode <em>Object Node</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.uml2.ObjectNode |
| * @generated |
| */ |
| public Adapter createObjectNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ControlNode <em>Control Node</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.uml2.ControlNode |
| * @generated |
| */ |
| public Adapter createControlNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ControlFlow <em>Control Flow</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.uml2.ControlFlow |
| * @generated |
| */ |
| public Adapter createControlFlowAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ObjectFlow <em>Object Flow</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.uml2.ObjectFlow |
| * @generated |
| */ |
| public Adapter createObjectFlowAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.InitialNode <em>Initial Node</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.uml2.InitialNode |
| * @generated |
| */ |
| public Adapter createInitialNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.FinalNode <em>Final Node</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.uml2.FinalNode |
| * @generated |
| */ |
| public Adapter createFinalNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ActivityFinalNode <em>Activity Final Node</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.uml2.ActivityFinalNode |
| * @generated |
| */ |
| public Adapter createActivityFinalNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.DecisionNode <em>Decision Node</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.uml2.DecisionNode |
| * @generated |
| */ |
| public Adapter createDecisionNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.MergeNode <em>Merge Node</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.uml2.MergeNode |
| * @generated |
| */ |
| public Adapter createMergeNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ExecutableNode <em>Executable Node</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.uml2.ExecutableNode |
| * @generated |
| */ |
| public Adapter createExecutableNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.OutputPin <em>Output Pin</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.uml2.OutputPin |
| * @generated |
| */ |
| public Adapter createOutputPinAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.InputPin <em>Input Pin</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.uml2.InputPin |
| * @generated |
| */ |
| public Adapter createInputPinAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Pin <em>Pin</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.uml2.Pin |
| * @generated |
| */ |
| public Adapter createPinAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ActivityParameterNode <em>Activity Parameter Node</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.uml2.ActivityParameterNode |
| * @generated |
| */ |
| public Adapter createActivityParameterNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ValuePin <em>Value Pin</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.uml2.ValuePin |
| * @generated |
| */ |
| public Adapter createValuePinAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Interface <em>Interface</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.uml2.Interface |
| * @generated |
| */ |
| public Adapter createInterfaceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Implementation <em>Implementation</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.uml2.Implementation |
| * @generated |
| */ |
| public Adapter createImplementationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Actor <em>Actor</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.uml2.Actor |
| * @generated |
| */ |
| public Adapter createActorAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Extend <em>Extend</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.uml2.Extend |
| * @generated |
| */ |
| public Adapter createExtendAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.UseCase <em>Use Case</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.uml2.UseCase |
| * @generated |
| */ |
| public Adapter createUseCaseAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ExtensionPoint <em>Extension Point</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.uml2.ExtensionPoint |
| * @generated |
| */ |
| public Adapter createExtensionPointAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Include <em>Include</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.uml2.Include |
| * @generated |
| */ |
| public Adapter createIncludeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.CallTrigger <em>Call 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.uml2.CallTrigger |
| * @generated |
| */ |
| public Adapter createCallTriggerAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.MessageTrigger <em>Message 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.uml2.MessageTrigger |
| * @generated |
| */ |
| public Adapter createMessageTriggerAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ChangeTrigger <em>Change 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.uml2.ChangeTrigger |
| * @generated |
| */ |
| public Adapter createChangeTriggerAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Trigger |
| * @generated |
| */ |
| public Adapter createTriggerAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Reception <em>Reception</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.uml2.Reception |
| * @generated |
| */ |
| public Adapter createReceptionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Signal |
| * @generated |
| */ |
| public Adapter createSignalAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.SignalTrigger <em>Signal 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.uml2.SignalTrigger |
| * @generated |
| */ |
| public Adapter createSignalTriggerAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.TimeTrigger <em>Time 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.uml2.TimeTrigger |
| * @generated |
| */ |
| public Adapter createTimeTriggerAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.AnyTrigger <em>Any 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.uml2.AnyTrigger |
| * @generated |
| */ |
| public Adapter createAnyTriggerAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ConnectorEnd <em>Connector End</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.uml2.ConnectorEnd |
| * @generated |
| */ |
| public Adapter createConnectorEndAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ConnectableElement <em>Connectable 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.uml2.ConnectableElement |
| * @generated |
| */ |
| public Adapter createConnectableElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Connector <em>Connector</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.uml2.Connector |
| * @generated |
| */ |
| public Adapter createConnectorAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.StructuredClassifier <em>Structured Classifier</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.uml2.StructuredClassifier |
| * @generated |
| */ |
| public Adapter createStructuredClassifierAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Variable |
| * @generated |
| */ |
| public Adapter createVariableAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.StructuredActivityNode <em>Structured Activity Node</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.uml2.StructuredActivityNode |
| * @generated |
| */ |
| public Adapter createStructuredActivityNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ConditionalNode <em>Conditional Node</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.uml2.ConditionalNode |
| * @generated |
| */ |
| public Adapter createConditionalNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Clause <em>Clause</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.uml2.Clause |
| * @generated |
| */ |
| public Adapter createClauseAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.LoopNode <em>Loop Node</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.uml2.LoopNode |
| * @generated |
| */ |
| public Adapter createLoopNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.StateMachine |
| * @generated |
| */ |
| public Adapter createStateMachineAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Region |
| * @generated |
| */ |
| public Adapter createRegionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Pseudostate |
| * @generated |
| */ |
| public Adapter createPseudostateAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.State |
| * @generated |
| */ |
| public Adapter createStateAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Vertex |
| * @generated |
| */ |
| public Adapter createVertexAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.ConnectionPointReference |
| * @generated |
| */ |
| public Adapter createConnectionPointReferenceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.Transition |
| * @generated |
| */ |
| public Adapter createTransitionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.FinalState |
| * @generated |
| */ |
| public Adapter createFinalStateAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ExpansionNode <em>Expansion Node</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.uml2.ExpansionNode |
| * @generated |
| */ |
| public Adapter createExpansionNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ExpansionRegion <em>Expansion 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.uml2.ExpansionRegion |
| * @generated |
| */ |
| public Adapter createExpansionRegionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ExceptionHandler <em>Exception Handler</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.uml2.ExceptionHandler |
| * @generated |
| */ |
| public Adapter createExceptionHandlerAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Port <em>Port</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.uml2.Port |
| * @generated |
| */ |
| public Adapter createPortAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.EncapsulatedClassifier <em>Encapsulated Classifier</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.uml2.EncapsulatedClassifier |
| * @generated |
| */ |
| public Adapter createEncapsulatedClassifierAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.CreateObjectAction <em>Create Object 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.uml2.CreateObjectAction |
| * @generated |
| */ |
| public Adapter createCreateObjectActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.DestroyObjectAction <em>Destroy Object 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.uml2.DestroyObjectAction |
| * @generated |
| */ |
| public Adapter createDestroyObjectActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.TestIdentityAction <em>Test Identity 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.uml2.TestIdentityAction |
| * @generated |
| */ |
| public Adapter createTestIdentityActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ReadSelfAction <em>Read Self 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.uml2.ReadSelfAction |
| * @generated |
| */ |
| public Adapter createReadSelfActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.StructuralFeatureAction <em>Structural Feature 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.uml2.StructuralFeatureAction |
| * @generated |
| */ |
| public Adapter createStructuralFeatureActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ReadStructuralFeatureAction <em>Read Structural Feature 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.uml2.ReadStructuralFeatureAction |
| * @generated |
| */ |
| public Adapter createReadStructuralFeatureActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.WriteStructuralFeatureAction <em>Write Structural Feature 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.uml2.WriteStructuralFeatureAction |
| * @generated |
| */ |
| public Adapter createWriteStructuralFeatureActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ClearStructuralFeatureAction <em>Clear Structural Feature 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.uml2.ClearStructuralFeatureAction |
| * @generated |
| */ |
| public Adapter createClearStructuralFeatureActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.RemoveStructuralFeatureValueAction <em>Remove Structural Feature Value 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.uml2.RemoveStructuralFeatureValueAction |
| * @generated |
| */ |
| public Adapter createRemoveStructuralFeatureValueActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.AddStructuralFeatureValueAction <em>Add Structural Feature Value 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.uml2.AddStructuralFeatureValueAction |
| * @generated |
| */ |
| public Adapter createAddStructuralFeatureValueActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.LinkAction <em>Link 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.uml2.LinkAction |
| * @generated |
| */ |
| public Adapter createLinkActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.LinkEndData <em>Link End Data</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.uml2.LinkEndData |
| * @generated |
| */ |
| public Adapter createLinkEndDataAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ReadLinkAction <em>Read Link 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.uml2.ReadLinkAction |
| * @generated |
| */ |
| public Adapter createReadLinkActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.LinkEndCreationData <em>Link End Creation Data</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.uml2.LinkEndCreationData |
| * @generated |
| */ |
| public Adapter createLinkEndCreationDataAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.CreateLinkAction <em>Create Link 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.uml2.CreateLinkAction |
| * @generated |
| */ |
| public Adapter createCreateLinkActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.WriteLinkAction <em>Write Link 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.uml2.WriteLinkAction |
| * @generated |
| */ |
| public Adapter createWriteLinkActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.DestroyLinkAction <em>Destroy Link 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.uml2.DestroyLinkAction |
| * @generated |
| */ |
| public Adapter createDestroyLinkActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ClearAssociationAction <em>Clear Association 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.uml2.ClearAssociationAction |
| * @generated |
| */ |
| public Adapter createClearAssociationActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.VariableAction <em>Variable 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.uml2.VariableAction |
| * @generated |
| */ |
| public Adapter createVariableActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ReadVariableAction <em>Read Variable 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.uml2.ReadVariableAction |
| * @generated |
| */ |
| public Adapter createReadVariableActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.WriteVariableAction <em>Write Variable 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.uml2.WriteVariableAction |
| * @generated |
| */ |
| public Adapter createWriteVariableActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ClearVariableAction <em>Clear Variable 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.uml2.ClearVariableAction |
| * @generated |
| */ |
| public Adapter createClearVariableActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.AddVariableValueAction <em>Add Variable Value 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.uml2.AddVariableValueAction |
| * @generated |
| */ |
| public Adapter createAddVariableValueActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.RemoveVariableValueAction <em>Remove Variable Value 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.uml2.RemoveVariableValueAction |
| * @generated |
| */ |
| public Adapter createRemoveVariableValueActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ApplyFunctionAction <em>Apply Function 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.uml2.ApplyFunctionAction |
| * @generated |
| */ |
| public Adapter createApplyFunctionActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.PrimitiveFunction <em>Primitive Function</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.uml2.PrimitiveFunction |
| * @generated |
| */ |
| public Adapter createPrimitiveFunctionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.CallAction <em>Call 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.uml2.CallAction |
| * @generated |
| */ |
| public Adapter createCallActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.InvocationAction <em>Invocation 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.uml2.InvocationAction |
| * @generated |
| */ |
| public Adapter createInvocationActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.SendSignalAction |
| * @generated |
| */ |
| public Adapter createSendSignalActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.BroadcastSignalAction <em>Broadcast 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.uml2.BroadcastSignalAction |
| * @generated |
| */ |
| public Adapter createBroadcastSignalActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.SendObjectAction <em>Send Object 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.uml2.SendObjectAction |
| * @generated |
| */ |
| public Adapter createSendObjectActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.CallOperationAction |
| * @generated |
| */ |
| public Adapter createCallOperationActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.CallBehaviorAction <em>Call Behavior 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.uml2.CallBehaviorAction |
| * @generated |
| */ |
| public Adapter createCallBehaviorActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ForkNode <em>Fork Node</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.uml2.ForkNode |
| * @generated |
| */ |
| public Adapter createForkNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.JoinNode <em>Join Node</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.uml2.JoinNode |
| * @generated |
| */ |
| public Adapter createJoinNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.FlowFinalNode <em>Flow Final Node</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.uml2.FlowFinalNode |
| * @generated |
| */ |
| public Adapter createFlowFinalNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.CentralBufferNode <em>Central Buffer Node</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.uml2.CentralBufferNode |
| * @generated |
| */ |
| public Adapter createCentralBufferNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ActivityPartition <em>Activity Partition</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.uml2.ActivityPartition |
| * @generated |
| */ |
| public Adapter createActivityPartitionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.TemplateSignature |
| * @generated |
| */ |
| public Adapter createTemplateSignatureAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.TemplateParameter |
| * @generated |
| */ |
| public Adapter createTemplateParameterAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.TemplateableElement |
| * @generated |
| */ |
| public Adapter createTemplateableElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.StringExpression <em>String 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.uml2.StringExpression |
| * @generated |
| */ |
| public Adapter createStringExpressionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ParameterableElement <em>Parameterable 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.uml2.ParameterableElement |
| * @generated |
| */ |
| public Adapter createParameterableElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.TemplateBinding |
| * @generated |
| */ |
| public Adapter createTemplateBindingAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.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.uml2.TemplateParameterSubstitution |
| * @generated |
| */ |
| public Adapter createTemplateParameterSubstitutionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Collaboration <em>Collaboration</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.uml2.Collaboration |
| * @generated |
| */ |
| public Adapter createCollaborationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.OperationTemplateParameter <em>Operation 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.uml2.OperationTemplateParameter |
| * @generated |
| */ |
| public Adapter createOperationTemplateParameterAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ClassifierTemplateParameter <em>Classifier 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.uml2.ClassifierTemplateParameter |
| * @generated |
| */ |
| public Adapter createClassifierTemplateParameterAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ParameterableClassifier <em>Parameterable Classifier</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.uml2.ParameterableClassifier |
| * @generated |
| */ |
| public Adapter createParameterableClassifierAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.RedefinableTemplateSignature <em>Redefinable 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.uml2.RedefinableTemplateSignature |
| * @generated |
| */ |
| public Adapter createRedefinableTemplateSignatureAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.TemplateableClassifier <em>Templateable Classifier</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.uml2.TemplateableClassifier |
| * @generated |
| */ |
| public Adapter createTemplateableClassifierAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ConnectableElementTemplateParameter <em>Connectable Element 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.uml2.ConnectableElementTemplateParameter |
| * @generated |
| */ |
| public Adapter createConnectableElementTemplateParameterAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Interaction <em>Interaction</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.uml2.Interaction |
| * @generated |
| */ |
| public Adapter createInteractionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.InteractionFragment <em>Interaction Fragment</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.uml2.InteractionFragment |
| * @generated |
| */ |
| public Adapter createInteractionFragmentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Lifeline <em>Lifeline</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.uml2.Lifeline |
| * @generated |
| */ |
| public Adapter createLifelineAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Message <em>Message</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.uml2.Message |
| * @generated |
| */ |
| public Adapter createMessageAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.GeneralOrdering <em>General Ordering</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.uml2.GeneralOrdering |
| * @generated |
| */ |
| public Adapter createGeneralOrderingAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.MessageEnd <em>Message End</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.uml2.MessageEnd |
| * @generated |
| */ |
| public Adapter createMessageEndAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.EventOccurrence <em>Event Occurrence</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.uml2.EventOccurrence |
| * @generated |
| */ |
| public Adapter createEventOccurrenceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ExecutionOccurrence <em>Execution Occurrence</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.uml2.ExecutionOccurrence |
| * @generated |
| */ |
| public Adapter createExecutionOccurrenceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.StateInvariant <em>State Invariant</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.uml2.StateInvariant |
| * @generated |
| */ |
| public Adapter createStateInvariantAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Stop <em>Stop</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.uml2.Stop |
| * @generated |
| */ |
| public Adapter createStopAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.CollaborationOccurrence <em>Collaboration Occurrence</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.uml2.CollaborationOccurrence |
| * @generated |
| */ |
| public Adapter createCollaborationOccurrenceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.DataStoreNode <em>Data Store Node</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.uml2.DataStoreNode |
| * @generated |
| */ |
| public Adapter createDataStoreNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.InterruptibleActivityRegion <em>Interruptible Activity 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.uml2.InterruptibleActivityRegion |
| * @generated |
| */ |
| public Adapter createInterruptibleActivityRegionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ParameterSet <em>Parameter Set</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| * <!-- end-user-doc --> |
| * @return the new adapter. |
| * @see org.eclipse.uml2.ParameterSet |
| * @generated |
| */ |
| public Adapter createParameterSetAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ReadExtentAction <em>Read Extent 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.uml2.ReadExtentAction |
| * @generated |
| */ |
| public Adapter createReadExtentActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ReclassifyObjectAction <em>Reclassify Object 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.uml2.ReclassifyObjectAction |
| * @generated |
| */ |
| public Adapter createReclassifyObjectActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ReadIsClassifiedObjectAction <em>Read Is Classified Object 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.uml2.ReadIsClassifiedObjectAction |
| * @generated |
| */ |
| public Adapter createReadIsClassifiedObjectActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.StartOwnedBehaviorAction <em>Start Owned Behavior 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.uml2.StartOwnedBehaviorAction |
| * @generated |
| */ |
| public Adapter createStartOwnedBehaviorActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.QualifierValue <em>Qualifier Value</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| * <!-- end-user-doc --> |
| * @return the new adapter. |
| * @see org.eclipse.uml2.QualifierValue |
| * @generated |
| */ |
| public Adapter createQualifierValueAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ReadLinkObjectEndAction <em>Read Link Object End 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.uml2.ReadLinkObjectEndAction |
| * @generated |
| */ |
| public Adapter createReadLinkObjectEndActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ReadLinkObjectEndQualifierAction <em>Read Link Object End Qualifier 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.uml2.ReadLinkObjectEndQualifierAction |
| * @generated |
| */ |
| public Adapter createReadLinkObjectEndQualifierActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.CreateLinkObjectAction <em>Create Link Object 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.uml2.CreateLinkObjectAction |
| * @generated |
| */ |
| public Adapter createCreateLinkObjectActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.AcceptEventAction <em>Accept Event 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.uml2.AcceptEventAction |
| * @generated |
| */ |
| public Adapter createAcceptEventActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.AcceptCallAction <em>Accept Call 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.uml2.AcceptCallAction |
| * @generated |
| */ |
| public Adapter createAcceptCallActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ReplyAction <em>Reply 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.uml2.ReplyAction |
| * @generated |
| */ |
| public Adapter createReplyActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.RaiseExceptionAction <em>Raise Exception 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.uml2.RaiseExceptionAction |
| * @generated |
| */ |
| public Adapter createRaiseExceptionActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.TimeExpression <em>Time 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.uml2.TimeExpression |
| * @generated |
| */ |
| public Adapter createTimeExpressionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Duration <em>Duration</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.uml2.Duration |
| * @generated |
| */ |
| public Adapter createDurationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.TimeObservationAction <em>Time Observation 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.uml2.TimeObservationAction |
| * @generated |
| */ |
| public Adapter createTimeObservationActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.DurationInterval <em>Duration Interval</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.uml2.DurationInterval |
| * @generated |
| */ |
| public Adapter createDurationIntervalAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Interval <em>Interval</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.uml2.Interval |
| * @generated |
| */ |
| public Adapter createIntervalAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.TimeConstraint <em>Time 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.uml2.TimeConstraint |
| * @generated |
| */ |
| public Adapter createTimeConstraintAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.IntervalConstraint <em>Interval 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.uml2.IntervalConstraint |
| * @generated |
| */ |
| public Adapter createIntervalConstraintAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.TimeInterval <em>Time Interval</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.uml2.TimeInterval |
| * @generated |
| */ |
| public Adapter createTimeIntervalAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.DurationObservationAction <em>Duration Observation 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.uml2.DurationObservationAction |
| * @generated |
| */ |
| public Adapter createDurationObservationActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.DurationConstraint <em>Duration 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.uml2.DurationConstraint |
| * @generated |
| */ |
| public Adapter createDurationConstraintAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ProtocolConformance <em>Protocol Conformance</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.uml2.ProtocolConformance |
| * @generated |
| */ |
| public Adapter createProtocolConformanceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ProtocolStateMachine <em>Protocol 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.uml2.ProtocolStateMachine |
| * @generated |
| */ |
| public Adapter createProtocolStateMachineAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ProtocolTransition <em>Protocol 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.uml2.ProtocolTransition |
| * @generated |
| */ |
| public Adapter createProtocolTransitionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.InteractionOccurrence <em>Interaction Occurrence</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.uml2.InteractionOccurrence |
| * @generated |
| */ |
| public Adapter createInteractionOccurrenceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Gate <em>Gate</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.uml2.Gate |
| * @generated |
| */ |
| public Adapter createGateAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.PartDecomposition <em>Part Decomposition</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.uml2.PartDecomposition |
| * @generated |
| */ |
| public Adapter createPartDecompositionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.InteractionOperand <em>Interaction Operand</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.uml2.InteractionOperand |
| * @generated |
| */ |
| public Adapter createInteractionOperandAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.InteractionConstraint <em>Interaction 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.uml2.InteractionConstraint |
| * @generated |
| */ |
| public Adapter createInteractionConstraintAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.CombinedFragment <em>Combined Fragment</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.uml2.CombinedFragment |
| * @generated |
| */ |
| public Adapter createCombinedFragmentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Continuation <em>Continuation</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.uml2.Continuation |
| * @generated |
| */ |
| public Adapter createContinuationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Component <em>Component</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.uml2.Component |
| * @generated |
| */ |
| public Adapter createComponentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Deployment <em>Deployment</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.uml2.Deployment |
| * @generated |
| */ |
| public Adapter createDeploymentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.DeployedArtifact <em>Deployed Artifact</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.uml2.DeployedArtifact |
| * @generated |
| */ |
| public Adapter createDeployedArtifactAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.DeploymentTarget <em>Deployment Target</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.uml2.DeploymentTarget |
| * @generated |
| */ |
| public Adapter createDeploymentTargetAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Node <em>Node</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.uml2.Node |
| * @generated |
| */ |
| public Adapter createNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.Device <em>Device</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.uml2.Device |
| * @generated |
| */ |
| public Adapter createDeviceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.ExecutionEnvironment <em>Execution 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.uml2.ExecutionEnvironment |
| * @generated |
| */ |
| public Adapter createExecutionEnvironmentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.CommunicationPath <em>Communication Path</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.uml2.CommunicationPath |
| * @generated |
| */ |
| public Adapter createCommunicationPathAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.DeploymentSpecification <em>Deployment 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.uml2.DeploymentSpecification |
| * @generated |
| */ |
| public Adapter createDeploymentSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.emf.ecore.EModelElement <em>EModel 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.emf.ecore.EModelElement |
| * @generated |
| */ |
| public Adapter createEModelElementAdapter() { |
| 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; |
| } |
| |
| } //UML2AdapterFactory |
