| /* |
| * Copyright (c) 2005, 2018 IBM Corporation, Embarcadero Technologies, CEA, and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v2.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v20.html |
| * |
| * Contributors: |
| * IBM - initial API and implementation |
| * Kenn Hussey (Embarcadero Technologies) - 205188 |
| * Kenn Hussey (CEA) - 327039, 351774, 418466, 485756 |
| * Kenn Hussey - 535301 |
| * |
| */ |
| package org.eclipse.uml2.uml.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.uml.Abstraction; |
| import org.eclipse.uml2.uml.AcceptCallAction; |
| import org.eclipse.uml2.uml.AcceptEventAction; |
| import org.eclipse.uml2.uml.Action; |
| import org.eclipse.uml2.uml.ActionExecutionSpecification; |
| import org.eclipse.uml2.uml.ActionInputPin; |
| import org.eclipse.uml2.uml.Activity; |
| import org.eclipse.uml2.uml.ActivityContent; |
| import org.eclipse.uml2.uml.ActivityEdge; |
| import org.eclipse.uml2.uml.ActivityFinalNode; |
| import org.eclipse.uml2.uml.ActivityGroup; |
| import org.eclipse.uml2.uml.ActivityNode; |
| import org.eclipse.uml2.uml.ActivityParameterNode; |
| import org.eclipse.uml2.uml.ActivityPartition; |
| import org.eclipse.uml2.uml.Actor; |
| import org.eclipse.uml2.uml.AddStructuralFeatureValueAction; |
| import org.eclipse.uml2.uml.AddVariableValueAction; |
| import org.eclipse.uml2.uml.AnyReceiveEvent; |
| import org.eclipse.uml2.uml.Artifact; |
| import org.eclipse.uml2.uml.Association; |
| import org.eclipse.uml2.uml.AssociationClass; |
| import org.eclipse.uml2.uml.Behavior; |
| import org.eclipse.uml2.uml.BehaviorExecutionSpecification; |
| import org.eclipse.uml2.uml.BehavioralFeature; |
| import org.eclipse.uml2.uml.BehavioredClassifier; |
| import org.eclipse.uml2.uml.BroadcastSignalAction; |
| import org.eclipse.uml2.uml.CallAction; |
| import org.eclipse.uml2.uml.CallBehaviorAction; |
| import org.eclipse.uml2.uml.CallEvent; |
| import org.eclipse.uml2.uml.CallOperationAction; |
| import org.eclipse.uml2.uml.CentralBufferNode; |
| import org.eclipse.uml2.uml.ChangeEvent; |
| import org.eclipse.uml2.uml.Classifier; |
| import org.eclipse.uml2.uml.ClassifierTemplateParameter; |
| import org.eclipse.uml2.uml.Clause; |
| import org.eclipse.uml2.uml.ClearAssociationAction; |
| import org.eclipse.uml2.uml.ClearStructuralFeatureAction; |
| import org.eclipse.uml2.uml.ClearVariableAction; |
| import org.eclipse.uml2.uml.Collaboration; |
| import org.eclipse.uml2.uml.CollaborationUse; |
| import org.eclipse.uml2.uml.CombinedFragment; |
| import org.eclipse.uml2.uml.Comment; |
| import org.eclipse.uml2.uml.CommunicationPath; |
| import org.eclipse.uml2.uml.Component; |
| import org.eclipse.uml2.uml.ComponentRealization; |
| import org.eclipse.uml2.uml.ConditionalNode; |
| import org.eclipse.uml2.uml.ConnectableElement; |
| import org.eclipse.uml2.uml.ConnectableElementTemplateParameter; |
| import org.eclipse.uml2.uml.ConnectionPointReference; |
| import org.eclipse.uml2.uml.Connector; |
| import org.eclipse.uml2.uml.ConnectorEnd; |
| import org.eclipse.uml2.uml.ConsiderIgnoreFragment; |
| import org.eclipse.uml2.uml.Constraint; |
| import org.eclipse.uml2.uml.Continuation; |
| import org.eclipse.uml2.uml.ControlFlow; |
| import org.eclipse.uml2.uml.ControlNode; |
| import org.eclipse.uml2.uml.CreateLinkAction; |
| import org.eclipse.uml2.uml.CreateLinkObjectAction; |
| import org.eclipse.uml2.uml.CreateObjectAction; |
| import org.eclipse.uml2.uml.DataStoreNode; |
| import org.eclipse.uml2.uml.DataType; |
| import org.eclipse.uml2.uml.DecisionNode; |
| import org.eclipse.uml2.uml.Dependency; |
| import org.eclipse.uml2.uml.DeployedArtifact; |
| import org.eclipse.uml2.uml.Deployment; |
| import org.eclipse.uml2.uml.DeploymentSpecification; |
| import org.eclipse.uml2.uml.DeploymentTarget; |
| import org.eclipse.uml2.uml.DestroyLinkAction; |
| import org.eclipse.uml2.uml.DestroyObjectAction; |
| import org.eclipse.uml2.uml.DestructionOccurrenceSpecification; |
| import org.eclipse.uml2.uml.Device; |
| import org.eclipse.uml2.uml.DirectedRelationship; |
| import org.eclipse.uml2.uml.Duration; |
| import org.eclipse.uml2.uml.DurationConstraint; |
| import org.eclipse.uml2.uml.DurationInterval; |
| import org.eclipse.uml2.uml.DurationObservation; |
| import org.eclipse.uml2.uml.Element; |
| import org.eclipse.uml2.uml.ElementImport; |
| import org.eclipse.uml2.uml.EncapsulatedClassifier; |
| import org.eclipse.uml2.uml.Enumeration; |
| import org.eclipse.uml2.uml.EnumerationLiteral; |
| import org.eclipse.uml2.uml.Event; |
| import org.eclipse.uml2.uml.ExceptionHandler; |
| import org.eclipse.uml2.uml.ExecutableNode; |
| import org.eclipse.uml2.uml.ExecutionEnvironment; |
| import org.eclipse.uml2.uml.ExecutionOccurrenceSpecification; |
| import org.eclipse.uml2.uml.ExecutionSpecification; |
| import org.eclipse.uml2.uml.ExpansionNode; |
| import org.eclipse.uml2.uml.ExpansionRegion; |
| import org.eclipse.uml2.uml.Expression; |
| import org.eclipse.uml2.uml.Extend; |
| import org.eclipse.uml2.uml.Extension; |
| import org.eclipse.uml2.uml.ExtensionEnd; |
| import org.eclipse.uml2.uml.ExtensionPoint; |
| import org.eclipse.uml2.uml.Feature; |
| import org.eclipse.uml2.uml.FinalNode; |
| import org.eclipse.uml2.uml.FinalState; |
| import org.eclipse.uml2.uml.FlowFinalNode; |
| import org.eclipse.uml2.uml.ForkNode; |
| import org.eclipse.uml2.uml.FunctionBehavior; |
| import org.eclipse.uml2.uml.Gate; |
| import org.eclipse.uml2.uml.GeneralOrdering; |
| import org.eclipse.uml2.uml.Generalization; |
| import org.eclipse.uml2.uml.GeneralizationSet; |
| import org.eclipse.uml2.uml.Image; |
| import org.eclipse.uml2.uml.Include; |
| import org.eclipse.uml2.uml.InformationFlow; |
| import org.eclipse.uml2.uml.InformationItem; |
| import org.eclipse.uml2.uml.InitialNode; |
| import org.eclipse.uml2.uml.InputPin; |
| import org.eclipse.uml2.uml.InstanceSpecification; |
| import org.eclipse.uml2.uml.InstanceValue; |
| import org.eclipse.uml2.uml.Interaction; |
| import org.eclipse.uml2.uml.InteractionConstraint; |
| import org.eclipse.uml2.uml.InteractionFragment; |
| import org.eclipse.uml2.uml.InteractionOperand; |
| import org.eclipse.uml2.uml.InteractionUse; |
| import org.eclipse.uml2.uml.Interface; |
| import org.eclipse.uml2.uml.InterfaceRealization; |
| import org.eclipse.uml2.uml.InterruptibleActivityRegion; |
| import org.eclipse.uml2.uml.Interval; |
| import org.eclipse.uml2.uml.IntervalConstraint; |
| import org.eclipse.uml2.uml.InvocationAction; |
| import org.eclipse.uml2.uml.JoinNode; |
| import org.eclipse.uml2.uml.Lifeline; |
| import org.eclipse.uml2.uml.LinkAction; |
| import org.eclipse.uml2.uml.LinkEndCreationData; |
| import org.eclipse.uml2.uml.LinkEndData; |
| import org.eclipse.uml2.uml.LinkEndDestructionData; |
| import org.eclipse.uml2.uml.LiteralBoolean; |
| import org.eclipse.uml2.uml.LiteralInteger; |
| import org.eclipse.uml2.uml.LiteralNull; |
| import org.eclipse.uml2.uml.LiteralReal; |
| import org.eclipse.uml2.uml.LiteralSpecification; |
| import org.eclipse.uml2.uml.LiteralString; |
| import org.eclipse.uml2.uml.LiteralUnlimitedNatural; |
| import org.eclipse.uml2.uml.LoopNode; |
| import org.eclipse.uml2.uml.Manifestation; |
| import org.eclipse.uml2.uml.MergeNode; |
| import org.eclipse.uml2.uml.Message; |
| import org.eclipse.uml2.uml.MessageEnd; |
| import org.eclipse.uml2.uml.MessageEvent; |
| import org.eclipse.uml2.uml.MessageOccurrenceSpecification; |
| import org.eclipse.uml2.uml.Model; |
| import org.eclipse.uml2.uml.MultiplicityElement; |
| import org.eclipse.uml2.uml.NamedElement; |
| import org.eclipse.uml2.uml.Namespace; |
| import org.eclipse.uml2.uml.Node; |
| import org.eclipse.uml2.uml.ObjectFlow; |
| import org.eclipse.uml2.uml.ObjectNode; |
| import org.eclipse.uml2.uml.Observation; |
| import org.eclipse.uml2.uml.OccurrenceSpecification; |
| import org.eclipse.uml2.uml.OpaqueAction; |
| import org.eclipse.uml2.uml.OpaqueBehavior; |
| import org.eclipse.uml2.uml.OpaqueExpression; |
| import org.eclipse.uml2.uml.Operation; |
| import org.eclipse.uml2.uml.OperationTemplateParameter; |
| import org.eclipse.uml2.uml.OutputPin; |
| import org.eclipse.uml2.uml.PackageImport; |
| import org.eclipse.uml2.uml.PackageMerge; |
| import org.eclipse.uml2.uml.PackageableElement; |
| import org.eclipse.uml2.uml.Parameter; |
| import org.eclipse.uml2.uml.ParameterSet; |
| import org.eclipse.uml2.uml.ParameterableElement; |
| import org.eclipse.uml2.uml.PartDecomposition; |
| import org.eclipse.uml2.uml.Pin; |
| import org.eclipse.uml2.uml.Port; |
| import org.eclipse.uml2.uml.PrimitiveType; |
| import org.eclipse.uml2.uml.Profile; |
| import org.eclipse.uml2.uml.ProfileApplication; |
| import org.eclipse.uml2.uml.Property; |
| import org.eclipse.uml2.uml.ProtocolConformance; |
| import org.eclipse.uml2.uml.ProtocolStateMachine; |
| import org.eclipse.uml2.uml.ProtocolTransition; |
| import org.eclipse.uml2.uml.Pseudostate; |
| import org.eclipse.uml2.uml.QualifierValue; |
| import org.eclipse.uml2.uml.RaiseExceptionAction; |
| import org.eclipse.uml2.uml.ReadExtentAction; |
| import org.eclipse.uml2.uml.ReadIsClassifiedObjectAction; |
| import org.eclipse.uml2.uml.ReadLinkAction; |
| import org.eclipse.uml2.uml.ReadLinkObjectEndAction; |
| import org.eclipse.uml2.uml.ReadLinkObjectEndQualifierAction; |
| import org.eclipse.uml2.uml.ReadSelfAction; |
| import org.eclipse.uml2.uml.ReadStructuralFeatureAction; |
| import org.eclipse.uml2.uml.ReadVariableAction; |
| import org.eclipse.uml2.uml.Realization; |
| import org.eclipse.uml2.uml.Reception; |
| import org.eclipse.uml2.uml.ReclassifyObjectAction; |
| import org.eclipse.uml2.uml.RedefinableElement; |
| import org.eclipse.uml2.uml.RedefinableTemplateSignature; |
| import org.eclipse.uml2.uml.ReduceAction; |
| import org.eclipse.uml2.uml.Region; |
| import org.eclipse.uml2.uml.Relationship; |
| import org.eclipse.uml2.uml.RemoveStructuralFeatureValueAction; |
| import org.eclipse.uml2.uml.RemoveVariableValueAction; |
| import org.eclipse.uml2.uml.ReplyAction; |
| import org.eclipse.uml2.uml.SendObjectAction; |
| import org.eclipse.uml2.uml.SendSignalAction; |
| import org.eclipse.uml2.uml.SequenceNode; |
| import org.eclipse.uml2.uml.Signal; |
| import org.eclipse.uml2.uml.SignalEvent; |
| import org.eclipse.uml2.uml.Slot; |
| import org.eclipse.uml2.uml.StartClassifierBehaviorAction; |
| import org.eclipse.uml2.uml.StartObjectBehaviorAction; |
| import org.eclipse.uml2.uml.State; |
| import org.eclipse.uml2.uml.StateInvariant; |
| import org.eclipse.uml2.uml.StateMachine; |
| import org.eclipse.uml2.uml.Stereotype; |
| import org.eclipse.uml2.uml.StringExpression; |
| import org.eclipse.uml2.uml.StructuralFeature; |
| import org.eclipse.uml2.uml.StructuralFeatureAction; |
| import org.eclipse.uml2.uml.StructuredActivityNode; |
| import org.eclipse.uml2.uml.StructuredClassifier; |
| import org.eclipse.uml2.uml.Substitution; |
| import org.eclipse.uml2.uml.TemplateBinding; |
| import org.eclipse.uml2.uml.TemplateParameter; |
| import org.eclipse.uml2.uml.TemplateParameterSubstitution; |
| import org.eclipse.uml2.uml.TemplateSignature; |
| import org.eclipse.uml2.uml.TemplateableElement; |
| import org.eclipse.uml2.uml.TestIdentityAction; |
| import org.eclipse.uml2.uml.TimeConstraint; |
| import org.eclipse.uml2.uml.TimeEvent; |
| import org.eclipse.uml2.uml.TimeExpression; |
| import org.eclipse.uml2.uml.TimeInterval; |
| import org.eclipse.uml2.uml.TimeObservation; |
| import org.eclipse.uml2.uml.Transition; |
| import org.eclipse.uml2.uml.Trigger; |
| import org.eclipse.uml2.uml.Type; |
| import org.eclipse.uml2.uml.TypedElement; |
| import org.eclipse.uml2.uml.UMLPackage; |
| import org.eclipse.uml2.uml.UnmarshallAction; |
| import org.eclipse.uml2.uml.Usage; |
| import org.eclipse.uml2.uml.UseCase; |
| import org.eclipse.uml2.uml.ValuePin; |
| import org.eclipse.uml2.uml.ValueSpecification; |
| import org.eclipse.uml2.uml.ValueSpecificationAction; |
| import org.eclipse.uml2.uml.Variable; |
| import org.eclipse.uml2.uml.VariableAction; |
| import org.eclipse.uml2.uml.Vertex; |
| import org.eclipse.uml2.uml.WriteLinkAction; |
| import org.eclipse.uml2.uml.WriteStructuralFeatureAction; |
| import org.eclipse.uml2.uml.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.uml.UMLPackage |
| * @generated |
| */ |
| public class UMLAdapterFactory |
| extends AdapterFactoryImpl { |
| |
| /** |
| * The cached model package. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| protected static UMLPackage modelPackage; |
| |
| /** |
| * Creates an instance of the adapter factory. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| public UMLAdapterFactory() { |
| if (modelPackage == null) { |
| modelPackage = UMLPackage.eINSTANCE; |
| } |
| } |
| |
| /** |
| * Returns whether this factory is applicable for the type of the object. |
| * <!-- begin-user-doc --> |
| * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model. |
| * <!-- end-user-doc --> |
| * @return whether this factory is applicable for the type of the object. |
| * @generated |
| */ |
| @Override |
| public boolean isFactoryForType(Object object) { |
| if (object == modelPackage) { |
| return true; |
| } |
| if (object instanceof EObject) { |
| return ((EObject) object).eClass().getEPackage() == modelPackage; |
| } |
| return false; |
| } |
| |
| /** |
| * The switch that delegates to the <code>createXXX</code> methods. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| protected UMLSwitch<Adapter> modelSwitch = new UMLSwitch<Adapter>() { |
| |
| @Override |
| public Adapter caseActivityContent(ActivityContent object) { |
| return createActivityContentAdapter(); |
| } |
| |
| @Override |
| public Adapter caseActivity(Activity object) { |
| return createActivityAdapter(); |
| } |
| |
| @Override |
| public Adapter caseBehavior(Behavior object) { |
| return createBehaviorAdapter(); |
| } |
| |
| @Override |
| public Adapter caseClass(org.eclipse.uml2.uml.Class object) { |
| return createClassAdapter(); |
| } |
| |
| @Override |
| public Adapter caseBehavioredClassifier(BehavioredClassifier object) { |
| return createBehavioredClassifierAdapter(); |
| } |
| |
| @Override |
| public Adapter caseClassifier(Classifier object) { |
| return createClassifierAdapter(); |
| } |
| |
| @Override |
| public Adapter caseNamespace(Namespace object) { |
| return createNamespaceAdapter(); |
| } |
| |
| @Override |
| public Adapter caseNamedElement(NamedElement object) { |
| return createNamedElementAdapter(); |
| } |
| |
| @Override |
| public Adapter caseElement(Element object) { |
| return createElementAdapter(); |
| } |
| |
| @Override |
| public Adapter caseComment(Comment object) { |
| return createCommentAdapter(); |
| } |
| |
| @Override |
| public Adapter caseStereotype(Stereotype object) { |
| return createStereotypeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseImage(Image object) { |
| return createImageAdapter(); |
| } |
| |
| @Override |
| public Adapter caseProfile(Profile object) { |
| return createProfileAdapter(); |
| } |
| |
| @Override |
| public Adapter casePackage(org.eclipse.uml2.uml.Package object) { |
| return createPackageAdapter(); |
| } |
| |
| @Override |
| public Adapter casePackageableElement(PackageableElement object) { |
| return createPackageableElementAdapter(); |
| } |
| |
| @Override |
| public Adapter caseParameterableElement(ParameterableElement object) { |
| return createParameterableElementAdapter(); |
| } |
| |
| @Override |
| public Adapter caseTemplateParameter(TemplateParameter object) { |
| return createTemplateParameterAdapter(); |
| } |
| |
| @Override |
| public Adapter caseTemplateSignature(TemplateSignature object) { |
| return createTemplateSignatureAdapter(); |
| } |
| |
| @Override |
| public Adapter caseTemplateableElement(TemplateableElement object) { |
| return createTemplateableElementAdapter(); |
| } |
| |
| @Override |
| public Adapter caseTemplateBinding(TemplateBinding object) { |
| return createTemplateBindingAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDirectedRelationship(DirectedRelationship object) { |
| return createDirectedRelationshipAdapter(); |
| } |
| |
| @Override |
| public Adapter caseRelationship(Relationship object) { |
| return createRelationshipAdapter(); |
| } |
| |
| @Override |
| public Adapter caseTemplateParameterSubstitution( |
| TemplateParameterSubstitution object) { |
| return createTemplateParameterSubstitutionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseType(Type object) { |
| return createTypeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseAssociation(Association object) { |
| return createAssociationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseProperty(Property object) { |
| return createPropertyAdapter(); |
| } |
| |
| @Override |
| public Adapter caseConnectableElement(ConnectableElement object) { |
| return createConnectableElementAdapter(); |
| } |
| |
| @Override |
| public Adapter caseTypedElement(TypedElement object) { |
| return createTypedElementAdapter(); |
| } |
| |
| @Override |
| public Adapter caseConnectorEnd(ConnectorEnd object) { |
| return createConnectorEndAdapter(); |
| } |
| |
| @Override |
| public Adapter caseMultiplicityElement(MultiplicityElement object) { |
| return createMultiplicityElementAdapter(); |
| } |
| |
| @Override |
| public Adapter caseValueSpecification(ValueSpecification object) { |
| return createValueSpecificationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseConnectableElementTemplateParameter( |
| ConnectableElementTemplateParameter object) { |
| return createConnectableElementTemplateParameterAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDeploymentTarget(DeploymentTarget object) { |
| return createDeploymentTargetAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDeployment(Deployment object) { |
| return createDeploymentAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDependency(Dependency object) { |
| return createDependencyAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDeploymentSpecification( |
| DeploymentSpecification object) { |
| return createDeploymentSpecificationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseArtifact(Artifact object) { |
| return createArtifactAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDeployedArtifact(DeployedArtifact object) { |
| return createDeployedArtifactAdapter(); |
| } |
| |
| @Override |
| public Adapter caseManifestation(Manifestation object) { |
| return createManifestationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseAbstraction(Abstraction object) { |
| return createAbstractionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseOpaqueExpression(OpaqueExpression object) { |
| return createOpaqueExpressionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseParameter(Parameter object) { |
| return createParameterAdapter(); |
| } |
| |
| @Override |
| public Adapter caseOperation(Operation object) { |
| return createOperationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseBehavioralFeature(BehavioralFeature object) { |
| return createBehavioralFeatureAdapter(); |
| } |
| |
| @Override |
| public Adapter caseFeature(Feature object) { |
| return createFeatureAdapter(); |
| } |
| |
| @Override |
| public Adapter caseRedefinableElement(RedefinableElement object) { |
| return createRedefinableElementAdapter(); |
| } |
| |
| @Override |
| public Adapter caseParameterSet(ParameterSet object) { |
| return createParameterSetAdapter(); |
| } |
| |
| @Override |
| public Adapter caseConstraint(Constraint object) { |
| return createConstraintAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDataType(DataType object) { |
| return createDataTypeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInterface(Interface object) { |
| return createInterfaceAdapter(); |
| } |
| |
| @Override |
| public Adapter caseReception(Reception object) { |
| return createReceptionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseSignal(Signal object) { |
| return createSignalAdapter(); |
| } |
| |
| @Override |
| public Adapter caseProtocolStateMachine(ProtocolStateMachine object) { |
| return createProtocolStateMachineAdapter(); |
| } |
| |
| @Override |
| public Adapter caseStateMachine(StateMachine object) { |
| return createStateMachineAdapter(); |
| } |
| |
| @Override |
| public Adapter casePseudostate(Pseudostate object) { |
| return createPseudostateAdapter(); |
| } |
| |
| @Override |
| public Adapter caseVertex(Vertex object) { |
| return createVertexAdapter(); |
| } |
| |
| @Override |
| public Adapter caseRegion(Region object) { |
| return createRegionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseState(State object) { |
| return createStateAdapter(); |
| } |
| |
| @Override |
| public Adapter caseConnectionPointReference( |
| ConnectionPointReference object) { |
| return createConnectionPointReferenceAdapter(); |
| } |
| |
| @Override |
| public Adapter caseTrigger(Trigger object) { |
| return createTriggerAdapter(); |
| } |
| |
| @Override |
| public Adapter caseEvent(Event object) { |
| return createEventAdapter(); |
| } |
| |
| @Override |
| public Adapter casePort(Port object) { |
| return createPortAdapter(); |
| } |
| |
| @Override |
| public Adapter caseTransition(Transition object) { |
| return createTransitionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseProtocolConformance(ProtocolConformance object) { |
| return createProtocolConformanceAdapter(); |
| } |
| |
| @Override |
| public Adapter caseOperationTemplateParameter( |
| OperationTemplateParameter object) { |
| return createOperationTemplateParameterAdapter(); |
| } |
| |
| @Override |
| public Adapter caseStructuralFeature(StructuralFeature object) { |
| return createStructuralFeatureAdapter(); |
| } |
| |
| @Override |
| public Adapter casePackageMerge(PackageMerge object) { |
| return createPackageMergeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseProfileApplication(ProfileApplication object) { |
| return createProfileApplicationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseEnumeration(Enumeration object) { |
| return createEnumerationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseEnumerationLiteral(EnumerationLiteral object) { |
| return createEnumerationLiteralAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInstanceSpecification(InstanceSpecification object) { |
| return createInstanceSpecificationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseSlot(Slot object) { |
| return createSlotAdapter(); |
| } |
| |
| @Override |
| public Adapter casePrimitiveType(PrimitiveType object) { |
| return createPrimitiveTypeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseElementImport(ElementImport object) { |
| return createElementImportAdapter(); |
| } |
| |
| @Override |
| public Adapter casePackageImport(PackageImport object) { |
| return createPackageImportAdapter(); |
| } |
| |
| @Override |
| public Adapter caseExtension(Extension object) { |
| return createExtensionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseExtensionEnd(ExtensionEnd object) { |
| return createExtensionEndAdapter(); |
| } |
| |
| @Override |
| public Adapter caseModel(Model object) { |
| return createModelAdapter(); |
| } |
| |
| @Override |
| public Adapter caseStringExpression(StringExpression object) { |
| return createStringExpressionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseExpression(Expression object) { |
| return createExpressionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseUsage(Usage object) { |
| return createUsageAdapter(); |
| } |
| |
| @Override |
| public Adapter caseCollaborationUse(CollaborationUse object) { |
| return createCollaborationUseAdapter(); |
| } |
| |
| @Override |
| public Adapter caseCollaboration(Collaboration object) { |
| return createCollaborationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseStructuredClassifier(StructuredClassifier object) { |
| return createStructuredClassifierAdapter(); |
| } |
| |
| @Override |
| public Adapter caseConnector(Connector object) { |
| return createConnectorAdapter(); |
| } |
| |
| @Override |
| public Adapter caseGeneralization(Generalization object) { |
| return createGeneralizationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseGeneralizationSet(GeneralizationSet object) { |
| return createGeneralizationSetAdapter(); |
| } |
| |
| @Override |
| public Adapter caseRedefinableTemplateSignature( |
| RedefinableTemplateSignature object) { |
| return createRedefinableTemplateSignatureAdapter(); |
| } |
| |
| @Override |
| public Adapter caseUseCase(UseCase object) { |
| return createUseCaseAdapter(); |
| } |
| |
| @Override |
| public Adapter caseExtend(Extend object) { |
| return createExtendAdapter(); |
| } |
| |
| @Override |
| public Adapter caseExtensionPoint(ExtensionPoint object) { |
| return createExtensionPointAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInclude(Include object) { |
| return createIncludeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseSubstitution(Substitution object) { |
| return createSubstitutionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseRealization(Realization object) { |
| return createRealizationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseClassifierTemplateParameter( |
| ClassifierTemplateParameter object) { |
| return createClassifierTemplateParameterAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInterfaceRealization(InterfaceRealization object) { |
| return createInterfaceRealizationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseEncapsulatedClassifier( |
| EncapsulatedClassifier object) { |
| return createEncapsulatedClassifierAdapter(); |
| } |
| |
| @Override |
| public Adapter caseActivityGroup(ActivityGroup object) { |
| return createActivityGroupAdapter(); |
| } |
| |
| @Override |
| public Adapter caseActivityEdge(ActivityEdge object) { |
| return createActivityEdgeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseActivityPartition(ActivityPartition object) { |
| return createActivityPartitionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseActivityNode(ActivityNode object) { |
| return createActivityNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInterruptibleActivityRegion( |
| InterruptibleActivityRegion object) { |
| return createInterruptibleActivityRegionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseStructuredActivityNode( |
| StructuredActivityNode object) { |
| return createStructuredActivityNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseAction(Action object) { |
| return createActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseExecutableNode(ExecutableNode object) { |
| return createExecutableNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseExceptionHandler(ExceptionHandler object) { |
| return createExceptionHandlerAdapter(); |
| } |
| |
| @Override |
| public Adapter caseObjectNode(ObjectNode object) { |
| return createObjectNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInputPin(InputPin object) { |
| return createInputPinAdapter(); |
| } |
| |
| @Override |
| public Adapter casePin(Pin object) { |
| return createPinAdapter(); |
| } |
| |
| @Override |
| public Adapter caseOutputPin(OutputPin object) { |
| return createOutputPinAdapter(); |
| } |
| |
| @Override |
| public Adapter caseVariable(Variable object) { |
| return createVariableAdapter(); |
| } |
| |
| @Override |
| public Adapter caseValueSpecificationAction( |
| ValueSpecificationAction object) { |
| return createValueSpecificationActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseVariableAction(VariableAction object) { |
| return createVariableActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseWriteLinkAction(WriteLinkAction object) { |
| return createWriteLinkActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseLinkAction(LinkAction object) { |
| return createLinkActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseLinkEndData(LinkEndData object) { |
| return createLinkEndDataAdapter(); |
| } |
| |
| @Override |
| public Adapter caseQualifierValue(QualifierValue object) { |
| return createQualifierValueAdapter(); |
| } |
| |
| @Override |
| public Adapter caseWriteStructuralFeatureAction( |
| WriteStructuralFeatureAction object) { |
| return createWriteStructuralFeatureActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseStructuralFeatureAction( |
| StructuralFeatureAction object) { |
| return createStructuralFeatureActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseWriteVariableAction(WriteVariableAction object) { |
| return createWriteVariableActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseAcceptCallAction(AcceptCallAction object) { |
| return createAcceptCallActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseAcceptEventAction(AcceptEventAction object) { |
| return createAcceptEventActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseActionInputPin(ActionInputPin object) { |
| return createActionInputPinAdapter(); |
| } |
| |
| @Override |
| public Adapter caseAddStructuralFeatureValueAction( |
| AddStructuralFeatureValueAction object) { |
| return createAddStructuralFeatureValueActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseAddVariableValueAction( |
| AddVariableValueAction object) { |
| return createAddVariableValueActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseBroadcastSignalAction(BroadcastSignalAction object) { |
| return createBroadcastSignalActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInvocationAction(InvocationAction object) { |
| return createInvocationActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseCallAction(CallAction object) { |
| return createCallActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseCallBehaviorAction(CallBehaviorAction object) { |
| return createCallBehaviorActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseCallOperationAction(CallOperationAction object) { |
| return createCallOperationActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseClause(Clause object) { |
| return createClauseAdapter(); |
| } |
| |
| @Override |
| public Adapter caseClearAssociationAction( |
| ClearAssociationAction object) { |
| return createClearAssociationActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseClearStructuralFeatureAction( |
| ClearStructuralFeatureAction object) { |
| return createClearStructuralFeatureActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseClearVariableAction(ClearVariableAction object) { |
| return createClearVariableActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseConditionalNode(ConditionalNode object) { |
| return createConditionalNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseCreateLinkAction(CreateLinkAction object) { |
| return createCreateLinkActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseLinkEndCreationData(LinkEndCreationData object) { |
| return createLinkEndCreationDataAdapter(); |
| } |
| |
| @Override |
| public Adapter caseCreateLinkObjectAction( |
| CreateLinkObjectAction object) { |
| return createCreateLinkObjectActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseCreateObjectAction(CreateObjectAction object) { |
| return createCreateObjectActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDestroyLinkAction(DestroyLinkAction object) { |
| return createDestroyLinkActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseLinkEndDestructionData( |
| LinkEndDestructionData object) { |
| return createLinkEndDestructionDataAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDestroyObjectAction(DestroyObjectAction object) { |
| return createDestroyObjectActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseExpansionNode(ExpansionNode object) { |
| return createExpansionNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseExpansionRegion(ExpansionRegion object) { |
| return createExpansionRegionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseLoopNode(LoopNode object) { |
| return createLoopNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseOpaqueAction(OpaqueAction object) { |
| return createOpaqueActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseRaiseExceptionAction(RaiseExceptionAction object) { |
| return createRaiseExceptionActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseReadExtentAction(ReadExtentAction object) { |
| return createReadExtentActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseReadIsClassifiedObjectAction( |
| ReadIsClassifiedObjectAction object) { |
| return createReadIsClassifiedObjectActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseReadLinkAction(ReadLinkAction object) { |
| return createReadLinkActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseReadLinkObjectEndAction( |
| ReadLinkObjectEndAction object) { |
| return createReadLinkObjectEndActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseReadLinkObjectEndQualifierAction( |
| ReadLinkObjectEndQualifierAction object) { |
| return createReadLinkObjectEndQualifierActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseReadSelfAction(ReadSelfAction object) { |
| return createReadSelfActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseReadStructuralFeatureAction( |
| ReadStructuralFeatureAction object) { |
| return createReadStructuralFeatureActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseReadVariableAction(ReadVariableAction object) { |
| return createReadVariableActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseReclassifyObjectAction( |
| ReclassifyObjectAction object) { |
| return createReclassifyObjectActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseReduceAction(ReduceAction object) { |
| return createReduceActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseRemoveStructuralFeatureValueAction( |
| RemoveStructuralFeatureValueAction object) { |
| return createRemoveStructuralFeatureValueActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseRemoveVariableValueAction( |
| RemoveVariableValueAction object) { |
| return createRemoveVariableValueActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseReplyAction(ReplyAction object) { |
| return createReplyActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseSendObjectAction(SendObjectAction object) { |
| return createSendObjectActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseSendSignalAction(SendSignalAction object) { |
| return createSendSignalActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseSequenceNode(SequenceNode object) { |
| return createSequenceNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseStartClassifierBehaviorAction( |
| StartClassifierBehaviorAction object) { |
| return createStartClassifierBehaviorActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseStartObjectBehaviorAction( |
| StartObjectBehaviorAction object) { |
| return createStartObjectBehaviorActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseTestIdentityAction(TestIdentityAction object) { |
| return createTestIdentityActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseUnmarshallAction(UnmarshallAction object) { |
| return createUnmarshallActionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseValuePin(ValuePin object) { |
| return createValuePinAdapter(); |
| } |
| |
| @Override |
| public Adapter caseActivityFinalNode(ActivityFinalNode object) { |
| return createActivityFinalNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseFinalNode(FinalNode object) { |
| return createFinalNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseControlNode(ControlNode object) { |
| return createControlNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseActivityParameterNode(ActivityParameterNode object) { |
| return createActivityParameterNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseCentralBufferNode(CentralBufferNode object) { |
| return createCentralBufferNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseControlFlow(ControlFlow object) { |
| return createControlFlowAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDataStoreNode(DataStoreNode object) { |
| return createDataStoreNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDecisionNode(DecisionNode object) { |
| return createDecisionNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseObjectFlow(ObjectFlow object) { |
| return createObjectFlowAdapter(); |
| } |
| |
| @Override |
| public Adapter caseFlowFinalNode(FlowFinalNode object) { |
| return createFlowFinalNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseForkNode(ForkNode object) { |
| return createForkNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInitialNode(InitialNode object) { |
| return createInitialNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseJoinNode(JoinNode object) { |
| return createJoinNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseMergeNode(MergeNode object) { |
| return createMergeNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInstanceValue(InstanceValue object) { |
| return createInstanceValueAdapter(); |
| } |
| |
| @Override |
| public Adapter caseAnyReceiveEvent(AnyReceiveEvent object) { |
| return createAnyReceiveEventAdapter(); |
| } |
| |
| @Override |
| public Adapter caseMessageEvent(MessageEvent object) { |
| return createMessageEventAdapter(); |
| } |
| |
| @Override |
| public Adapter caseCallEvent(CallEvent object) { |
| return createCallEventAdapter(); |
| } |
| |
| @Override |
| public Adapter caseChangeEvent(ChangeEvent object) { |
| return createChangeEventAdapter(); |
| } |
| |
| @Override |
| public Adapter caseFunctionBehavior(FunctionBehavior object) { |
| return createFunctionBehaviorAdapter(); |
| } |
| |
| @Override |
| public Adapter caseOpaqueBehavior(OpaqueBehavior object) { |
| return createOpaqueBehaviorAdapter(); |
| } |
| |
| @Override |
| public Adapter caseSignalEvent(SignalEvent object) { |
| return createSignalEventAdapter(); |
| } |
| |
| @Override |
| public Adapter caseTimeEvent(TimeEvent object) { |
| return createTimeEventAdapter(); |
| } |
| |
| @Override |
| public Adapter caseTimeExpression(TimeExpression object) { |
| return createTimeExpressionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseObservation(Observation object) { |
| return createObservationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseCommunicationPath(CommunicationPath object) { |
| return createCommunicationPathAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDevice(Device object) { |
| return createDeviceAdapter(); |
| } |
| |
| @Override |
| public Adapter caseNode(Node object) { |
| return createNodeAdapter(); |
| } |
| |
| @Override |
| public Adapter caseExecutionEnvironment(ExecutionEnvironment object) { |
| return createExecutionEnvironmentAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInformationFlow(InformationFlow object) { |
| return createInformationFlowAdapter(); |
| } |
| |
| @Override |
| public Adapter caseMessage(Message object) { |
| return createMessageAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInteraction(Interaction object) { |
| return createInteractionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInteractionFragment(InteractionFragment object) { |
| return createInteractionFragmentAdapter(); |
| } |
| |
| @Override |
| public Adapter caseLifeline(Lifeline object) { |
| return createLifelineAdapter(); |
| } |
| |
| @Override |
| public Adapter casePartDecomposition(PartDecomposition object) { |
| return createPartDecompositionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInteractionUse(InteractionUse object) { |
| return createInteractionUseAdapter(); |
| } |
| |
| @Override |
| public Adapter caseGate(Gate object) { |
| return createGateAdapter(); |
| } |
| |
| @Override |
| public Adapter caseMessageEnd(MessageEnd object) { |
| return createMessageEndAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInteractionOperand(InteractionOperand object) { |
| return createInteractionOperandAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInteractionConstraint(InteractionConstraint object) { |
| return createInteractionConstraintAdapter(); |
| } |
| |
| @Override |
| public Adapter caseGeneralOrdering(GeneralOrdering object) { |
| return createGeneralOrderingAdapter(); |
| } |
| |
| @Override |
| public Adapter caseOccurrenceSpecification( |
| OccurrenceSpecification object) { |
| return createOccurrenceSpecificationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInformationItem(InformationItem object) { |
| return createInformationItemAdapter(); |
| } |
| |
| @Override |
| public Adapter caseActionExecutionSpecification( |
| ActionExecutionSpecification object) { |
| return createActionExecutionSpecificationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseExecutionSpecification( |
| ExecutionSpecification object) { |
| return createExecutionSpecificationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseBehaviorExecutionSpecification( |
| BehaviorExecutionSpecification object) { |
| return createBehaviorExecutionSpecificationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseCombinedFragment(CombinedFragment object) { |
| return createCombinedFragmentAdapter(); |
| } |
| |
| @Override |
| public Adapter caseConsiderIgnoreFragment( |
| ConsiderIgnoreFragment object) { |
| return createConsiderIgnoreFragmentAdapter(); |
| } |
| |
| @Override |
| public Adapter caseContinuation(Continuation object) { |
| return createContinuationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDestructionOccurrenceSpecification( |
| DestructionOccurrenceSpecification object) { |
| return createDestructionOccurrenceSpecificationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseMessageOccurrenceSpecification( |
| MessageOccurrenceSpecification object) { |
| return createMessageOccurrenceSpecificationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseExecutionOccurrenceSpecification( |
| ExecutionOccurrenceSpecification object) { |
| return createExecutionOccurrenceSpecificationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseStateInvariant(StateInvariant object) { |
| return createStateInvariantAdapter(); |
| } |
| |
| @Override |
| public Adapter caseFinalState(FinalState object) { |
| return createFinalStateAdapter(); |
| } |
| |
| @Override |
| public Adapter caseProtocolTransition(ProtocolTransition object) { |
| return createProtocolTransitionAdapter(); |
| } |
| |
| @Override |
| public Adapter caseAssociationClass(AssociationClass object) { |
| return createAssociationClassAdapter(); |
| } |
| |
| @Override |
| public Adapter caseComponent(Component object) { |
| return createComponentAdapter(); |
| } |
| |
| @Override |
| public Adapter caseComponentRealization(ComponentRealization object) { |
| return createComponentRealizationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseActor(Actor object) { |
| return createActorAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDuration(Duration object) { |
| return createDurationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDurationConstraint(DurationConstraint object) { |
| return createDurationConstraintAdapter(); |
| } |
| |
| @Override |
| public Adapter caseIntervalConstraint(IntervalConstraint object) { |
| return createIntervalConstraintAdapter(); |
| } |
| |
| @Override |
| public Adapter caseInterval(Interval object) { |
| return createIntervalAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDurationInterval(DurationInterval object) { |
| return createDurationIntervalAdapter(); |
| } |
| |
| @Override |
| public Adapter caseDurationObservation(DurationObservation object) { |
| return createDurationObservationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseLiteralBoolean(LiteralBoolean object) { |
| return createLiteralBooleanAdapter(); |
| } |
| |
| @Override |
| public Adapter caseLiteralSpecification(LiteralSpecification object) { |
| return createLiteralSpecificationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseLiteralInteger(LiteralInteger object) { |
| return createLiteralIntegerAdapter(); |
| } |
| |
| @Override |
| public Adapter caseLiteralNull(LiteralNull object) { |
| return createLiteralNullAdapter(); |
| } |
| |
| @Override |
| public Adapter caseLiteralReal(LiteralReal object) { |
| return createLiteralRealAdapter(); |
| } |
| |
| @Override |
| public Adapter caseLiteralString(LiteralString object) { |
| return createLiteralStringAdapter(); |
| } |
| |
| @Override |
| public Adapter caseLiteralUnlimitedNatural( |
| LiteralUnlimitedNatural object) { |
| return createLiteralUnlimitedNaturalAdapter(); |
| } |
| |
| @Override |
| public Adapter caseTimeConstraint(TimeConstraint object) { |
| return createTimeConstraintAdapter(); |
| } |
| |
| @Override |
| public Adapter caseTimeInterval(TimeInterval object) { |
| return createTimeIntervalAdapter(); |
| } |
| |
| @Override |
| public Adapter caseTimeObservation(TimeObservation object) { |
| return createTimeObservationAdapter(); |
| } |
| |
| @Override |
| public Adapter caseEModelElement(EModelElement object) { |
| return createEModelElementAdapter(); |
| } |
| |
| @Override |
| public Adapter defaultCase(EObject object) { |
| return createEObjectAdapter(); |
| } |
| }; |
| |
| /** |
| * Creates an adapter for the <code>target</code>. |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @param target the object to adapt. |
| * @return the adapter for the <code>target</code>. |
| * @generated |
| */ |
| @Override |
| public Adapter createAdapter(Notifier target) { |
| return modelSwitch.doSwitch((EObject) target); |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.ActivityContent <em>Activity Content</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| * <!-- end-user-doc --> |
| * @return the new adapter. |
| * @see org.eclipse.uml2.uml.ActivityContent |
| * @generated |
| */ |
| public Adapter createActivityContentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Comment |
| * @generated |
| */ |
| public Adapter createCommentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Element |
| * @generated |
| */ |
| public Adapter createElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.DirectedRelationship |
| * @generated |
| */ |
| public Adapter createDirectedRelationshipAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Relationship |
| * @generated |
| */ |
| public Adapter createRelationshipAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.LiteralSpecification |
| * @generated |
| */ |
| public Adapter createLiteralSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ValueSpecification |
| * @generated |
| */ |
| public Adapter createValueSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.TypedElement |
| * @generated |
| */ |
| public Adapter createTypedElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.NamedElement |
| * @generated |
| */ |
| public Adapter createNamedElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Dependency |
| * @generated |
| */ |
| public Adapter createDependencyAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.PackageableElement |
| * @generated |
| */ |
| public Adapter createPackageableElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ParameterableElement |
| * @generated |
| */ |
| public Adapter createParameterableElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.TemplateParameter |
| * @generated |
| */ |
| public Adapter createTemplateParameterAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.TemplateSignature |
| * @generated |
| */ |
| public Adapter createTemplateSignatureAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.TemplateableElement |
| * @generated |
| */ |
| public Adapter createTemplateableElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.TemplateBinding |
| * @generated |
| */ |
| public Adapter createTemplateBindingAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.TemplateParameterSubstitution |
| * @generated |
| */ |
| public Adapter createTemplateParameterSubstitutionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Namespace |
| * @generated |
| */ |
| public Adapter createNamespaceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ElementImport |
| * @generated |
| */ |
| public Adapter createElementImportAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.PackageImport |
| * @generated |
| */ |
| public Adapter createPackageImportAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Package |
| * @generated |
| */ |
| public Adapter createPackageAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.PackageMerge |
| * @generated |
| */ |
| public Adapter createPackageMergeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Type |
| * @generated |
| */ |
| public Adapter createTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ProfileApplication |
| * @generated |
| */ |
| public Adapter createProfileApplicationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Profile |
| * @generated |
| */ |
| public Adapter createProfileAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Stereotype |
| * @generated |
| */ |
| public Adapter createStereotypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Class |
| * @generated |
| */ |
| public Adapter createClassAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.BehavioredClassifier |
| * @generated |
| */ |
| public Adapter createBehavioredClassifierAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Classifier |
| * @generated |
| */ |
| public Adapter createClassifierAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.RedefinableElement |
| * @generated |
| */ |
| public Adapter createRedefinableElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Generalization |
| * @generated |
| */ |
| public Adapter createGeneralizationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.GeneralizationSet |
| * @generated |
| */ |
| public Adapter createGeneralizationSetAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Feature |
| * @generated |
| */ |
| public Adapter createFeatureAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.UseCase |
| * @generated |
| */ |
| public Adapter createUseCaseAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Include |
| * @generated |
| */ |
| public Adapter createIncludeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Extend |
| * @generated |
| */ |
| public Adapter createExtendAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Constraint |
| * @generated |
| */ |
| public Adapter createConstraintAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ExtensionPoint |
| * @generated |
| */ |
| public Adapter createExtensionPointAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Substitution |
| * @generated |
| */ |
| public Adapter createSubstitutionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Realization |
| * @generated |
| */ |
| public Adapter createRealizationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Abstraction |
| * @generated |
| */ |
| public Adapter createAbstractionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.OpaqueExpression |
| * @generated |
| */ |
| public Adapter createOpaqueExpressionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Parameter |
| * @generated |
| */ |
| public Adapter createParameterAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.MultiplicityElement |
| * @generated |
| */ |
| public Adapter createMultiplicityElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ConnectableElement |
| * @generated |
| */ |
| public Adapter createConnectableElementAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ConnectorEnd |
| * @generated |
| */ |
| public Adapter createConnectorEndAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Property |
| * @generated |
| */ |
| public Adapter createPropertyAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.DeploymentTarget |
| * @generated |
| */ |
| public Adapter createDeploymentTargetAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Deployment |
| * @generated |
| */ |
| public Adapter createDeploymentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.DeployedArtifact |
| * @generated |
| */ |
| public Adapter createDeployedArtifactAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.DeploymentSpecification |
| * @generated |
| */ |
| public Adapter createDeploymentSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Artifact |
| * @generated |
| */ |
| public Adapter createArtifactAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Manifestation |
| * @generated |
| */ |
| public Adapter createManifestationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Operation |
| * @generated |
| */ |
| public Adapter createOperationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.BehavioralFeature |
| * @generated |
| */ |
| public Adapter createBehavioralFeatureAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Behavior |
| * @generated |
| */ |
| public Adapter createBehaviorAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ParameterSet |
| * @generated |
| */ |
| public Adapter createParameterSetAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.DataType |
| * @generated |
| */ |
| public Adapter createDataTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Interface |
| * @generated |
| */ |
| public Adapter createInterfaceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Reception |
| * @generated |
| */ |
| public Adapter createReceptionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Signal |
| * @generated |
| */ |
| public Adapter createSignalAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ProtocolStateMachine |
| * @generated |
| */ |
| public Adapter createProtocolStateMachineAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.StateMachine |
| * @generated |
| */ |
| public Adapter createStateMachineAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Region |
| * @generated |
| */ |
| public Adapter createRegionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Vertex |
| * @generated |
| */ |
| public Adapter createVertexAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Transition |
| * @generated |
| */ |
| public Adapter createTransitionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Trigger |
| * @generated |
| */ |
| public Adapter createTriggerAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.Event <em>Event</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it'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.uml.Event |
| * @generated |
| */ |
| public Adapter createEventAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Port |
| * @generated |
| */ |
| public Adapter createPortAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.State |
| * @generated |
| */ |
| public Adapter createStateAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ConnectionPointReference |
| * @generated |
| */ |
| public Adapter createConnectionPointReferenceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Pseudostate |
| * @generated |
| */ |
| public Adapter createPseudostateAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ProtocolConformance |
| * @generated |
| */ |
| public Adapter createProtocolConformanceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.OperationTemplateParameter |
| * @generated |
| */ |
| public Adapter createOperationTemplateParameterAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.StructuralFeature |
| * @generated |
| */ |
| public Adapter createStructuralFeatureAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Association |
| * @generated |
| */ |
| public Adapter createAssociationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ConnectableElementTemplateParameter |
| * @generated |
| */ |
| public Adapter createConnectableElementTemplateParameterAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.CollaborationUse <em>Collaboration Use</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it'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.uml.CollaborationUse |
| * @generated |
| */ |
| public Adapter createCollaborationUseAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Collaboration |
| * @generated |
| */ |
| public Adapter createCollaborationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.StructuredClassifier |
| * @generated |
| */ |
| public Adapter createStructuredClassifierAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Connector |
| * @generated |
| */ |
| public Adapter createConnectorAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.RedefinableTemplateSignature |
| * @generated |
| */ |
| public Adapter createRedefinableTemplateSignatureAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ClassifierTemplateParameter |
| * @generated |
| */ |
| public Adapter createClassifierTemplateParameterAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.InterfaceRealization <em>Interface 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.uml.InterfaceRealization |
| * @generated |
| */ |
| public Adapter createInterfaceRealizationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.EncapsulatedClassifier |
| * @generated |
| */ |
| public Adapter createEncapsulatedClassifierAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Extension |
| * @generated |
| */ |
| public Adapter createExtensionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ExtensionEnd |
| * @generated |
| */ |
| public Adapter createExtensionEndAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.Image <em>Image</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it'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.uml.Image |
| * @generated |
| */ |
| public Adapter createImageAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.StringExpression |
| * @generated |
| */ |
| public Adapter createStringExpressionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Expression |
| * @generated |
| */ |
| public Adapter createExpressionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.LiteralInteger |
| * @generated |
| */ |
| public Adapter createLiteralIntegerAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.LiteralString |
| * @generated |
| */ |
| public Adapter createLiteralStringAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.LiteralBoolean |
| * @generated |
| */ |
| public Adapter createLiteralBooleanAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.LiteralNull |
| * @generated |
| */ |
| public Adapter createLiteralNullAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.LiteralReal <em>Literal Real</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it'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.uml.LiteralReal |
| * @generated |
| */ |
| public Adapter createLiteralRealAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Slot |
| * @generated |
| */ |
| public Adapter createSlotAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.InstanceSpecification |
| * @generated |
| */ |
| public Adapter createInstanceSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Enumeration |
| * @generated |
| */ |
| public Adapter createEnumerationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.EnumerationLiteral |
| * @generated |
| */ |
| public Adapter createEnumerationLiteralAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.PrimitiveType |
| * @generated |
| */ |
| public Adapter createPrimitiveTypeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.InstanceValue |
| * @generated |
| */ |
| public Adapter createInstanceValueAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.LiteralUnlimitedNatural |
| * @generated |
| */ |
| public Adapter createLiteralUnlimitedNaturalAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.OpaqueBehavior <em>Opaque 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.uml.OpaqueBehavior |
| * @generated |
| */ |
| public Adapter createOpaqueBehaviorAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.FunctionBehavior <em>Function 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.uml.FunctionBehavior |
| * @generated |
| */ |
| public Adapter createFunctionBehaviorAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Actor |
| * @generated |
| */ |
| public Adapter createActorAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Usage |
| * @generated |
| */ |
| public Adapter createUsageAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Message |
| * @generated |
| */ |
| public Adapter createMessageAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.MessageEnd |
| * @generated |
| */ |
| public Adapter createMessageEndAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Interaction |
| * @generated |
| */ |
| public Adapter createInteractionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.InteractionFragment |
| * @generated |
| */ |
| public Adapter createInteractionFragmentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Lifeline |
| * @generated |
| */ |
| public Adapter createLifelineAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.PartDecomposition |
| * @generated |
| */ |
| public Adapter createPartDecompositionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.InteractionUse <em>Interaction Use</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it'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.uml.InteractionUse |
| * @generated |
| */ |
| public Adapter createInteractionUseAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Gate |
| * @generated |
| */ |
| public Adapter createGateAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Action |
| * @generated |
| */ |
| public Adapter createActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ExecutableNode |
| * @generated |
| */ |
| public Adapter createExecutableNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ActivityNode |
| * @generated |
| */ |
| public Adapter createActivityNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ActivityEdge |
| * @generated |
| */ |
| public Adapter createActivityEdgeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Activity |
| * @generated |
| */ |
| public Adapter createActivityAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ActivityPartition |
| * @generated |
| */ |
| public Adapter createActivityPartitionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ActivityGroup |
| * @generated |
| */ |
| public Adapter createActivityGroupAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.StructuredActivityNode |
| * @generated |
| */ |
| public Adapter createStructuredActivityNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Variable |
| * @generated |
| */ |
| public Adapter createVariableAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.InterruptibleActivityRegion |
| * @generated |
| */ |
| public Adapter createInterruptibleActivityRegionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ExceptionHandler |
| * @generated |
| */ |
| public Adapter createExceptionHandlerAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ObjectNode |
| * @generated |
| */ |
| public Adapter createObjectNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.OutputPin |
| * @generated |
| */ |
| public Adapter createOutputPinAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Pin |
| * @generated |
| */ |
| public Adapter createPinAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.InputPin |
| * @generated |
| */ |
| public Adapter createInputPinAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.GeneralOrdering |
| * @generated |
| */ |
| public Adapter createGeneralOrderingAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.OccurrenceSpecification <em>Occurrence 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.uml.OccurrenceSpecification |
| * @generated |
| */ |
| public Adapter createOccurrenceSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.InteractionOperand |
| * @generated |
| */ |
| public Adapter createInteractionOperandAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.InteractionConstraint |
| * @generated |
| */ |
| public Adapter createInteractionConstraintAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.ExecutionSpecification <em>Execution 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.uml.ExecutionSpecification |
| * @generated |
| */ |
| public Adapter createExecutionSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.ExecutionOccurrenceSpecification <em>Execution Occurrence 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.uml.ExecutionOccurrenceSpecification |
| * @generated |
| */ |
| public Adapter createExecutionOccurrenceSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.StateInvariant |
| * @generated |
| */ |
| public Adapter createStateInvariantAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.ActionExecutionSpecification <em>Action Execution 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.uml.ActionExecutionSpecification |
| * @generated |
| */ |
| public Adapter createActionExecutionSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.BehaviorExecutionSpecification <em>Behavior Execution 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.uml.BehaviorExecutionSpecification |
| * @generated |
| */ |
| public Adapter createBehaviorExecutionSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.MessageEvent <em>Message Event</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it'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.uml.MessageEvent |
| * @generated |
| */ |
| public Adapter createMessageEventAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.MessageOccurrenceSpecification <em>Message Occurrence 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.uml.MessageOccurrenceSpecification |
| * @generated |
| */ |
| public Adapter createMessageOccurrenceSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.CombinedFragment |
| * @generated |
| */ |
| public Adapter createCombinedFragmentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Continuation |
| * @generated |
| */ |
| public Adapter createContinuationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.ConsiderIgnoreFragment <em>Consider Ignore 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.uml.ConsiderIgnoreFragment |
| * @generated |
| */ |
| public Adapter createConsiderIgnoreFragmentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.CallEvent <em>Call Event</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it'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.uml.CallEvent |
| * @generated |
| */ |
| public Adapter createCallEventAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.ChangeEvent <em>Change Event</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it'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.uml.ChangeEvent |
| * @generated |
| */ |
| public Adapter createChangeEventAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.SignalEvent <em>Signal Event</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it'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.uml.SignalEvent |
| * @generated |
| */ |
| public Adapter createSignalEventAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.AnyReceiveEvent <em>Any Receive Event</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it'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.uml.AnyReceiveEvent |
| * @generated |
| */ |
| public Adapter createAnyReceiveEventAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.CreateObjectAction |
| * @generated |
| */ |
| public Adapter createCreateObjectActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.DestroyObjectAction |
| * @generated |
| */ |
| public Adapter createDestroyObjectActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.DestructionOccurrenceSpecification <em>Destruction Occurrence 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.uml.DestructionOccurrenceSpecification |
| * @generated |
| */ |
| public Adapter createDestructionOccurrenceSpecificationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.TestIdentityAction |
| * @generated |
| */ |
| public Adapter createTestIdentityActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ReadSelfAction |
| * @generated |
| */ |
| public Adapter createReadSelfActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.StructuralFeatureAction |
| * @generated |
| */ |
| public Adapter createStructuralFeatureActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ReadStructuralFeatureAction |
| * @generated |
| */ |
| public Adapter createReadStructuralFeatureActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.WriteStructuralFeatureAction |
| * @generated |
| */ |
| public Adapter createWriteStructuralFeatureActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ClearStructuralFeatureAction |
| * @generated |
| */ |
| public Adapter createClearStructuralFeatureActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.RemoveStructuralFeatureValueAction |
| * @generated |
| */ |
| public Adapter createRemoveStructuralFeatureValueActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.AddStructuralFeatureValueAction |
| * @generated |
| */ |
| public Adapter createAddStructuralFeatureValueActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.LinkAction |
| * @generated |
| */ |
| public Adapter createLinkActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.LinkEndData |
| * @generated |
| */ |
| public Adapter createLinkEndDataAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.QualifierValue |
| * @generated |
| */ |
| public Adapter createQualifierValueAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ReadLinkAction |
| * @generated |
| */ |
| public Adapter createReadLinkActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.LinkEndCreationData |
| * @generated |
| */ |
| public Adapter createLinkEndCreationDataAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.CreateLinkAction |
| * @generated |
| */ |
| public Adapter createCreateLinkActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.WriteLinkAction |
| * @generated |
| */ |
| public Adapter createWriteLinkActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.DestroyLinkAction |
| * @generated |
| */ |
| public Adapter createDestroyLinkActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.LinkEndDestructionData <em>Link End Destruction 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.uml.LinkEndDestructionData |
| * @generated |
| */ |
| public Adapter createLinkEndDestructionDataAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ClearAssociationAction |
| * @generated |
| */ |
| public Adapter createClearAssociationActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.BroadcastSignalAction |
| * @generated |
| */ |
| public Adapter createBroadcastSignalActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.InvocationAction |
| * @generated |
| */ |
| public Adapter createInvocationActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.SendObjectAction |
| * @generated |
| */ |
| public Adapter createSendObjectActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.ValueSpecificationAction <em>Value Specification 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.uml.ValueSpecificationAction |
| * @generated |
| */ |
| public Adapter createValueSpecificationActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.TimeExpression |
| * @generated |
| */ |
| public Adapter createTimeExpressionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.Observation <em>Observation</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it'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.uml.Observation |
| * @generated |
| */ |
| public Adapter createObservationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Duration |
| * @generated |
| */ |
| public Adapter createDurationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ValuePin |
| * @generated |
| */ |
| public Adapter createValuePinAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.DurationInterval |
| * @generated |
| */ |
| public Adapter createDurationIntervalAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Interval |
| * @generated |
| */ |
| public Adapter createIntervalAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.TimeConstraint |
| * @generated |
| */ |
| public Adapter createTimeConstraintAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.IntervalConstraint |
| * @generated |
| */ |
| public Adapter createIntervalConstraintAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.TimeInterval |
| * @generated |
| */ |
| public Adapter createTimeIntervalAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.DurationConstraint |
| * @generated |
| */ |
| public Adapter createDurationConstraintAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.TimeObservation <em>Time Observation</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it'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.uml.TimeObservation |
| * @generated |
| */ |
| public Adapter createTimeObservationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.DurationObservation <em>Duration Observation</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it'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.uml.DurationObservation |
| * @generated |
| */ |
| public Adapter createDurationObservationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.OpaqueAction <em>Opaque 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.uml.OpaqueAction |
| * @generated |
| */ |
| public Adapter createOpaqueActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.CallAction |
| * @generated |
| */ |
| public Adapter createCallActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.SendSignalAction |
| * @generated |
| */ |
| public Adapter createSendSignalActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.CallOperationAction |
| * @generated |
| */ |
| public Adapter createCallOperationActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.CallBehaviorAction |
| * @generated |
| */ |
| public Adapter createCallBehaviorActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.InformationItem |
| * @generated |
| */ |
| public Adapter createInformationItemAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.InformationFlow |
| * @generated |
| */ |
| public Adapter createInformationFlowAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Model |
| * @generated |
| */ |
| public Adapter createModelAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.VariableAction |
| * @generated |
| */ |
| public Adapter createVariableActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ReadVariableAction |
| * @generated |
| */ |
| public Adapter createReadVariableActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.WriteVariableAction |
| * @generated |
| */ |
| public Adapter createWriteVariableActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ClearVariableAction |
| * @generated |
| */ |
| public Adapter createClearVariableActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.AddVariableValueAction |
| * @generated |
| */ |
| public Adapter createAddVariableValueActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.RemoveVariableValueAction |
| * @generated |
| */ |
| public Adapter createRemoveVariableValueActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.RaiseExceptionAction |
| * @generated |
| */ |
| public Adapter createRaiseExceptionActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.ActionInputPin <em>Action 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.uml.ActionInputPin |
| * @generated |
| */ |
| public Adapter createActionInputPinAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ReadExtentAction |
| * @generated |
| */ |
| public Adapter createReadExtentActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ReclassifyObjectAction |
| * @generated |
| */ |
| public Adapter createReclassifyObjectActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ReadIsClassifiedObjectAction |
| * @generated |
| */ |
| public Adapter createReadIsClassifiedObjectActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.StartClassifierBehaviorAction <em>Start Classifier 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.uml.StartClassifierBehaviorAction |
| * @generated |
| */ |
| public Adapter createStartClassifierBehaviorActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ReadLinkObjectEndAction |
| * @generated |
| */ |
| public Adapter createReadLinkObjectEndActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ReadLinkObjectEndQualifierAction |
| * @generated |
| */ |
| public Adapter createReadLinkObjectEndQualifierActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.CreateLinkObjectAction |
| * @generated |
| */ |
| public Adapter createCreateLinkObjectActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.AcceptEventAction |
| * @generated |
| */ |
| public Adapter createAcceptEventActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.AcceptCallAction |
| * @generated |
| */ |
| public Adapter createAcceptCallActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ReplyAction |
| * @generated |
| */ |
| public Adapter createReplyActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.UnmarshallAction <em>Unmarshall 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.uml.UnmarshallAction |
| * @generated |
| */ |
| public Adapter createUnmarshallActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.ReduceAction <em>Reduce 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.uml.ReduceAction |
| * @generated |
| */ |
| public Adapter createReduceActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.StartObjectBehaviorAction <em>Start Object 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.uml.StartObjectBehaviorAction |
| * @generated |
| */ |
| public Adapter createStartObjectBehaviorActionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ControlNode |
| * @generated |
| */ |
| public Adapter createControlNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ControlFlow |
| * @generated |
| */ |
| public Adapter createControlFlowAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.InitialNode |
| * @generated |
| */ |
| public Adapter createInitialNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ActivityParameterNode |
| * @generated |
| */ |
| public Adapter createActivityParameterNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ForkNode |
| * @generated |
| */ |
| public Adapter createForkNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.FlowFinalNode |
| * @generated |
| */ |
| public Adapter createFlowFinalNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.FinalNode |
| * @generated |
| */ |
| public Adapter createFinalNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.CentralBufferNode |
| * @generated |
| */ |
| public Adapter createCentralBufferNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.MergeNode |
| * @generated |
| */ |
| public Adapter createMergeNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.DecisionNode |
| * @generated |
| */ |
| public Adapter createDecisionNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ActivityFinalNode |
| * @generated |
| */ |
| public Adapter createActivityFinalNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.JoinNode |
| * @generated |
| */ |
| public Adapter createJoinNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.DataStoreNode |
| * @generated |
| */ |
| public Adapter createDataStoreNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ObjectFlow |
| * @generated |
| */ |
| public Adapter createObjectFlowAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.SequenceNode <em>Sequence 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.uml.SequenceNode |
| * @generated |
| */ |
| public Adapter createSequenceNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ConditionalNode |
| * @generated |
| */ |
| public Adapter createConditionalNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Clause |
| * @generated |
| */ |
| public Adapter createClauseAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.LoopNode |
| * @generated |
| */ |
| public Adapter createLoopNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ExpansionNode |
| * @generated |
| */ |
| public Adapter createExpansionNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ExpansionRegion |
| * @generated |
| */ |
| public Adapter createExpansionRegionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.ComponentRealization <em>Component 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.uml.ComponentRealization |
| * @generated |
| */ |
| public Adapter createComponentRealizationAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Component |
| * @generated |
| */ |
| public Adapter createComponentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Node |
| * @generated |
| */ |
| public Adapter createNodeAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.Device |
| * @generated |
| */ |
| public Adapter createDeviceAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ExecutionEnvironment |
| * @generated |
| */ |
| public Adapter createExecutionEnvironmentAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.CommunicationPath |
| * @generated |
| */ |
| public Adapter createCommunicationPathAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.FinalState |
| * @generated |
| */ |
| public Adapter createFinalStateAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.TimeEvent <em>Time Event</em>}'. |
| * <!-- begin-user-doc --> |
| * This default implementation returns null so that we can easily ignore cases; |
| * it'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.uml.TimeEvent |
| * @generated |
| */ |
| public Adapter createTimeEventAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.ProtocolTransition |
| * @generated |
| */ |
| public Adapter createProtocolTransitionAdapter() { |
| return null; |
| } |
| |
| /** |
| * Creates a new adapter for an object of class '{@link org.eclipse.uml2.uml.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.uml.AssociationClass |
| * @generated |
| */ |
| public Adapter createAssociationClassAdapter() { |
| 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; |
| } |
| |
| } //UMLAdapterFactory |
