Uses of Interface de.mid.innovator.srv2api.icw2elem.ELUUIDAble (Java API)

Overview

Package

Class

Use

Help

SDK Help DE EN

PREV NEXT

FRAMES NO FRAMES

Uses of Interface
de.mid.innovator.srv2api.icw2elem.ELUUIDAble

Packages that use ELUUIDAble
de.mid.innovator.srv2api.icw2ac	Activity modeling emphasizes the sequence and conditions for coordinating lower-level behaviors, rather than which classifiers own those behaviors.
de.mid.innovator.srv2api.icw2bc
de.mid.innovator.srv2api.icw2be	The Common Behaviors packages specify the core concepts required for dynamic elements and provides the infrastructure to support more detailed definitions of behavior.
de.mid.innovator.srv2api.icw2bp
de.mid.innovator.srv2api.icw2bpdia
de.mid.innovator.srv2api.icw2br
de.mid.innovator.srv2api.icw2brdia
de.mid.innovator.srv2api.icw2bs
de.mid.innovator.srv2api.icw2bsdia
de.mid.innovator.srv2api.icw2class	The classes package deals with the basic modeling concepts of UML and, in particular, classes and their relationships.
de.mid.innovator.srv2api.icw2cldia
de.mid.innovator.srv2api.icw2db	The DB package (spezialization of the IM package) describes the concepts needed for modeling a relational database.
de.mid.innovator.srv2api.icw2dbdia	Database Diagramms and representations of tables and foreign keys, as well as views and from clauses.
de.mid.innovator.srv2api.icw2dg	The documentation package deals with the model documentation configuration and generation.
de.mid.innovator.srv2api.icw2elem
de.mid.innovator.srv2api.icw2er	The ER package (spezialization of the IM package) deals with the modeling concepts for the Entity Relationship Model and, in particular, entities, attributes and their relationships.
de.mid.innovator.srv2api.icw2erdia	Entity Relationship Diagramms and representations of entities and relationships, as well as conceptual views and from clauses.
de.mid.innovator.srv2api.icw2gc
de.mid.innovator.srv2api.icw2gcdia
de.mid.innovator.srv2api.icw2ia	The Interaction package describes the concepts needed to express Interactions.
de.mid.innovator.srv2api.icw2im	The IM package specify the Information Management Metamodel core concepts required for data modeling.
de.mid.innovator.srv2api.icw2imdia	Information Management Metamodel Diagramm is a subclass of Class Diagramm.
de.mid.innovator.srv2api.icw2meta	Meta model and administration information.
de.mid.innovator.srv2api.icw2model	This packagage contains elements representing the logical model.
de.mid.innovator.srv2api.icw2pres	Diagramms and grafical representations of model elements in diagramms.
de.mid.innovator.srv2api.icw2sm	The StateMachine package defines a set of concepts that can be used for modeling discrete behavior through finite statetransition systems.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2ac

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2ac
`interface`	`ACActivity` An activity specifies the coordination of executions of subordinate behaviors using a control and data flow model.
`interface`	`ACActivityEdge` Flow edge for either control flow of object flow.
`interface`	`ACActivityFinalNode` An activity final node is a final node that stops all flows in an activity.
`interface`	`ACActivityGroup` An activity group is an abstract class for defining sets of nodes and edges in an activity.
`interface`	`ACActivityNode` An activity node is an abstract class for points in the flow of an activity connected by edges.
`interface`	`ACCentralBufferNode` A central buffer node is an object node for managing flows from multiple sources and destinations.
`interface`	`ACControlFlow` A control flow is an edge that starts an activity node after the previous one is finished.
`interface`	`ACControlNode` A control node is an abstract activity node that coordinates flows in an activity.
`interface`	`ACDataStoreNode` A data store node is a central buffer node for non-transient information.
`interface`	`ACDecisionNode` A decision node is a control node that chooses between outgoing flows.
`interface`	`ACExecutableNode` An executable node is an abstract class for activity nodes that may be executed.
`interface`	`ACFinalNode` A final node is an abstract control node which a flow in an activity stops at.
`interface`	`ACFlowFinalNode` A flow final node is a final node that terminates a flow.
`interface`	`ACForkNode` A fork node is a control node that splits a flow into multiple concurrent flows.
`interface`	`ACInitialNode` An initial node is a control node which flow starts at when the activity is invoked.
`interface`	`ACInterruptibleRegion` An interruptible activity region is an activity group that supports termination of tokens flowing in the portions of an activity.
`interface`	`ACJoinNode` A join node is a control node that synchronizes multiple flows.
`interface`	`ACMergeNode` A merge node is a control node that brings multiple alternate flows together.
`interface`	`ACObjectFlow` An object flow is an activity edge that can have objects or data passing along it.
`interface`	`ACObjectNode` An object node is an activity node that indicates an instance of a particular classifier, possibly in a particular state, and may be available at a particular point in the activity.
`interface`	`ACParamNode` An activity parameter node is an object node for inputs and outputs to activities.
`interface`	`ACPartition` An activity partition is a kind of activity group that identifies actions that have common characteristics.
`interface`	`ACStructuredNode` A structured activity node is an executable activity node that may have an expansion into subordinate nodes as an ActivityGroup.
`interface`	`ACVariable` Variables are elements for passing data between actions indirectly.
`interface`	`ANAcceptCall` AcceptCallAction is an accept event action that represents the receipt of a synchronous call request.
`interface`	`ANAcceptEvent` AcceptEventAction is an action that waits for the occurrence of an event meeting specified condition.
`interface`	`ANAction` An action is a named element that is the fundamental unit of executable functionality.
`interface`	`ANActionInputPin` An action input pin is a kind of pin that executes an action to determine the values to input to another.
`interface`	`ANAddStructuralFeatureValue` Structural features are potentially multi-valued and ordered; this means that the action supports specification of insertion points for new values.
`interface`	`ANBroadcastSignal` BroadcastSignalAction is an action that transmits a signal instance to all the potential target objects in the system.
`interface`	`ANCall` CallAction is an abstract class for actions that invoke behavior and receive return values.
`interface`	`ANCallBehavior` A CallBehaviorAction is a call action that invokes a behavior directly rather than invoking a behavioral feature that, in turn, results in the invocation of that behavior.
`interface`	`ANCallOperation` CallOperationAction is an action that transmits an operation call request to the target object where it may cause the invocation of associated behavior.
`interface`	`ANClearAssociation` This action destroys all links of an association that have a particular object at one end.
`interface`	`ANClearStructuralFeature` This action removes all values of a structural feature.
`interface`	`ANCreateLink` This action can be used to create links and link objects.
`interface`	`ANCreateObject` This action instantiates a classifier.
`interface`	`ANDestroyLink` This action destroys a link or a link object.
`interface`	`ANDestroyObject` This action destroys the object on its input pin at runtime.
`interface`	`ANInputPin` An input pin is a pin that holds input values to be consumed by an action.
`interface`	`ANInvocation` Invocation is an abstract class for the various actions that invoke behavior.
`interface`	`ANLink` A link action creates, destroys or reads links, identifying a link by its end objects and qualifier values, if any.
`interface`	`ANOpaque` An action with implementation-specific semantics.
`interface`	`ANOutputPin` An output pin is a pin that holds output values produced by an action.
`interface`	`ANPin` A pin is a typed element and multiplicity element that provides values to actions and accept result values from them.
`interface`	`ANRaiseException` Action that causes an exception to occur.
`interface`	`ANReadLink` This action navigates an association towards one end which is the end that does not have an input pin to take its object (the "open" end).
`interface`	`ANReadSelf` Every action is ultimately a part of some behavior, which is in turn optionally attached in some way to the specification of a classifier -- for example, as the body of a method or as part of a state machine.
`interface`	`ANReadStructuralFeature` This action reads the values of a structural feature in order if the structural feature is ordered.r
`interface`	`ANRemoveStructuralFeatureValue` The object to access is specified dynamically by referring to an input pin which the object will be placed on at runtime.
`interface`	`ANReply` Action that accepts a set of return values and a value containing return information produced by a previous accept call action.
`interface`	`ANSendObject` SendObjectAction is an action that transmits an object to the target object where it may invoke behavior such as the firing of state machine transitions or the execution of an activity.
`interface`	`ANSendSignal` SendSignalAction is an action that creates a signal instance from its inputs and transmits it to the target object where it may cause the firing of a state machine transition or the execution of an activity.
`interface`	`ANStructuralFeature` This abstract action class statically specifies the structural feature being accessed.
`interface`	`ANTestIdentity` This action returns true if the two input values are the same identity, false if they are not.
`interface`	`ANUnmarshall` Action that breaks an object of a known type into outputs each of which is equal to a value froma structural feature of the object.
`interface`	`ANValSpec` The action returns the result of evaluating a value specification.
`interface`	`ANValuePin` A value pin is an input pin that provides a value by evaluating a value specification.
`interface`	`ANWriteLink` A write link action takes a complete identification of a link and creates or destroys it.
`interface`	`ANWriteStructuralFeature` A write structural feature action operates on a structural feature of an object to modify its values.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2bc

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2bc
`interface`	`BCBaseElement` This is a utility class for BCBaseElement that provides static methods for creation or other purposes.
`interface`	`BCBaseNamedStereotypeAble` This is a utility class for BCBaseNamedStereotypeAble that provides static methods for creation or other purposes.
`interface`	`BCExpression`
`interface`	`BCProperty`
`interface`	`BCPropertySet`
`interface`	`BCRelshipBinDir` This is a utility class for BCRelshipBinDir that provides static methods for creation or other purposes.
`interface`	`BCRootReuseAbleElement` This is a utility class for BCRootReuseAbleElement that provides static methods for creation or other purposes.
`interface`	`BCTerm` A term relevant for the business description.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2be

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2be
`interface`	`BEAnyReceiveEvent` A transition trigger associated with AnyReceiveEvent specifies that the transition is to be triggered by the receipt of any message that is not explicitly referenced in another transition from the same vertex.
`interface`	`BEBehavior` Behavior is a specification of how its context classifier changes state over time.
`interface`	`BECallEvent` A call event represents the reception of a request to invoke a specific operation.
`interface`	`BEChangeEvent` A change event occurs when a Boolean-valued expression becomes true, for example, as a result of a change in the value held in a slot corresponding to an attribute.
`interface`	`BECreationEvent` A creation event represents the creation of an instance.
`interface`	`BEDestructionEvent` A destruction event represents the destruction of the instance described by the lifeline that contains the OccurrenceSpecification that references the destruction event.
`interface`	`BEEvent` An event is the specification of some occurrence that may potentially trigger effects by an object.
`interface`	`BEExecutionEvent` An execution event represents the start or finish of the execution of an action or a behavior.
`interface`	`BEMessageEvent` A message event specifies the receipt by an object of either a call or a signal.
`interface`	`BEOpaque` The semantics of the behavior is determined by the implementation.
`interface`	`BEReceiveOperEvent` This specifies the event of receiving an operation invocation for a particular operation by the target entity.
`interface`	`BEReceiveSignalEvent` This specifies the event of receiving a signal by the target entity.
`interface`	`BESendOperEvent` A send operation event specifies the sending of a request to invoke a specific operation on an object.
`interface`	`BESendSignalEvent` A send signal event specifies the sending of a message to a receiver object.
`interface`	`BESignalEvent` A signal event represents the receipt of an asynchronous signal.
`interface`	`BETimeEvent` A time event specifies a point in time by an expression.
`interface`	`BETrigger` A trigger specifies an event that may cause the execution by the execution of an action, but need not be.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2bp

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2bp
`interface`	`BPActivityNode` This is a utility class for BPActivityNode that provides static methods for creation or other purposes.
`interface`	`BPActivityResource` The activity resource specifies the business entity or role or system to perform or work on the activity.
`interface`	`BPArtifact` "BPMN provides modelers with the capability of showing additional information about a Process that is not directly related to the Sequence Flow or Message Flow of the Process.
`interface`	`BPAssociationArtifact` Note that directional Associations were used in BPMN 1.2 to show how Data Objects were inputs or outputs to Activities.
`interface`	`BPCallAble` This is a utility class for BPCallAble that provides static methods for creation or other purposes.
`interface`	`BPCallAbleChoreographyElement` This is a utility class for BPCallAbleChoreographyElement that provides static methods for creation or other purposes.
`interface`	`BPCallAbleProcessElement` This is a utility class for BPCallAbleProcessElement that provides static methods for creation or other purposes.
`interface`	`BPChoreography`
`interface`	`BPChoreographyActivity` This is a utility class for BPChoreographyActivity that provides static methods for creation or other purposes.
`interface`	`BPChoreographySubProcess`
`interface`	`BPChoreographyTask`
`interface`	`BPCollaboration`
`interface`	`BPConditionalEventDefinition`
`interface`	`BPDataIOAssociation`
`interface`	`BPDataObject`
`interface`	`BPDataStore`
`interface`	`BPEndPoint` The end points element may be extended with endpoint reference definitions introduced in other specifications (e.g., WS-Addressing).
`interface`	`BPError` An error represents the content of an error event or the fault of a failed operation.
`interface`	`BPEscalation` An `BPEscalation` identifies a business situation that a process might need to react to.
`interface`	`BPEventDefinition`
`interface`	`BPEventNode`
`interface`	`BPFlowChoreographyContainer` This is a utility class for BPFlowChoreographyContainer that provides static methods for creation or other purposes.
`interface`	`BPFlowElement` This is a utility class for BPFlowElement that provides static methods for creation or other purposes.
`interface`	`BPFlowElementContainer` This is a utility class for BPFlowElementContainer that provides static methods for creation or other purposes.
`interface`	`BPFlowProcessContainer` This is a utility class for BPFlowProcessContainer that provides static methods for creation or other purposes.
`interface`	`BPGateway`
`interface`	`BPGlobalChoreographyTask`
`interface`	`BPGlobalMaskTask`
`interface`	`BPGlobalTask`
`interface`	`BPGlobalTaskResource`
`interface`	`BPGroupArtifact`
`interface`	`BPGroupAssign`
`interface`	`BPInputSet`
`interface`	`BPInterface` An interface defines a set of operations that are implemented by services.
`interface`	`BPItemAwareElement` This is a utility class for BPItemAwareElement that provides static methods for creation or other purposes.
`interface`	`BPItemDefinition` The Business Object defines an object important for the definition of business processes or concepts.
`interface`	`BPItemDefinitionRel`
`interface`	`BPLane` Lanes are used to organize and categorize activities within a Pool.
`interface`	`BPLaneSet` The lane set defines the container for one or more lanes.
`interface`	`BPLinkEventDefinition`
`interface`	`BPLoopCharx` This is a utility class for BPLoopCharx that provides static methods for creation or other purposes.
`interface`	`BPMappingAssociation` This is a utility class for BPMappingAssociation that provides static methods for creation or other purposes.
`interface`	`BPMaskDefinition`
`interface`	`BPMaskField`
`interface`	`BPMaskTask`
`interface`	`BPMessage`
`interface`	`BPMessageFlow` On message modification try to set the message on the source and target node of the message flow as well as on message flow itself.
`interface`	`BPMessageFlowMapping`
`interface`	`BPMessageReferencingElement` This is a utility class for BPMessageReferencingElement that provides static methods for creation or other purposes.
`interface`	`BPMultiInstLoopCharx`
`interface`	`BPOperation`
`interface`	`BPOutputSet`
`interface`	`BPParticipant`
`interface`	`BPParticipantMapping`
`interface`	`BPPath` A path in a process.
`interface`	`BPProcess`
`interface`	`BPProperty`
`interface`	`BPSequenceFlow`
`interface`	`BPSequenceFlowNode` This is a utility class for BPSequenceFlowNode that provides static methods for creation or other purposes.
`interface`	`BPSignal` Signal to trigger e.g a signal event.
`interface`	`BPStdLoopCharx`
`interface`	`BPSubProcess`
`interface`	`BPSupportsRel`
`interface`	`BPTaskNode`
`interface`	`BPTimerEventDefinition`
`interface`	`BPUseCaseInteractionRel`
`interface`	`BPUseCasePathRel`

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2bpdia

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2bpdia
`interface`	`BPDia`

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2br

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2br
`interface`	`BRCostCenter`
`interface`	`BRLocation`
`interface`	`BROrgUnit`
`interface`	`BROrgUnitMemberRel`
`interface`	`BROrgUnitPersonRel`
`interface`	`BROrgUnitRequiresRole`
`interface`	`BRPerson`
`interface`	`BRPersonContactData`
`interface`	`BRPersonInRole`
`interface`	`BRResource`
`interface`	`BRResourceCL` An actor specifies a role played by a user or any other system that interacts with the subject.
`interface`	`BRResourceHierRel`
`interface`	`BRResourceNamedRel`
`interface`	`BRResourceNonHierRel` This is a utility class for BRResourceNonHierRel that provides static methods for creation or other purposes.
`interface`	`BRResourceRel` This is a utility class for BRResourceRel that provides static methods for creation or other purposes.
`interface`	`BRRole`
`interface`	`BRTechnical`

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2brdia

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2brdia
`interface`	`BRDia`

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2bs

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2bs
`interface`	`BSFinalState`
`interface`	`BSInitState`
`interface`	`BSPseudoState` This is a utility class for BSPseudoState that provides static methods for creation or other purposes.
`interface`	`BSRegularState`
`interface`	`BSState` This is a utility class for BSState that provides static methods for creation or other purposes.
`interface`	`BSTransition`
`interface`	`BSVertex` This is a utility class for BSVertex that provides static methods for creation or other purposes.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2bsdia

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2bsdia
`interface`	`BSDia`

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2class

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2class
`interface`	`CLActor` An actor specifies a role played by a user or any other system that interacts with the subject.
`interface`	`CLArtifact` An artifact is the specification of a physical piece of information that is used or produced by a software development process or by deployment and operation of a system.
`interface`	`CLAssocClass` A model element that has both association and class properties.
`interface`	`CLAssociation` An association describes a set of tuples whose values refer to typed instances.
`interface`	`CLBehavioralFeature` A behavioral feature is a feature of a classifier that specifies an aspect of the behavior of its instances.
`interface`	`CLClass` The purpose of a class is to specify a classification of objects and to specify the features that characterize the structure and behavior of those objects.
`interface`	`CLClassifierTemplateParameter` A classifier template parameter exposes a classifier as a formal template parameter.
`interface`	`CLCollaboration` A collaboration describes a structure of collaborating elements (roles), each performing a specialized function, which collectively accomplish some desired functionality.
`interface`	`CLCollaborationUse` A collaboration use represents the application of the pattern described by a collaboration to a specific situation involving specific classes or instances playing the roles of the collaboration.
`interface`	`CLCommunicationPath` A communication path is an association between two deployment targets which they are able to exchange signals and messages through.
`interface`	`CLComponent` A component represents a modular part of a system that encapsulates its contents and whose manifestation is replaceable within its environment.
`interface`	`CLComponentRealization` The component realization concept is specialized in the components package to (optionally) define the classifiers that realize the contract offered by a component in terms of its provided and required interfaces.
`interface`	`CLConnectAbleElement` A ConnectAbleElement is an abstract metaclass representing a set of instances that plays the role of a classifier.
`interface`	`CLConnector` Specifies a link that enables communication between two or more instances.
`interface`	`CLDataType` A data type is a type whose instances are only identified by their value.
`interface`	`CLDeployedArtifact` A deployed artifact is an artifact or artifact instance that has been deployed to a deployment target.
`interface`	`CLDeployment` A deployment is the allocation of an artifact or artifact instance to a deployment target.
`interface`	`CLDeploymentSpec` A deployment specification specifies a set of properties that determine execution parameters of a component artifact that is deployed on a node.
`interface`	`CLDeploymentTarget` A deployment target is the location for a deployed artifact.
`interface`	`CLDevice` A device is a physical computational resource with processing capability which artifacts may be deployed for execution on.
`interface`	`CLEnumeration` An enumeration is a data type whose values are enumerated in the model as enumeration literals.
`interface`	`CLEnumLiteral` An enumeration literal is a user-defined data value for an enumeration.
`interface`	`CLExecEnv` An execution environment is a node that offers an execution environment for specific types of components that are deployed on it in the form of executable artifacts.
`interface`	`CLExtend` A relationship from an extending use case to an extended use case that specifies how and when the behavior defined in the extending use case can be inserted into the behavior defined in the extended use case.
`interface`	`CLExtensionPoint` An extension point identifies a point in the behavior of a use case where that behavior can be extended by the behavior of some other (extending) use case, as specified by an extend relationship.
`interface`	`CLGeneralization` A generalization relates a specific classifier to a more general classifier and is owned by the specific classifier.
`interface`	`CLInclude` An include relationship defines the fact that a use case contains the behavior defined in another use case.
`interface`	`CLInstanceSpecification` An instance specification is a model element that represents an instance in a modeled system.
`interface`	`CLInstSpec` This is a utility class for CLInstSpec that provides static methods for creation or other purposes.
`interface`	`CLInterface` An interface is a kind of classifier that represents a declaration of a set of coherent public features and obligations.
`interface`	`CLInterfaceRealization` An interface realization is a specialized realization relationship between a classifier and an interface.
`interface`	`CLManifestation` A manifestation is the concrete physical rendering of one or more model elements by an artifact.
`interface`	`CLNode` A node is a computational resource which artifacts may be deployed for execution on.
`interface`	`CLOperation` An operation is a behavioral feature of a classifier that specifies the name, type, parameters and constraints for invoking an associated behavior.
`interface`	`CLParameter` A parameter is a specification of an argument used to pass information into or out of an invocation of a behavioral feature.
`interface`	`CLParameterSet` A parameter set is an element that provides alternative sets of inputs or outputs that a behavior may use.
`interface`	`CLPort` A port is a property of a classifier that specifies a distinct interaction point between that classifier and its environment or between the (behavior of the) classifier and its internal parts.
`interface`	`CLPrimitiveType` A primitive type defines a predefined data type, without any relevant substructure (it has no parts).
`interface`	`CLProperty` A property is a structural feature.
`interface`	`CLReception` A reception is a declaration stating that a classifier is prepared to react to the receipt of a signal.
`interface`	`CLRoleBinding`
`interface`	`CLSignal` A signal is a specification of send request instances communicated between objects.
`interface`	`CLStructureDefinition`
`interface`	`CLStructureElement` This is a utility class for CLStructureElement that provides static methods for creation or other purposes.
`interface`	`CLStructureEntry`
`interface`	`CLStructureGroup`
`interface`	`CLSubstitution` A substitution is a relationship between two classifiers and signifies that the substituting classifier complies with the contract specified by the contract classifier.
`interface`	`CLTemplateBinding` A `CLTemplateBinding` represents a relationship between a templateable element and a template.
`interface`	`CLTemplateParameter` A template parameter exposes a parameter able element as as formal template parameter of a template.
`interface`	`CLTemplateParameterAbleClass`
`interface`	`CLUseCase` A use case is the specification of a set of actions performed by a system.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2cldia

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2cldia
`interface`	`CLClassDia` The following nodes and edges are typically drawn in a class diagram: Association Aggregation Class Composition Dependency Generalization Interface InterfaceRealization Realization
`interface`	`CLComponentDia` The following nodes and edges are typically drawn in a component diagram: Component Interface ComponentRealization, InterfaceRealization, Usage Dependencies Class Artifact Port
`interface`	`CLCompositeStructureDia` A composite structure diagram depicts the internal structure of a classifier, as well as the use of a collaboration in a collaboration use.
`interface`	`CLDeploymentDia`
`interface`	`CLDia` This is a utility class for CLDia that provides static methods for creation or other purposes.
`interface`	`CLHierarchyAbleDia` This is a utility class for CLHierarchyAbleDia that provides static methods for creation or other purposes.
`interface`	`CLRequirementDia`
`interface`	`CLStructureDefinitionDia`
`interface`	`CLUseCaseDia` Use case diagrams are a specialization of class diagrams; the classifiers shown are restricted to being either actors or use cases.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2db

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2db
`interface`	`DBAuthorization` This is a utility class for DBAuthorization that provides static methods for creation or other purposes.
`interface`	`DBAuthorizationIdentifier` This is a utility class for DBAuthorizationIdentifier that provides static methods for creation or other purposes.
`interface`	`DBCheckConstraint`
`interface`	`DBColumn` This is a utility class for DBColumn that provides static methods for creation or other purposes.
`interface`	`DBColumnSet` An `DBColumnSet` can be a `DBTable` or a `DBView`.
`interface`	`DBForeignKey`
`interface`	`DBGroup`
`interface`	`DBIndex`
`interface`	`DBIndexedColumn`
`interface`	`DBMergedTable` The merge methods of `DBTable` are creating a `DBMergedTable` to keep information which was the assimilated table.
`interface`	`DBPackage` A `DBPackage` is both a `MEPackage` for organizing elements in a tree and a `DBSQLObject` for modeling privileges or relationships to other SQL obejcts.
`interface`	`DBPrivilege`
`interface`	`DBProcedureExpression`
`interface`	`DBRole`
`interface`	`DBRoleAuthorization`
`interface`	`DBSiblingConstraint`
`interface`	`DBSQLGeneric`
`interface`	`DBStoredProcedure`
`interface`	`DBTable` An `DBTable` as part of the Relational Database Model is specified by its columns.
`interface`	`DBTableColumn`
`interface`	`DBTrigger`
`interface`	`DBUniqueKey`
`interface`	`DBUser`
`interface`	`DBView`
`interface`	`DBViewColumn`
`interface`	`DBViewFrom`

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2dbdia

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2dbdia
`interface`	`DBDia`

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2dg

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2dg
`interface`	`DGCommand` Represents a documentation command.
`interface`	`DGConfig` Contains the index information for a documentation selection.
`interface`	`DGDocuStructureRoot` The root of a documentation structure.
`interface`	`DGFooter` Represents the footer of a documentation's section.
`interface`	`DGHeader` Represents the header of a documentation's section.
`interface`	`DGSelection` A documentation selection links a documentation structure to layout information such as title page, header information, footer information and documentation configuration.
`interface`	`DGTemplate` A template of documentation standard chapters for common usage in documentation structures.
`interface`	`DGTitle` Represents the title page of a documentation.
`interface`	`DGTreeTemplate` A template of documentation standard chapters for common usage in model browsers.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2elem

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2elem
`interface`	`ELComment` Represents a common comment.
`interface`	`ELConstraint` This is a utility class for ELConstraint that provides static methods for creation or other purposes.

Fields in de.mid.innovator.srv2api.icw2elem declared as ELUUIDAble
`ELUUIDAble`	`ARG_ElementUUID.ohElem` uuid able element

Fields in de.mid.innovator.srv2api.icw2elem with type parameters of type ELUUIDAble
`List<ELUUIDAble>`	`ARG_ModifyUUIDOclReq.element` UUIDAble Element which UUID should be modified
`List<ELUUIDAble>`	`ARG_ModifyUUIDOclCmd.element` UUIDAble Element which UUID should be modified
`List<ELUUIDAble>`	`ARG_AssignNewUUIDOclCmd.seqElem` these elements gain a new uuid

Methods in de.mid.innovator.srv2api.icw2elem with type parameters of type ELUUIDAble

static



<T extends ELUUIDAble> 


List<T>

ELUUIDAbleHelper.getFindByUUID(Class<T> returnType,
              SrvContext srvCtx,
              String sIUUID,
              ELElement optADModel)

Returns the model elements described by the Innovator UUID, if they exist.

Method parameters in de.mid.innovator.srv2api.icw2elem with type arguments of type ELUUIDAble
`static void`	`ELUUIDAbleHelper.assignNewUUID(SrvContext srvCtx, List<? extends ELUUIDAble> seqElem)` Assign every element a new uuid.
`static ARG_ModifyUUIDOclCmd`	`ELUUIDAbleHelper.getModifyUUID(SrvContext srvCtx, List<? extends ELUUIDAble> element)` Returns a filled structure ARG_ModifyUUIDOclCmd for a bulk of UUIDAble elements, who's UUIDs should be new generated.
`static void`	`ELUUIDAbleHelper.modifyUUID(SrvContext srvCtx, List<? extends ELUUIDAble> element, List<String> sUUID)` Sets the UUIDs for the elements specified in the input data structure.

Constructors in de.mid.innovator.srv2api.icw2elem with parameters of type ELUUIDAble
`ARG_ElementUUID(ELUUIDAble ohElem, String strUUID)`

Constructor parameters in de.mid.innovator.srv2api.icw2elem with type arguments of type ELUUIDAble
`ARG_AssignNewUUIDOclCmd(List<ELUUIDAble> seqElem)`
`ARG_ModifyUUIDOclCmd(List<ELUUIDAble> element, List<String> sUUID)`
`ARG_ModifyUUIDOclReq(List<ELUUIDAble> element)`

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2er

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2er
`interface`	`BI2Cube`
`interface`	`BI2CubeDimension`
`interface`	`BI2CubeDimensionHierarchy`
`interface`	`BI2DimensionAttribute` This is a utility class for BI2DimensionAttribute that provides static methods for creation or other purposes.
`interface`	`BI2DimensionIdAttribute`
`interface`	`BI2DimensionLevel`
`interface`	`BI2DimensionPrecedence`
`interface`	`BI2DimensionShowAttribute`
`interface`	`BI2DimensionSortAttribute`
`interface`	`BI2DimensionTree`
`interface`	`BI2Hierarchy`
`interface`	`BI2HierarchyLevel`
`interface`	`BI2MeasurementTime` A `BI2MeasurementTime` defines the rule, at which point of time the data are determined.
`interface`	`BIHierarchy` A `BIHierarchy` defines a dimension chain used by a fact entity of the data warehouse model.
`interface`	`BIHierarchyRole` A `BIHierarchyRole` is a specialization of a `ERRelationship`.
`interface`	`ERAttribute` An `ERAttribute` is a property of an `EREntity`.
`interface`	`ERAttributeSet` An `ERAttributeSet` of the Entity Relationship Model can be an `EREntity` or a `ERView`.
`interface`	`ERCheckConstraint` A `ERCheckConstraint` describes the value consistency of the attributes.
`interface`	`EREntity` An `EREntity` as part of the Entity Relationship Model is specified by its attributes and its relationships to other entities.
`interface`	`ERForeignKey` A `ERForeignKey` is a collection of attributes of its `EREntity`.
`interface`	`ERGeneralization` A `ERGeneralization` is a special relationship between two entities.
`interface`	`ERGeneralizationSet` A `ERGeneralizationSet` is a collection of generalization relationships to specify disjoint and covering instance sets of the specialization entities.
`interface`	`ERRelationship` A `ERRelationship` connects two entities via `ERRole` roles.
`interface`	`ERRole` A `ERRole` is a part of a `ERRelationship` which connects the relationship to an `EREntity`.
`interface`	`ERUniqueKey` An `ERUniqueKey` is a collection of attributes of its `ERAttributeSet`.
`interface`	`ERUsedAttribute` An `ERUsedAttribute` (`ERAttribute` or `ERViewAttribute`) can be used by an `ERViewElement`.
`interface`	`ERView` A `ERView` to the Entity Relationship Model builds a table by joining and filtering the selected attributes.
`interface`	`ERViewAttribute` An `ERViewAttribute` describes a column of an `ERView`.
`interface`	`ERViewFrom` A `ERViewFrom` of a `ERView` point to an `ERAttributeSet` to use its attributes for viewing or filtering.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2erdia

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2erdia
`interface`	`ERDia` This is a utility class for ERDia that provides static methods for creation or other purposes.
`interface`	`ERDiaAll`

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2gc

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2gc
`interface`	`GCConcept` A concept is a generic modeling construct which may be realized by different model elements.
`interface`	`GCConceptConnection` The directed connection between two concepts.
`interface`	`GCConceptRealization` The realization of a concept by another model element.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2gcdia

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2gcdia
`interface`	`GCDia` A diagram showing concepts and concept connections.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2ia

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2ia
`interface`	`IAActionExecSpec` ActionExecutionSpecification is a kind of ExecutionSpecification that represents the execution of an action.
`interface`	`IAAlt` The interactionOperator 'alt' designates that the CombinedFragment represents a choice of behavior.
`interface`	`IAAssert` The interactionOperator 'assert' designates that the CombinedFragment represents an assertion.
`interface`	`IABehaviorExecSpec` BehaviorExecutionSpecification is a kind of ExecutionSpecification that represents the execution of a behavior.
`interface`	`IABreak` The interactionOperator 'break' designates that the CombinedFragment represents a breaking scenario in the sense that the operand is a scenario that is performed instead of the remainder of the enclosing InteractionFragment.
`interface`	`IACallMessage` The message is generated by a call to an operation.
`interface`	`IACombined` A combined fragment defines an expression of interaction fragments.
`interface`	`IAConsider` The interactionOperator 'consider' designates which messages should be considered within this combined fragment.
`interface`	`IAConstraint` An InteractionConstraint is a Boolean expression that guards an operand in a CombinedFragment.
`interface`	`IAContinuation` A Continuation is a syntactic way to define continuations of different branches of an Alternative CombinedFragment.
`interface`	`IACreateMessage` The message that designates the creation of another lifeline object.
`interface`	`IACritical` The interactionOperator 'critical' designates that the CombinedFragment represents a critical region.
`interface`	`IADestructMessage` The message that designates the termination of another lifeline.
`interface`	`IAExecOccSpec` An ExecutionOccurrenceSpecification represents moments in time which actions or behaviors start or finish at.
`interface`	`IAExecSpec` An ExecutionSpecification is a specification of the execution of a unit of behavior or action within the lifeline.
`interface`	`IAFragment` InteractionFragment is an abstract notion of the most general interaction unit.
`interface`	`IAGate` A gate is a connection point for relating a message outside an InteractionFragment with a message inside an InteractionFragment.
`interface`	`IAIgnore` The interacionOperator 'ignore' designates that there are some message types that are not shown within this combined fragment.
`interface`	`IAInteraction` An interaction is a unit of behavior that focuses on the observable exchange of information between ConnectAbleElements.
`interface`	`IALifeline` A lifeline represents an individual participant in the iteraction.
`interface`	`IALoop` The interactionOperator 'loop' designates that the CombinedFragment represents a loop.
`interface`	`IALostAndFound`
`interface`	`IAMessage` A message is a NamedElement that defines one specific kind of communication in an interaction.
`interface`	`IAMessageEnd` A MessageEnd is an abstract NamedElement that represents what can occur at the end of a message.
`interface`	`IAMessageOccSpec` Specifies the occurrence of message events, such as sending and receiving of signals or invoking or receiving of operation calls.
`interface`	`IANeg` The interactionOperator 'neg' designates that the CombinedFragment represents traces that are defined to be invalid.
`interface`	`IAOccSpec` An OccurrenceSpecification is the basic semantic unit of interactions.
`interface`	`IAOperand` An InteractionOperand is contained in a CombinedFragment.
`interface`	`IAOpt` The interactionOperator 'opt' designates that the CombinedFragment represents a choice of behavior where either the (sole) operand happens or nothing happens.
`interface`	`IAOrdering` A GeneralOrdering represents a binary relation between two OccurrenceSpecifications to describe that one OccurrenceSpecification must occur before the other in a valid trace.
`interface`	`IAPar` The interactionOperator 'par' designates that the CombinedFragment represents a parallel merge between the behaviors of the operands.
`interface`	`IAReplyMessage` The message is a reply message to an operation call.
`interface`	`IASeq` The interactionOperator 'seq' designates that the CombinedFragment represents a weak sequencing between the behaviors of the operands.
`interface`	`IASignalMessage` The message was generated by the asynchronous sending of a signal.
`interface`	`IAStateInvariant` A StateInvariant is a runtime constraint on the participants of the interaction.
`interface`	`IAStrict` The interactionOperator 'strict' designates that the CombinedFragment represents a strict sequencing between the behaviors of the operands.
`interface`	`IAUse` An InteractionUse refers to an interaction.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2im

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2im
`interface`	`IMAssociation` Association between two classifiers.
`interface`	`IMClassifier` Classifier within an Information Management Model.
`interface`	`IMCLDataType`
`interface`	`IMConstraint` This is a utility class for IMConstraint that provides static methods for creation or other purposes.
`interface`	`IMFeature` This is a utility class for IMFeature that provides static methods for creation or other purposes.
`interface`	`IMGeneralization` This is a utility class for IMGeneralization that provides static methods for creation or other purposes.
`interface`	`IMGeneralizationSet` This is a utility class for IMGeneralizationSet that provides static methods for creation or other purposes.
`interface`	`IMIndex` This is a utility class for IMIndex that provides static methods for creation or other purposes.
`interface`	`IMIndexedFeature` This is a utility class for IMIndexedFeature that provides static methods for creation or other purposes.
`interface`	`IMKey` This is a utility class for IMKey that provides static methods for creation or other purposes.
`interface`	`IMKeyRelationship` This is a utility class for IMKeyRelationship that provides static methods for creation or other purposes.
`interface`	`IMProcedure` This is a utility class for IMProcedure that provides static methods for creation or other purposes.
`interface`	`IMProcedureExpression` This is a utility class for IMProcedureExpression that provides static methods for creation or other purposes.
`interface`	`IMProperty` This is a utility class for IMProperty that provides static methods for creation or other purposes.
`interface`	`IMSemanticDataType` A type which describes the semantic of its stored value.
`interface`	`IMSequence` Subclass of `IMSemanticDataType` with automatic unique value.
`interface`	`IMStructuralFeature` This is a utility class for IMStructuralFeature that provides static methods for creation or other purposes.
`interface`	`IMTrigger` This is a utility class for IMTrigger that provides static methods for creation or other purposes.
`interface`	`IMUniqueKey` This is a utility class for IMUniqueKey that provides static methods for creation or other purposes.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2imdia

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2imdia
`interface`	`IMDia` Superclass of `ERDia` and `DBDia`.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2meta

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2meta
`interface`	`ADChangeSet` The currently active change set of the assigned users.
`interface`	`ADMdlUser` Represents a common model user which is used for connecting to a model.
`interface`	`ADModel` Represents a common model.
`interface`	`ADRepository` Represents the repository.
`interface`	`ADUsrRole` Roles are used for access and execution right.
`interface`	`ADXModel` Represents an InoX model.
`interface`	`MM2Association`
`interface`	`MM2Attribute`
`interface`	`MM2Class`
`interface`	`MM2Package`
`interface`	`MM2TypeEnumMember`
`interface`	`MMCreateTemplate`
`interface`	`MMEngineeringSequence`
`interface`	`MMFilter`
`interface`	`MMFontColor`
`interface`	`MMLabel` Represents a label definition.
`interface`	`MMProfile` A profile is a kind of package that extends a reference metamodel.
`interface`	`MMStereotype` A stereotype defines how an existing metaclass may be extended and enables the use of platform-specific or domain-specific terminology or notation in place of, or in addition to, the ones used for the extended metaclass.
`interface`	`MMStereotypeProperty`
`interface`	`MMText` Represents a text definition.
`interface`	`MMTSOption` This is a utility class for MMTSOption that provides static methods for creation or other purposes.
`interface`	`MMTSOptionForeignKey`
`interface`	`MMTSOptionIndex`
`interface`	`MMTSOptionIndexedColumn`
`interface`	`MMTSOptionTable`
`interface`	`MMTSOptionTableColumn`
`interface`	`MMTSOptionUniqueKey`
`interface`	`MMTSOptionView`
`interface`	`MMTSOptionViewColumn`
`interface`	`MMTSOptionViewFrom`
`interface`	`MMTSType`
`interface`	`MMTypeSystem`
`interface`	`MMVerify`
`interface`	`MMXProfile`

Methods in de.mid.innovator.srv2api.icw2meta with type parameters of type ELUUIDAble





<T extends ELUUIDAble> 


List<T>

ADModel.getFindByUUID(Class<T> returnType,
              MMStereotype stereotype,
              String pattern,
              K_CONTROL_OPTION... behaviourFlags)

The method calls getFindByUUID and filters its return values according to the given stereotype value.





<T extends ELUUIDAble> 


List<T>

ADModel.getFindByUUID(Class<T> returnType,
              String pattern,
              K_CONTROL_OPTION... behaviourFlags)

If they exist, returns the model elements described by the Innovator UUID provided by argument pattern.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2model

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2model
`interface`	`MEAbstraction` An abstraction is a relationship that relates two elements or sets of elements that represent the same concept at different levels of abstraction or from different viewpoints.
`interface`	`MEAssignAbleConstraint` This is a utility class for MEAssignAbleConstraint that provides static methods for creation or other purposes.
`interface`	`MEAttachment`
`interface`	`MEComment` A comment gives the ability to attach various remarks to elements.
`interface`	`MEConfigurationManagement` Configuration management package.
`interface`	`MEConstraint` A constraint is a condition or restriction expressed in natural language text or in a machine readable language for the purpose of declaring some of the semantics of an element.
`interface`	`MECopy`
`interface`	`MECreateRedirect`
`interface`	`MEDependency` A dependency is a relationship that signifies that a single or a set of model elements requires other model elements for their specification or implementation.
`interface`	`MEDurationConstraint` A DurationConstraint defines a Constraint that refers to a DurationInterval.
`interface`	`MEElementImport` An element import identifies an element in another package and allows the element to be referenced using its name without a qualifier.
`interface`	`MEHierarchyAble` Abstract superclass for Metaclasses which may own PackageableElements, e.g.
`interface`	`MEIntervalConstraint` An IntervalConstraint defines a constraint that refers to an interval.
`interface`	`MEMappingConfigurationPackage` Abstract mapping configuration package.
`interface`	`MEMappingConfigurationPackageForward` Mapping configuration package forward direction.
`interface`	`MEMappingConfigurationPackageReverse` Mapping configuration package reverse direction.
`interface`	`MEMappingDependency` Mapping dependendcy is a subclass of `MEDependency`.
`interface`	`MEMappingPackageContent` Package used for content below MappingPackageType.
`interface`	`MEMappingPackageType` Abstract mapping package type defines the mapping type.
`interface`	`MEMappingPackageTypeForward` Implementing mapping type with direction FORWARD.
`interface`	`MEMappingPackageTypeReverse` Implementing mapping type with direction REVERSE.
`interface`	`MEModel` A model captures a view of a physical system.
`interface`	`MENamespaceAsgnAble` A named element represents elements that may have a name.
`interface`	`MEPackage` A package is a namespace for its members and may contain other packages.
`interface`	`MEPackageAble` A packageable element indicates a named element that may be owned directly by a package.
`interface`	`MEPackageImport` A package import is a relationship that allows the use of unqualified names to refer to package members from other namespaces.
`interface`	`MEProxyAssignment` Specialized depencency for associating MEProxy and tangible elements.
`interface`	`MERealization` Realization is a specialized abstraction relationship between two sets of model elements, one representing a specification (the supplier) and the other represents an implementation of the latter (the client).
`interface`	`MERefAbleAsResource` This is a utility class for MERefAbleAsResource that provides static methods for creation or other purposes.
`interface`	`MERequirement`
`interface`	`MESection`
`interface`	`MESimpleConstraint`
`interface`	`MEStubPackage` Abstract Stub Package.
`interface`	`MEStubPackageBase` Stub package base package collecting all stub packages within a system model.
`interface`	`MEStubPackageExternalModel` Stub package for external models.
`interface`	`MEStubPackageInnovator` Stub package for Innovator models
`interface`	`MESystemModel`
`interface`	`MESystemModelManagement` System model management package containing MEConfigurationManagement and MEStubPackageBase packages.
`interface`	`METimeConstraint` A TimeConstraint defines a Constraint that refers to a TimeInterval.
`interface`	`MEUsage` A usage is a relationship which one element requires another element (or set of elements) for its full implementation or operation.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2pres

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2pres
`interface`	`PRDiaWhiteboard`
`interface`	`PRVersionAbleDia` This is a utility class for PRVersionAbleDia that provides static methods for creation or other purposes.

Uses of ELUUIDAble in de.mid.innovator.srv2api.icw2sm

Subinterfaces of ELUUIDAble in de.mid.innovator.srv2api.icw2sm
`interface`	`SMChoice` Choice vertices result, when reached, in the dynamic evaluation of the guards of the triggers of its outgoing transitions.
`interface`	`SMDeepHistory` DeepHistory represents the most recent active configuration of the composite state that directly contains this pseudostate - the state configuration that was active when the composite state was last exited.
`interface`	`SMEntryPoint` An entry point pseudostate is an entry point of a state machine or composite state.
`interface`	`SMExitPoint` An exit point pseudostate is an exit point of a state machine or composite state.
`interface`	`SMFinalState` A special kind of state that signifies that the enclosing region is completed.
`interface`	`SMInit` An initial pseudostate represents a default vertex that is the source for a single transition to the default state of a composite state.
`interface`	`SMJoinFork` Joins vertices serve to merge several transitions emanating from source vertices in different orthogonal regions.
`interface`	`SMJunction` Junction vertices are semantic-free vertices that are used to chain multiple transitions together.
`interface`	`SMProtocolStateMachine` A protocol state machine is always defined in the context of a classifier.
`interface`	`SMPseudoState` A pseudostate is an abstraction that encompasses different types of transient vertices in the state machine graph.
`interface`	`SMRegion` A region is an orthogonal part of either a composite state or a state machine.
`interface`	`SMRegularState`
`interface`	`SMShallowHistory` shallowHistory represents the most recent active substate of its containing state (but not the substates of that substate).
`interface`	`SMState` A state model is a situation which an invariant condition (usually implicit) usually holds in.
`interface`	`SMStateMachine` State machines can be used to express the behavior of part of a system.
`interface`	`SMTerminator` Entering a terminate pseudostate implies that the execution of this state machine by means of its context object is terminated.
`interface`	`SMTransExt` kind=external implies that the transition, if triggered, will exit the composite (source) state.
`interface`	`SMTransInt` kind=internal implies that the transition, if triggered, occurs without exiting or entering the source state.
`interface`	`SMTransition` A transition is a directed relationship between a source vertex and a target vertex.
`interface`	`SMVertex` A vertex is an abstraction of a node in a state machine graph.