The CommonBehaviors package is partially copied into the Composite Structures syntax model. This is because that package contains the sub-package Communications, which is required for Composite Structures modeling. More precisely, it allows Receptions to be owned by Interfaces, as a way of enabling a classifier to specify that it provides or requires Receptions for Signals for some of its Ports. The copy of the CommonBehaviors package is partial in the sense that only this sub-package is copied. Note that the CommonBehaviors::Communications package is already part of the fUML Abstract Syntax model. However, the Interface metaclass was explicitly removed from the fUML subset. The following subclause provides details about the content of this sub-package. CommonBehaviors::Communications::Reception does not extend fUML Reception. It is included in the Composite Structures syntax model because it is needed for the merging process described in the Overview subclause of the clause 7. CommonBehaviors::Communications::Interface extends (merge increment) Classes::Interfaces::Interface with the ability to own receptions. Receptions that objects providing this interface are willing to accept. The Classes package is partially copied into the Composite Structures syntax model. This is because it contains the subpackages Dependencies and Interfaces, which are both required for Composite Structures modeling. The copy of the Classes package is partial since only these two subpackages are copied. Note that the Classes package is already part of the fUML Abstract Syntax model. However, the packages Dependencies and Interfaces were explicitly removed from that model. The following subclauses provide details about the content of these two subpackages. The Interfaces package is introduced to enable the definition of required and/or provided features associated with ports. It also includes a mechanism for specifying that a given BehavioredClassifier realizes the features of an Interface. At run time, this information is used to determine if a given object (instance of a BehavioredClassifier) is a valid target for the invocation of a BehavioralFeature (where this feature is specified by an interface). Classes::Interfaces::BehavioredClassifier extends (merge increment) fUML BehavioredClassifier with the ability to own a collection of InterfaceRealization relationships. The set of InterfaceRealizations owned by the BehavioredClassifier. Interface realizations reference the Interfaces of which the BehavioredClassifier is an implementation. Classes::Interfaces::Classifier does not extend fUML Classifier. It is included in the Composite Structures syntax model because it is needed for the merging process described in the Overview subclause of the Abstract Syntax clause 7. Interface is introduced to enable specification of features provided or required on a Port. Through InterfaceRealization relationships, it also enables specifying features that are realized by a given BehavioredClassifier. References all the Classifiers that are defined (nested) within the Class. The attributes (i.e. the properties) owned by the class. The operations owned by the class. References all the Interfaces redefined by this Interface. InterfaceRealization is introduced since it is used to specify the provided Interfaces of a Port. In addition, it is also used to specify that features of the contract Interface are realized by the implementingClassifier of a BehavioredClassifier. References the Interface specifying the conformance contract. References the BehavioredClassifier that owns this Interfacerealization (i.e., the classifier that realizes the Interface to which it points). Classes::Interfaces::Operation extends (merge increment) fUML Operation with the capability to be owned by an Interface. The Interface that owns this Operation. Classes::Interfaces::Property extends (merge increment) fUML Property with the capability to be owned by an Interface. References the Interface that owns the Property The Dependencies package is copied for two reasons. First, it introduces the metaclass Usage, which is needed to specify the required interfaces of a port. Second, it introduces the metaclass Realization, which is a generalization of InterfaceRealization defined in the Interfaces package. Note that metaclasses DirectedRelationship and Substitution, as well as association A_mapping_abstraction are not included, since they are not relevant to Composite Structures modeling. Indicates the dependencies that reference the supplier. Abstraction is introduced to enable modeling of InterfaceRealization. This is an indirect generalization of InterfaceRealization. Classes::Dependencies::Classifier does not extend fUML Classifier. It is included in the Composite Structures syntax model because it is needed for the merging process described in the Overview subclause of the Abstract Syntax clause 7. Dependency is introduced to enable modeling of both Usage and InterfaceRealization relationships. It is a generalization of these two metaclasses. The element(s) dependent on the supplier element(s). In some cases (such as a Trace Abstraction) the assignment of direction (that is, the designation of the client element) is at the discretion of the modeler, and is a stipulation. The element(s) independent of the client element(s), in the same respect and the same dependency relationship. In some directed dependency relationships (such as Refinement Abstractions), a common convention in the domain of class-based OO software is to put the more abstract element in this role. Despite this convention, users of UML may stipulate a sense of dependency suitable for their domain, which makes a more abstract element dependent on that which is more specific. Classes::Dependencies::NamedElement extends (merge increment) fUML NamedElement with the ability to indicate all the Dependencies that reference this NamedElement as a client (property clientDependency). Indicates the dependencies that reference the client. Specifies the namespace that owns the NamedElement. Missing derivation for NamedElement::/namespace : Namespace OCL true Classes::Dependencies::Namespace does not extend fUML Namespace. It is included in the Composite Structures syntax model because it is needed for the merging process described in the Overview subclause of the Abstract Syntax clause 7. A collection of NamedElements owned by the Namespace. Missing derivation for Namespace::/ownedMember : NamedElement OCL true Classes::Dependencies::PackeageableElement does not extend fUML PackageableElement. It is included in the Composite Structures syntax model to make the merging process (described in the Overview subclause of the Abstract Syntax clause 7) meaningful. Realization is introduced to enable modeling of InterfaceRealization. This is a generalization of InterfaceRealization. Usage is introduced since it is required to specify required interfaces of a port. The CompositeStructures package is completely copied into the Composite Structures syntax model. This is because all of its subpackages introduce key modeling concepts underlying Composite Structures. This includes packages InternalStructures, InvocationActions, Ports and StructuredClasses. The following subclauses provide details about the content of these subpackages. The InternalStructures package is introduced to enable modeling of the internal structure of a class as a network of parts, linked through connectors. The topology of parts and connectors places constraints on the runtime structure of a class instance. CompositeStructures::InternalStructures::Class extends (merge increment) fUML Class by making it a StructuredClassifier. CompositeStructures::InternalStructures::Classifier does not extend fUML Classifier. This metaclass is included in the Composite Structures syntax model because it is needed for the merging process described in the Overview subclause of the Abstract Syntax clause 7. Refers to all of the Properties that are direct (i.e. not inherited or imported) attributes of the classifier. ConnectableElement is introduced as an abstract metaclass representing elements than can be interconnected by being attached to the connector ends of connectors. Denotes a set of connector ends that attaches to this connectable element. Missing derivation for ConnectableElement::/end : ConnectorEnd OCL result = ConnectorEnd.allInstances()->select(e | e.role=self) Connector is introduced to enable modeling of interconnections between parts and/or roles, in the context of a structured classifier. This specification introduces the additional constraint that the type of a connector must be defined (i.e., it is not an optional attribute as it is in UML). The rationale for this constraint is given in subclause 8.1. Natural language OCL A Connector must be typed by an association inv: self.type->notEmpty() A connector consists of at least two connector ends, each representing the participation of instances of the classifiers typing the connectable elements attached to this end. The set of connector ends is ordered. A connector may be redefined when its containing classifier is specialized. The redefining connector may have a type that specializes the type of the redefined connector. The types of the connector ends of the redefining connector may specialize the types of the connector ends of the redefined connector. The properties of the connector ends of the redefining connector may be replaced. An optional association that specifies the link corresponding to this connector. ConnectorEnd is introduced to allow modeling of Connectors. A derived association referencing the corresponding association end on the association which types the connector owing this connector end. This association is derived by selecting the association end at the same place in the ordering of association ends as this connector end. The connectable element attached at this connector end. When an instance of the containing classifier is created, a link may (depending on the multiplicities) be created to an instance of the classifier that types this connectable element. Missing derivation for ConnectorEnd::/definingEnd : Property OCL true CompositeStructures::InternalStructures::Feature does not extend fUML Feature. It is included in the Composite Structures syntax model because it is needed for the merging process described in the Overview subclause of the Abstract Syntax clause 7. CompositeStructures::InternalStructures::Property extends (merge increment) fUML Property. By being a ConnectableElement, a Property can be connected to other connectable elements through connectors. StructuredClassifier is introduced to enable modeling of internal structures comprising a network of parts and roles linked by connectors. References the properties owned by the classifier. References the connectors owned by the classifier. References the properties specifying instances that the classifier owns by composition. This association is derived, selecting those owned properties where isComposite is true. References the roles that instances may play in this classifier. Missing derivation for StructuredClassifier::/part : Property OCL true The InvocationActions package introduces extensions to fUML InvocationAction and Trigger to account for ports of an EncapsulatedClassifier. CompositeStructures::InvocationActions::InvocationAction extends (merge increment) fUML InvocationAction so that, in addition of targeting an object, the invocation (i.e., the call for an operation or the emission of a signal) can be made through a specific Port of this object (onPort). A optional port of the receiver object on which the behavioral feature is invoked. CompositeStructures::InternalStructures::Trigger extends (merge increment) fUML Trigger so that a list of Ports can be associated with a Trigger. A optional port of the receiver object on which the behavioral feature is invoked. The Ports package introduces mechanisms enabling a classifier to have Ports. CompositeStructures::Ports::ConnectorEnd extends (merge increment) CompositeStructures::InternalStructures::ConnectorEnd with an additional property (partWithPort), which, when the connected role is a Port, specifies that an instance of this Port is connected in the context of a specific property of the context Classifier. Indicates the role of the internal structure of a classifier with the port to which the connector end is attached. EncapsulatedClassifier extends StructuredClassifier with the ability to own a set of Ports. References a set of ports that an encapsulated classifier owns. Missing derivation for EncapsulatedClassifier::/ownedPort : Port OCL true Port enables specification of interaction points through which instances of an encapsulated classifier can be connected and communicate with their environment or internal parts. Port also enables the specification of a set of Features provided or required by the owning EncapsulatedClassifier, that is, Features defined by provided or required Interfaces associated with the Port. Natural language OCL A behavior port can only belong to an active class. inv: encapsulatedClassifier->notEmpty() and (encapsulatedClassifier.oclIsKindOf(Class) and encapsulatedClassifier.isActive)) Specifies whether requests arriving at this port are sent to the classifier behavior of this classifier. Such ports are referred to as behavior port. Any invocation of a behavioral feature targeted at a behavior port will be handled by the instance of the owning classifier itself, rather than by any instances that this classifier may contain. Specifies the way that the provided and required interfaces are derived from the Port’s Type. The default value is false. If true indicates that this port is used to provide the published functionality of a classifier; if false, this port is used to implement the classifier but is not part of the essential externally-visible functionality of the classifier and can, therefore, be altered or deleted along with the internal implementation of the classifier and other properties that are considered part of its implementation. References the interfaces specifying the set of operations and receptions that the classifier offers to its environment via this port, and which it will handle either directly or by forwarding it to a part of its internal structure. This association is derived according to the value of isConjugated. If isConjugated is false, provided is derived as the union of the sets of interfaces realized by the type of the port and its supertypes, or directly from the type of the port if the port is typed by an interface. If isConjugated is true, it is derived as the union of the sets of interfaces used by the type of the port and its supertypes. A port may be redefined when its containing classifier is specialized. The redefining port may have additional interfaces to those that are associated with the redefined port or it may replace an interface by one of its subtypes. References the interfaces specifying the set of operations and receptions that the classifier expects its environment to handle via this port. This association is derived according to the value of isConjugated. If isConjugated is false, required is derived as the union of the sets of interfaces used by the type of the port and its supertypes. If isConjugated is true, it is derived as the union of the sets of interfaces realized by the type of the port and its supertypes, or directly from the type of the port if the port is typed by an interface. Missing derivation for Port::/provided : Interface OCL true Missing derivation for Port::/required : Interface OCL true The StructuredClasses package is introduced to enable a Class to be structured, which is a key aspect of UML Composite Structures. CompositeStructures::StructuredClasses::Class extends (merge increment) fUML Class with the ability to be structured. A Class can have an internal structure comprising a network of linked parts, as well as a set of Ports. The Components package is partially copied into the Composite Structures syntax model. This is because the Components package contains the sub-package BasicComponents, which is required for Composite Structures modeling. More precisely, it extends (merge increment) CompositeStructures::StructuredClasses::Connector with the property kind , which enables determining whether a given connector is for delegation or for assembly. Note that metaclass Component as well as package Components::PackagingComponents are excluded from this specification, since they do not introduce any concepts impacting the semantics of UML Composite Structures. Components::BasicComponents::Connector extends (merge increment) CompositeStructures::StructuredClasses::Connector with a property indicating the kind (delegation or assembly) of a connector. Indicates the kind of connector. This is derived: a connector with one or more ends connected to a Port which is not on a Part and which is not a behavior port is a delegation; otherwise it is an assembly. Missing derivation for Connector::/kind : ConnectorKind OCL result = if end->exists( role.oclIsKindOf(Port) and partWithPort->isEmpty() and not role.oclAsType(Port).isBehavior) then ConnectorKind::delegation else ConnectorKind::assembly endif ConnectorKind is an enumeration type. Indicates that the connector is an assembly connector. Indicates that the connector is a delegation connector. A CS_InteractionPoint represents the runtime manifestation of a Reference to an Object playing the role of a Port. More specifically, it overrides operation dispatching and signal receptions in order to capture the specific propagation semantics of requests targeting a port. NOTE: This class is related to the following requirements: - R1. The target value of an invocation action may also be a port. In this case, the invocation request is sent to the object owning this port as identified by the port identity, and is, upon arrival, handled as described in "Port" clause // Imports import CompositeStructuresSyntaxAndSemantics.Syntax.Classes.Interfaces.Operation; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.Ports.Port; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.StructuredClasses.Class_; import fUML.Semantics.Classes.Kernel.Reference; import fUML.Semantics.CommonBehaviors.BasicBehaviors.Execution; import fUML.Semantics.CommonBehaviors.BasicBehaviors.ParameterValueList; import fUML.Semantics.CommonBehaviors.Communications.SignalInstance; Represents the Reference to the CompositeObject owning this InteractionPort. NOTE: This is introduced to address requirement R3 (It represents the "link from that instance to the instance of the owning classifier [...] through which communication is forwarded to the instance of the owning classifier or through which the owning classifier communicates) The Port for which this InteractionPoint is a runtime manifestation Java // Overriden to do nothing Java // Delegates dispatching to the owning object return this.owner.dispatchIn(operation, this) ; Java // Delegates sending to the owning object this.owner.sendIn(signalInstance, this) ; <<TextualRepresentation>>public startBehavior (in classifier : Class [0..1], in inputs : ParameterValue [*]) { // Overriden to do nothing } <<TextualRepresentation>>public dispatch (in operation : Operation ) : Execution { // Delegates dispatching to the owning object return this.owner.dispatchIn(operation, this) ; } <<TextualRepresentation>>public send (in signalInstance : SignalInstance ) { // Delegates sending to the owning object this.owner.sendIn(signalInstance, this) ; } CS_Link extends Link with the ability to specify that this association instance plays a particular Connector. NOTE: The execution model described in this specification makes the hypothesis that connectors are necessarily typed by an Association. // Imports import fUML.Semantics.Classes.Kernel.FeatureValue; import fUML.Semantics.Classes.Kernel.FeatureValueList; import fUML.Semantics.Classes.Kernel.Link; import fUML.Semantics.Classes.Kernel.Value; Java // Returns true if the given value object is used as a value for a FeatureValue of this link FeatureValueList allFeatureValues = this.getFeatureValues() ; Integer i = 1 ; boolean isAValue = false ; while (i <= allFeatureValues.size() && !isAValue) { FeatureValue featureValue = allFeatureValues.getValue(i-1); isAValue = !featureValue.values.isEmpty() && featureValue.values.getValue(0).equals(value) ; i = i + 1 ; } return isAValue ; Java FeatureValueList allFeatureValues = this.getFeatureValues() ; Integer i = 1 ; StructuralFeature feature = null ; while (i <= allFeatureValues.size() && feature == null) { FeatureValue featureValue = allFeatureValues.get(i-1); if (!featureValue.values.isEmpty() && featureValue.values.get(0).equals(value)) { feature = featureValue.feature ; } i = i + 1 ; } return feature ; CS_Object extends fUML Object with specific operations for managing propagations of requests through ports, from the environment to the internals of this object, or from the objet to its environment. NOTE, this class addresses the following requirements: - R4: If connectors are attached to both the port when used on a property within the internal structure of a classifier and the port on the container of an internal structure, the instance of the owning classifier will forward any requests arriving at this port along the link specified by those connectors. - R5: If there is a connector attached to only one side of a port, any requests arriving at this port will terminante at this port [Non-behavior port] - R6: For a behavior port, the instance of the owning classifier will handle requests arriving at this port (as specified in the behavior of the classifier), if this classifier has any behavior. - R7: If there is no behavior defined for this classifier, any communication arriving at a behavior port is lost. - R8: If several connectors are attached on one side of a port, then any request arriving at this port on a link derived from a connector on the other side of the port will be fowarded on links corresponding to these connectors. It is a semantic variation point whether these requests will be forwarded on all links, or on only one of those links. // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.CommonBehaviors.Communications.CS_DispatchOperationOfInterfaceStrategy; import CompositeStructuresSyntaxAndSemantics.Semantics.CommonBehaviors.Communications.CS_StructuralFeatureOfInterfaceAccessStrategy; import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.InvocationActions.CS_RequestPropagationStrategy; import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.InvocationActions.CS_SignalInstance; import CompositeStructuresSyntaxAndSemantics.Syntax.Classes.Dependencies.NamedElement; import CompositeStructuresSyntaxAndSemantics.Syntax.Classes.Interfaces.Operation; import CompositeStructuresSyntaxAndSemantics.Syntax.CommonBehaviors.Communications.Interface; import CompositeStructuresSyntaxAndSemantics.Syntax.CommonBehaviors.Communications.InterfaceList; import CompositeStructuresSyntaxAndSemantics.Syntax.Components.BasicComponents.ConnectorKind; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.InternalStructures.ClassifierList; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.Ports.Port; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.StructuredClasses.Class_; import fUML.Semantics.Actions.BasicActions.CallOperationActionActivation; import fUML.Semantics.Actions.BasicActions.SendSignalActionActivation; import fUML.Semantics.Classes.Kernel.ExtensionalValue; import fUML.Semantics.Classes.Kernel.ExtensionalValueList; import fUML.Semantics.Classes.Kernel.FeatureValue; import fUML.Semantics.Classes.Kernel.FeatureValueList; import fUML.Semantics.Classes.Kernel.Object_; import fUML.Semantics.Classes.Kernel.Reference; import fUML.Semantics.Classes.Kernel.ReferenceList; import fUML.Semantics.Classes.Kernel.Value; import fUML.Semantics.Classes.Kernel.ValueList; import fUML.Semantics.CommonBehaviors.BasicBehaviors.Execution; import fUML.Semantics.CommonBehaviors.Communications.SignalInstance; import fUML.Semantics.Loci.LociL1.ChoiceStrategy; import fUML.Syntax.Classes.Kernel.NamedElementList; import fUML.Syntax.Classes.Kernel.StructuralFeature; import fUML.Syntax.Classes.Kernel.Type; import fUML.Syntax.Classes.Kernel.TypeList; import fUML.Syntax.CommonBehaviors.Communications.Reception; import fUML.Syntax.CommonBehaviors.Communications.Signal; Java // If the interaction point refers to a behavior port, does nothing [for the moment... ?], // since the only kind of event supported in fUML is SignalEvent // If it does not refer to a behavior port, select appropriate delegation links // from interactionPoint, and propagates the operation call through // these links Execution execution = null ; if (interactionPoint.definingPort.isBehavior) { // Do nothing } else { boolean operationIsProvided = true ; ReferenceList potentialTargets = new ReferenceList() ; CS_LinkList cddLinks = this.getLinks(interactionPoint) ; Integer linkIndex = 1 ; while (linkIndex <= cddLinks.size()) { ReferenceList validTargets = this.selectTargetsForDispatching(cddLinks.getValue(linkIndex - 1), interactionPoint, ConnectorKind.delegation, operation, operationIsProvided) ; Integer targetIndex = 1 ; while(targetIndex <= validTargets.size()) { potentialTargets.add(validTargets.getValue(targetIndex-1)) ; targetIndex = targetIndex + 1 ; } linkIndex = linkIndex + 1 ; } // If potentialTargets is empty, no delegation target have been found, // and the operation call will be lost if (! (potentialTargets.size()==0)) { CS_RequestPropagationStrategy strategy = (CS_RequestPropagationStrategy)this.locus.factory.getStrategy("requestPropagation") ; // Choose one target non-deterministically ReferenceList targets = strategy.select(potentialTargets, new CallOperationActionActivation()) ; Reference target = targets.getValue(0) ; execution = target.dispatch(operation) ; } } return execution ; Java // If the interaction is a behavior port, // creates a CS_SignalInstance from the signal instance, // sets its interaction point, // and sends it to the target object using operation send // If this is not a behavior port, // select appropriate delegation targets from interactionPoint, // and propagates the signal to these targets if (interactionPoint.definingPort.isBehavior) { CS_SignalInstance newSignalInstance = (CS_SignalInstance)signalInstance.copy() ; newSignalInstance.interactionPoint = interactionPoint ; this.send(newSignalInstance) ; } else { boolean receptionIsProvided = true ; ReferenceList potentialTargets = new ReferenceList() ; CS_LinkList cddLinks = this.getLinks(interactionPoint) ; Integer linkIndex = 1 ; while (linkIndex <= cddLinks.size()) { ReferenceList validTargets = this.selectTargetsForSending(cddLinks.getValue(linkIndex - 1), interactionPoint, ConnectorKind.delegation, signalInstance.type, receptionIsProvided) ; Integer targetIndex = 1 ; while(targetIndex <= validTargets.size()) { potentialTargets.add(validTargets.getValue(targetIndex-1)) ; targetIndex = targetIndex + 1 ; } linkIndex = linkIndex + 1 ; } // If potential targets is empty, no delegation target has been found, // and the signal is lost // Otherwise, do the following concurrently for (int i = 0 ; i < potentialTargets.size() ; i++) { Reference target = potentialTargets.getValue(i) ; CS_SignalInstance newSignalInstance = (CS_SignalInstance)signalInstance.copy() ; newSignalInstance.interactionPoint = interactionPoint ; target.send(newSignalInstance) ; } } Java // From the given link, signal and interaction point, retrieves potential targets (i.e. end values of link) // through which request can be propagated // These targets are attached to interaction point through the given link, and respect the following rules: // - if toInternal is true, connectorKind must be Delegation, the given link has to target the internals of this CS_Object // - if toInternal is false, the given link has to target the environment of this CS_Object. ReferenceList potentialTargets = new ReferenceList() ; if (toInternal && connectorKind == ConnectorKind.delegation) { if (this.getLinkKind(link, interactionPoint) == CS_LinkKind.ToInternal) { Integer i = 1 ; while(i <= link.getFeatureValues().size()) { ValueList values = link.getFeatureValues().get(i-1).values ; if (!values.isEmpty()) { Integer j = 1 ; while (j <= values.size()) { Reference cddTarget = (Reference)values.get(j-1) ; if (!cddTarget.equals(interactionPoint)) { potentialTargets.add(cddTarget) ; } j = j + 1 ; } } i = i + 1 ; } } } else { // to Environment if (this.getLinkKind(link, interactionPoint) == CS_LinkKind.ToEnvironment) { Integer i = 1 ; while(i <= link.getFeatureValues().size()) { ValueList values = link.getFeatureValues().get(i-1).values ; if (!values.isEmpty() && values.get(0) instanceof Reference) { Reference cddTarget = (Reference)values.get(0) ; if (connectorKind == ConnectorKind.assembly) { if (! (cddTarget instanceof CS_InteractionPoint)) { // This is an assembly link potentialTargets.add(cddTarget) ; } else { // This is an assembly if the interaction point is not a feature value // for a container of this CS_Object CS_ObjectList directContainers = this.getDirectContainers() ; boolean isAssembly = true ; Integer j = 1 ; if (! this.hasValueForAFeature(cddTarget)) { while (isAssembly && j <= directContainers.size()) { CS_Object container = directContainers.get(j - 1) ; if (container.hasValueForAFeature(cddTarget)) { isAssembly = false ; } j++ ; } } else { isAssembly = false ; } if (isAssembly) { potentialTargets.add(cddTarget) ; } } } else { // delegation // This is a delegation if the target is an interaction point // and if this interaction is a feature value for a container of this CS_Object if (cddTarget instanceof CS_InteractionPoint) { CS_ObjectList directContainers = this.getDirectContainers() ; boolean isDelegation = false ; Integer j = 1 ; while (!isDelegation && j <= directContainers.size()) { CS_Object container = directContainers.get(j - 1) ; if (container.hasValueForAFeature(cddTarget)) { isDelegation = true ; } j++ ; } if (isDelegation) { potentialTargets.add(cddTarget) ; } } } } i = i + 1 ; } } } return potentialTargets ; Java // From the given link, operation and interaction point, retrieves potential targets (i.e. end values of link) // through which request can be propagated // These targets are attached to interaction point through the given link, and respect the following rules: // - if toInternal is true, connectorKind must be Delegation, the given link has to target the internals of this CS_Object, // and a valid target must provide the Operation // - if toInternal is false, the given link has to target the environment of this CS_Object. // - if connectorKind is assembly, a valid target has to provide the operation // - if connectorKind is delegation, a valid target has to require the operation ReferenceList potentialTargets = new ReferenceList() ; if (toInternal && connectorKind == ConnectorKind.delegation) { if (this.getLinkKind(link, interactionPoint) == CS_LinkKind.ToInternal) { Integer i = 1 ; while(i <= link.getFeatureValues().size()) { ValueList values = link.getFeatureValues().get(i-1).values ; if (!values.isEmpty() && values.get(0) instanceof Reference) { Reference cddTarget = (Reference)values.get(0) ; if (cddTarget != interactionPoint && this.isOperationProvided(cddTarget, operation)) { potentialTargets.add(cddTarget) ; } } i = i + 1 ; } } } else { // to environment if (this.getLinkKind(link, interactionPoint) == CS_LinkKind.ToEnvironment) { Integer i = 1 ; while(i <= link.getFeatureValues().size()) { ValueList values = link.getFeatureValues().get(i-1).values ; if (!values.isEmpty() && values.get(0) instanceof Reference) { Reference cddTarget = (Reference)values.get(0) ; if (connectorKind == ConnectorKind.assembly) { if (! (cddTarget instanceof CS_InteractionPoint)) { // This is an assembly link if (this.isOperationProvided(cddTarget, operation)) { potentialTargets.add(cddTarget) ; } } else { // This is an assembly if the interaction point is not a feature value // for a container of this CS_Object CS_ObjectList directContainers = this.getDirectContainers() ; boolean isAssembly = true ; Integer j = 1 ; if (! this.hasValueForAFeature(cddTarget)) { while (isAssembly && j <= directContainers.size()) { CS_Object container = directContainers.get(j - 1) ; if (container.hasValueForAFeature(cddTarget)) { isAssembly = false ; } j++ ; } } else { isAssembly = false ; } if (isAssembly) { if (this.isOperationProvided(cddTarget, operation)) { potentialTargets.add(cddTarget) ; } } } } else { // delegation // This is a delegation if the target is an interaction point // and if this interaction is a feature value for a container of this CS_Object if (cddTarget instanceof CS_InteractionPoint) { CS_ObjectList directContainers = this.getDirectContainers() ; boolean isDelegation = false ; Integer j = 1 ; while (!isDelegation && j <= directContainers.size()) { CS_Object container = directContainers.get(j - 1) ; if (container.hasValueForAFeature(cddTarget)) { isDelegation = true ; } j++ ; } if (isDelegation) { if (this.isOperationRequired(cddTarget, operation)) { potentialTargets.add(cddTarget) ; } } } } } i = i + 1 ; } } } return potentialTargets ; Java // Select appropriate delegation links from interactionPoint, // and propagates the signal instance through these links // Appropriate links are links which target elements // in the environment of this CS_Object. // These can be delegation links (i.e, the targeted elements must // require a reception for the signal) or assembly links (i.e., the target elements // must provide a reception for the signal) boolean receptionIsNotProvided = false ; // i.e. it is required ReferenceList allPotentialTargets = new ReferenceList() ; ReferenceList targetsForSendingIn = new ReferenceList() ; ReferenceList targetsForSendingOut = new ReferenceList() ; CS_LinkList cddLinks = this.getLinks(interactionPoint) ; Integer linkIndex = 1 ; while (linkIndex <= cddLinks.size()) { ReferenceList validAssemblyTargets = this.selectTargetsForSending(cddLinks.getValue(linkIndex - 1), interactionPoint, ConnectorKind.assembly, signalInstance.type, receptionIsNotProvided) ; Integer targetIndex = 1 ; while(targetIndex <= validAssemblyTargets.size()) { allPotentialTargets.addValue(validAssemblyTargets.getValue(targetIndex-1)) ; targetsForSendingIn.addValue(validAssemblyTargets.getValue(targetIndex-1)) ; targetIndex = targetIndex + 1 ; } ReferenceList validDelegationTargets = this.selectTargetsForSending(cddLinks.getValue(linkIndex - 1), interactionPoint, ConnectorKind.delegation, signalInstance.type, receptionIsNotProvided) ; targetIndex = 1 ; while(targetIndex <= validDelegationTargets.size()) { allPotentialTargets.addValue(validDelegationTargets.getValue(targetIndex-1)) ; targetsForSendingOut.addValue(validDelegationTargets.getValue(targetIndex-1)) ; targetIndex = targetIndex + 1 ; } linkIndex = linkIndex + 1 ; } CS_RequestPropagationStrategy strategy = (CS_RequestPropagationStrategy)this.locus.factory.getStrategy("requestPropagation") ; ReferenceList selectedTargets = strategy.select(allPotentialTargets, new SendSignalActionActivation()) ; for (int j = 0 ; j < selectedTargets.size() ; j++) { Reference target = selectedTargets.getValue(j) ; for (int k = 0 ; k < targetsForSendingIn.size() ; k++) { Reference cddTarget = targetsForSendingIn.getValue(k) ; if (cddTarget == target) { target.send(signalInstance) ; } } for (int k = 0 ; k < targetsForSendingOut.size() ; k++) { // The target must be an interaction point // i.e. a delegation connector for a required reception can only target a port CS_InteractionPoint cddTarget = (CS_InteractionPoint)targetsForSendingOut.getValue(k) ; if (cddTarget == target) { CS_Reference owner = cddTarget.owner ; owner.sendOut(signalInstance, cddTarget) ; } } } Java // Select appropriate delegation links from interactionPoint, // and propagates the operation call through these links // Appropriate links are either links which target elements // in the environment of this CS_Object. // These can be delegation links (i.e, the targeted elements must // require the operation) or assembly links (i.e., the target elements // must provide the operation) Execution execution = null ; boolean operationIsNotProvided = false ; // i.e. it is required ReferenceList allPotentialTargets = new ReferenceList() ; ReferenceList targetsForDispatchingIn = new ReferenceList() ; ReferenceList targetsForDispatchingOut = new ReferenceList() ; CS_LinkList cddLinks = this.getLinks(interactionPoint) ; Integer linkIndex = 1 ; while (linkIndex <= cddLinks.size()) { ReferenceList validAssemblyTargets = this.selectTargetsForDispatching(cddLinks.getValue(linkIndex - 1), interactionPoint, ConnectorKind.assembly, operation, operationIsNotProvided) ; Integer targetIndex = 1 ; while(targetIndex <= validAssemblyTargets.size()) { allPotentialTargets.addValue(validAssemblyTargets.getValue(targetIndex-1)) ; targetsForDispatchingIn.addValue(validAssemblyTargets.getValue(targetIndex-1)) ; targetIndex = targetIndex + 1 ; } ReferenceList validDelegationTargets = this.selectTargetsForDispatching(cddLinks.getValue(linkIndex - 1), interactionPoint, ConnectorKind.delegation, operation, operationIsNotProvided) ; targetIndex = 1 ; while(targetIndex <= validDelegationTargets.size()) { allPotentialTargets.addValue(validDelegationTargets.getValue(targetIndex-1)) ; targetsForDispatchingOut.addValue(validDelegationTargets.getValue(targetIndex-1)) ; targetIndex = targetIndex + 1 ; } linkIndex = linkIndex + 1 ; } CS_RequestPropagationStrategy strategy = (CS_RequestPropagationStrategy)this.locus.factory.getStrategy("requestPropagation") ; ReferenceList selectedTargets = strategy.select(allPotentialTargets, new SendSignalActionActivation()) ; for (int j = 0 ; j < selectedTargets.size() ; j++) { Reference target = selectedTargets.getValue(j) ; for (int k = 0 ; k < targetsForDispatchingIn.size() && execution == null ; k++) { Reference cddTarget = targetsForDispatchingIn.getValue(k) ; if (cddTarget == target) { execution = target.dispatch(operation) ; } } for (int k = 0 ; k < targetsForDispatchingOut.size() && execution == null ; k++) { // The target must be an interaction point // i.e. a delegation connector for a required operation can only target a port CS_InteractionPoint cddTarget = (CS_InteractionPoint)targetsForDispatchingOut.getValue(k) ; if (cddTarget == target) { CS_Reference owner = cddTarget.owner ; execution = owner.dispatchOut(operation, cddTarget) ; } } } return execution ; Java // In the case where the feature belongs to an Interface, // fUML semantics is extended in the sense that reading is // delegated to a CS_StructuralFeatureOfInterfaceAccessStrategy if (feature.namespace instanceof Interface) { CS_StructuralFeatureOfInterfaceAccessStrategy readStrategy = (CS_StructuralFeatureOfInterfaceAccessStrategy)this.locus.factory.getStrategy("structuralFeature") ; return readStrategy.read(this, feature) ; } else { return super.getFeatureValue(feature); } Java // In the case where the feature belongs to an Interface, // fUML semantics is extended in the sense that writing is // delegated to a CS_StructuralFeatureOfInterfaceAccessStrategy if (feature.namespace instanceof Interface) { CS_StructuralFeatureOfInterfaceAccessStrategy writeStrategy = (CS_StructuralFeatureOfInterfaceAccessStrategy)this.locus.factory.getStrategy("structuralFeature") ; writeStrategy.write(this, feature, values, position) ; } else { super.setFeatureValue(feature, values, position); } Java // Determines if the object given as a parameter is directly // or indirectly contained by this CS_Object boolean objectIsContained = this.directlyContains(object) ; // if object is not directly contained, restart the research // recursively on the objects owned by this CS_Object for (int i = 0 ; i < this.featureValues.size() && !objectIsContained ; i++) { FeatureValue featureValue = this.featureValues.getValue(i) ; ValueList values = featureValue.values ; for (int j = 0 ; j < values.size() && !objectIsContained ; j++) { Value value = values.getValue(j) ; if (value instanceof CS_Object) { objectIsContained = ((CS_Object)value).contains(object) ; } else if (value instanceof CS_Reference) { CS_Object referent = ((CS_Reference)value).compositeReferent ; objectIsContained = referent.contains(object) ; } } } return objectIsContained; Java // Determines if the object given as a parameter is directly // contained by this CS_Object boolean objectIsContained = false ; for (int i = 0 ; i < this.featureValues.size() && !objectIsContained ; i++) { FeatureValue featureValue = this.featureValues.getValue(i) ; ValueList values = featureValue.values ; for (int j = 0 ; j < values.size() && !objectIsContained ; j++) { Value value = values.getValue(j) ; if (value == object) { objectIsContained = true ; } else if (value instanceof CS_Reference) { objectIsContained = (((CS_Reference)value).referent == object) ; } } } return objectIsContained; Java // Retrieves all the extensional values at this locus which are direct // containers for this CS_Object // An extensional value is a direct container for an object if: // - it is a CS_Object // - it directly contains this object (i.e. CS_Object.directlyContains(Object)==true) CS_ObjectList containers = new CS_ObjectList() ; for (int i = 0 ; i < this.locus.extensionalValues.size() ; i++) { ExtensionalValue extensionalValue = this.locus.extensionalValues.getValue(i) ; if (extensionalValue != this && extensionalValue instanceof CS_Object) { CS_Object cddContainer = (CS_Object)extensionalValue ; if (cddContainer.directlyContains(this)) { containers.add(cddContainer) ; } } } return containers ; Java // Determines if the given reference provides the operation // If the reference is an interaction point, it provides the operation if this operation // is a member of one of its provided interfaces // If the reference is NOT an interactionPoint, it provides this operation if this operation is // an operation of one of its type, or one of its type provides a realization for this operation (in the case // where the namespace of this Operation is an interface) boolean isProvided = false ; if (reference instanceof CS_InteractionPoint) { if (operation.owner instanceof Interface) { // We have to look in provided interfaces of the port if // they define directly or indirectly the Operation Integer interfaceIndex = 1 ; // Iterates on provided interfaces of the port InterfaceList providedInterfaces = ((CS_InteractionPoint)reference).definingPort.provided() ; while (interfaceIndex <= providedInterfaces.size() && !isProvided) { Interface interface_ = providedInterfaces.getValue(interfaceIndex-1) ; // Iterates on members of the current Interface Integer memberIndex = 1 ; while (memberIndex <= interface_.member.size() && !isProvided) { NamedElement cddOperation = interface_.member.getValue(memberIndex-1) ; if (cddOperation instanceof Operation) { isProvided = operation == cddOperation ; } memberIndex = memberIndex + 1 ; } interfaceIndex = interfaceIndex + 1 ; } } } else { // We have to look if one of the Classifiers typing this reference // directly or indirectly provides this operation ClassifierList types = reference.getTypes() ; Integer typeIndex = 1 ; while (typeIndex <= types.size() && !isProvided) { if (types.getValue(typeIndex - 1) instanceof Class_) { Integer memberIndex = 1 ; NamedElementList members = ((Class_)types.getValue(typeIndex - 1)).member ; while (memberIndex <= members.size() && !isProvided) { NamedElement cddOperation = members.getValue(memberIndex-1) ; if (cddOperation instanceof Operation) { CS_DispatchOperationOfInterfaceStrategy strategy = new CS_DispatchOperationOfInterfaceStrategy() ; isProvided = strategy.operationsMatch((Operation)cddOperation, operation) ; } memberIndex = memberIndex + 1 ; } } typeIndex = typeIndex + 1 ; } } return isProvided ; Java // Determines if the given reference requires the operation // If the reference is an interaction point, it requires the operation if this operation // is a member of one of its required interfaces // If the reference is not a interaction point, it cannot require an operation boolean matches = false ; if (reference instanceof CS_InteractionPoint) { Integer interfaceIndex = 1 ; // Iterates on provided interfaces of the port InterfaceList requiredInterfaces = ((CS_InteractionPoint)reference).definingPort.required() ; while (interfaceIndex <= requiredInterfaces.size() && !matches) { Interface interface_ = requiredInterfaces.getValue(interfaceIndex-1) ; // Iterates on members of the current Interface Integer memberIndex = 1 ; while (memberIndex <= interface_.member.size() && !matches) { NamedElement cddOperation = interface_.member.getValue(memberIndex-1) ; if (cddOperation instanceof Operation) { matches = operation == cddOperation ; } memberIndex = memberIndex + 1 ; } interfaceIndex = interfaceIndex + 1 ; } } return matches ; Java // If the given interaction point belongs to the given object, and if the given interaction point is used as an end of the link, // then the links targets the environment of the object (enumeration literal ToEnvironment) if all the feature values of the link // (but one for the interaction point) refer to values which are not themselves values for features of the interaction point. // If all the feature values of the link refer to values which are themselves values for features of the interaction point, // the link targets the internals of the object (enumeration literal ToInternal). Otherwise, the link has no particular meaning // in the context defined by the object and the interaction point (enumeration literal None). if (! link.hasValueForAFeature(interactionPoint)) { return CS_LinkKind.None ; } CS_LinkKind kind = CS_LinkKind.ToInternal ; FeatureValueList featureValues = link.getFeatureValues() ; Integer i = 1 ; while (i <= featureValues.size() && kind != CS_LinkKind.None) { FeatureValue value = featureValues.getValue(i-1) ; if (value.values.isEmpty()) { kind = CS_LinkKind.None ; } else { Value v = value.values.getValue(0) ; boolean vIsAValueForAFeatureOfContext = false ; if (v.equals(interactionPoint)) { vIsAValueForAFeatureOfContext = true ; } else if (v instanceof CS_InteractionPoint) { v = ((CS_InteractionPoint)v).owner ; vIsAValueForAFeatureOfContext = this.hasValueForAFeature(v) ; } else { vIsAValueForAFeatureOfContext = this.hasValueForAFeature(v) ; } if (!vIsAValueForAFeatureOfContext) { kind = CS_LinkKind.ToEnvironment ; } } i = i + 1 ; } return kind ; Java // Get all links (available at the locus of this object) where the given interaction point is used as a feature value // (i.e. the interaction is an end such links) ExtensionalValueList extensionalValues = this.locus.extensionalValues ; Integer i = 1 ; CS_LinkList connectorInstances = new CS_LinkList() ; while (i <= extensionalValues.size()) { ExtensionalValue value = extensionalValues.getValue(i-1) ; if (value instanceof CS_Link) { CS_Link link = (CS_Link)value ; if (this.getLinkKind(link, interactionPoint) != CS_LinkKind.None) { connectorInstances.addValue(link) ; } } i = i + 1 ; } return connectorInstances ; Java // Returns true if the given value object is used as a value for a feature value of this object FeatureValueList allFeatureValues = this.getFeatureValues() ; Integer i = 1 ; boolean isAValue = false ; while (i <= allFeatureValues.size() && !isAValue) { FeatureValue featureValue = allFeatureValues.getValue(i-1); if (!featureValue.values.isEmpty()) { ValueList valuesForCurrentFeature = featureValue.values ; Integer j = 1 ; while (j <= valuesForCurrentFeature.size() && !isAValue) { isAValue = featureValue.values.getValue(j-1).equals(value) ; j = j + 1 ; } } i = i + 1 ; } return isAValue ; Java // Select a CS_InteractionPoint value playing onPort, // and send the signal instance to this interaction point FeatureValue featureValue = this.getFeatureValue(onPort) ; ValueList values = featureValue.values ; ReferenceList potentialTargets = new ReferenceList() ; for (int i = 0 ; i < values.size() ; i++) { potentialTargets.addValue((Reference)values.getValue(i)) ; } CS_RequestPropagationStrategy strategy = (CS_RequestPropagationStrategy)this.locus.factory.getStrategy("requestPropagation") ; ReferenceList targets = strategy.select(potentialTargets, new SendSignalActionActivation()) ; for (int i = 0 ; i < targets.size() ; i++) { CS_InteractionPoint target = (CS_InteractionPoint)targets.getValue(i) ; this.sendOut(signalInstance, target) ; } Java // Select a CS_InteractionPoint value playing onPort, // and dispatches the operation to this interaction point Execution execution = null ; FeatureValue featureValue = this.getFeatureValue(onPort) ; ValueList values = featureValue.values ; ReferenceList potentialTargets = new ReferenceList() ; for (int i = 0 ; i < values.size() ; i++) { potentialTargets.addValue((Reference)values.getValue(i)) ; } CS_RequestPropagationStrategy strategy = (CS_RequestPropagationStrategy)this.locus.factory.getStrategy("requestPropagation") ; ReferenceList targets = strategy.select(potentialTargets, new CallOperationActionActivation()) ; // if targets is empty, no dispatch target has been found, // and the operation call is lost if (targets.size() >= 1) { CS_InteractionPoint target = (CS_InteractionPoint)targets.getValue(0) ; execution = this.dispatchOut(operation, target) ; } return execution ; Java // delegates dispatching to composite referent // Select a CS_InteractionPoint value playing onPort, // and dispatches the operation call to this interaction point FeatureValue featureValue = this.getFeatureValue(onPort) ; ValueList values = featureValue.values ; Integer choice = ((ChoiceStrategy) this.locus.factory .getStrategy("choice")) .choose(featureValue.values.size()) - 1; CS_InteractionPoint interactionPoint = (CS_InteractionPoint)values.getValue(choice) ; return interactionPoint.dispatch(operation) ; Java // Select a Reference value playing onPort, // and send the signal instance to this interaction point FeatureValue featureValue = this.getFeatureValue(onPort) ; ValueList values = featureValue.values ; ReferenceList potentialTargets = new ReferenceList() ; for (int i = 0 ; i < values.size() ; i++) { potentialTargets.addValue((Reference)values.getValue(i)) ; } CS_RequestPropagationStrategy strategy = (CS_RequestPropagationStrategy)this.locus.factory.getStrategy("requestPropagation") ; ReferenceList targets = strategy.select(potentialTargets, new SendSignalActionActivation()) ; for (int i = 0 ; i < targets.size() ; i++) { Reference target = targets.getValue(i) ; target.send(signalInstance) ; } <<TextualRepresentation>>public dispatchIn (in operation : Operation, in interactionPoint : InteractionPoint) : Execution { // If the interaction is a behavior port, does nothing [for the moment... ?], // since the only kind of event supported in fUML is SignalEvent // If this is not a behavior port, select appropriate delegation links // from interactionPoint, and propagates the operation call through // these links Execution execution = null ; if (interactionPoint.definingPort.isBehavior) { // Do nothing } else { ReferenceList targets = this.selectTargetsForDispatching(operation, interactionPoint) ; // If targets is empty, no delegation target have been found, // and the operation call will be lost if (! (targets.size()==0)) { // Choose one target non-deterministically Integer index = ((ChoiceStrategy)this.locus.factory.getStrategy("choice")) .choose(targets.size()) ; Reference target = targets.getValue(index - 1) ; execution = target.dispatch(operation) ; } } return execution ; } <<TextualRepresentation>>public sendIn (in signalInstance : SignalInstance, in interactionPoint : InteractionPoint) { // If the interaction is a behavior port, // creates a SignalInstanceWithPort from the signal instance, // and sends it as usual using operation send // If this is not a behavior port, // select appropriate delegation targets from interactionPoint, // and propagates the signal to these targets if (interactionPoint.definingPort.isBehavior) { SignalInstanceWithPort newSignalInstance = new SignalInstanceWithPort() ; SignalInstance copy = (SignalInstance)signalInstance.copy() ; newSignalInstance.featureValues = copy.featureValues ; newSignalInstance.type = copy.type ; newSignalInstance.interactionPoint = interactionPoint ; this.send(newSignalInstance) ; } else { ReferenceList targets = this.selectTargetsForSending(signalInstance, interactionPoint) ; // If targets is empty, no delegation target have been found, // and the signal is lost Integer i = 1 ; // Do the following concurrently while (i <= targets.size()) { Reference target = targets.getValue(i-1) ; target.send(signalInstance) ; i = i + 1 ; } } } <<TextualRepresentation>>public selectTargetsForSending (in signalInstance : SignalInstance, in interactionPoint : InteractionPoint) : Reference[*] { // From the given signalInstance and interactionPoint, // retrieves potential connectors through which request can be delegated // These connectors are delegation connectors attached to // Port interactionPoint.definingPort, and whose target provide a // reception for Signal signalInstance.type ConnectorList connectors = this.selectConnectorsForSending(signalInstance.type, interactionPoint.definingPort) ; // Select links owned by the context object for which the // definingConnector is included in the list of matching connectors. Integer i = 1 ; ConnectorInstanceList connectorInstances = new ConnectorInstanceList() ; while (i <= connectors.size()) { Integer j = 1 ; Connector connector = connectors.getValue(i-1) ; while (j <= this.ownedConnectorInstances.size()) { ConnectorInstance connectorInstance = this.ownedConnectorInstances.getValue(j-1) ; if (connectorInstance.definingConnector == connector) { connectorInstances.addValue(connectorInstance) ; } j=j+1 ; } i = i+1 ; } // For each matching link, retrieves the end value opposite // to interactionPoint. // If this value is a reference (which means that it is possible to send it // a signal), it is added in the list of potential targets. ReferenceList targets = new ReferenceList() ; i = 1 ; while (i <= connectorInstances.size()) { ConnectorInstance link = connectorInstances.getValue(i-1) ; Association association = link.type ; Property oppositeEnd = association.memberEnd.getValue(0); if (oppositeEnd == interactionPoint.definingPort) { oppositeEnd = association.memberEnd.getValue(1); } Value value = link.getFeatureValue(oppositeEnd).values.getValue(0) ; if (value instanceof Reference) { targets.addValue((Reference)value) ; } i = i + 1; } // if targets is empty, no matching targets have been found, // and the signal instance will be lost return targets ; } <<TextualRepresentation>>public selectTargetsForDispatching (in operation : Operation, in interactionPoint : InteractionPoint) : Reference [*] { // From the given operation and interactionPoint, retrieves potential // connectors through which request can be delegated // These connectors are delegation connectors attached to Port // interactionPoint.definingPort, // and whose target provides or realize operation ConnectorList connectors = this.selectConnectorsForDispatching(operation, interactionPoint.definingPort) ; // Select links owned by the context object for which the // definingConnector is included in the list of matching connectors. Integer i = 1 ; ConnectorInstanceList connectorInstances = new ConnectorInstanceList() ; while (i <= connectors.size()) { Integer j = 1 ; Connector connector = connectors.getValue(i-1) ; while (j <= this.ownedConnectorInstances.size()) { ConnectorInstance connectorInstance = this.ownedConnectorInstances.getValue(j-1) ; if (connectorInstance.definingConnector == connector) { connectorInstances.addValue(connectorInstance) ; } j=j+1 ; } i = i+1 ; } // For each matching link, retrieves the end value opposite // to interactionPoint. // If this value is a reference (which means that it is possible to dispatch // operation to it), it is added in the list of potential targets. ReferenceList targets = new ReferenceList() ; i = 1 ; while (i <= connectorInstances.size()) { ConnectorInstance link = connectorInstances.getValue(i-1) ; Association association = link.type ; Property oppositeEnd = association.memberEnd.getValue(0); if (oppositeEnd == interactionPoint.definingPort) { oppositeEnd = association.memberEnd.getValue(1); } Value value = link.getFeatureValue(oppositeEnd).values.getValue(0) ; if (value instanceof Reference) { targets.addValue((Reference)value) ; } i = i + 1; } // if targets is empty, no matching targets have been found, // and the operation call will be lost return targets ; } <<TextualRepresentation>>public sendOut(in signalInstance : SignalInstance, in onPort : Port) { // TODO: // Propagate the signal instance through interaction points // corresponding to onPorts, following appropriate links. // This will result in calling send(signalInstance) on // oppositeEnd found from the links } <<TextualRepresentation>>public dispatchOut (in operation : Operation, in onPort : Port) : Execution { // TODO: // Propagate the operation call through interaction points corresponding // to onPorts, following appropriate links, // This will result in calling dispatch(operation) on oppositeEnd found // from the links return null ; } This class extends fuml Reference with specific operations for managing request propagation through ports, from the environment to the internals of the referent object, or from the referent objet to its environment. (NOTE: Addresses requirement R1 "The target value of an invocation action may also be a port. In this case, the invocation request is sent to the object owning this port as identified by the port identity, and is, upon arrival, handled as described in "Port" clause", and R2 "Invocation actions may also be sent to a target via a given port, either on the sending object or on another object.") // Imports import CompositeStructuresSyntaxAndSemantics.Syntax.Classes.Interfaces.Operation; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.Ports.Port; import fUML.Semantics.Classes.Kernel.Reference; import fUML.Semantics.CommonBehaviors.BasicBehaviors.Execution; import fUML.Semantics.CommonBehaviors.Communications.SignalInstance; The composite object referenced by this ReferenceToCompositeStructure. This property subsets Reference::referent. Java //Delegates dispatching to composite referent return this.compositeReferent.dispatchIn(operation, interactionPoint) ; Java // delegates sending to composite referent this.compositeReferent.sendIn(signalInstance, interactionPoint) ; Java // delegates sending to composite referent this.compositeReferent.sendOut(signalInstance, onPort) ; Java // delegates dispatching to composite referent return this.compositeReferent.dispatchOut(operation, onPort) ; Java // delegates dispatching to composite referent return this.compositeReferent.dispatchIn(operation, onPort) ; Java // delegates sending to composite referent this.compositeReferent.sendIn(signalInstance, onPort) ; Java // Delegates dispatching (through the interaction point, to the environment) // to compositeReferent return this.compositeReferent.dispatchOut(operation, interactionPoint) ; Java // Delegates sending (through the interaction point, to the environment) // to compositeReferent this.compositeReferent.sendOut(signalInstance, interactionPoint) ; JAVA // Create a new reference with the same referent and composite referent as this reference. CS_Reference newValue = new CS_Reference(); newValue.referent = this.referent; newValue.compositeReferent = this.compositeReferent; return newValue; <<TextualRepresentation>>public dispatchIn (in operation : Operation, in interactionPoint : InteractionPoint) : Execution { //Delegates dispatching to composite referent return this.compositeReferent.dispatchIn(operation, interactionPoint) ; } <<TextualRepresentation>>public sendIn (in signalInstance : SignalInstance, in interactionPoint : InteractionPoint) { // delegates sending to composite referent this.compositeReferent.sendIn(signalInstance, interactionPoint) ; } <<TextualRepresentation>>public sendOut(in signalInstance : SignalInstance, in onPort : Port) { // Delegates sending (through the port, to the environment) // to compositeReferent this.compositeReferent.sendOut(signalInstance, onPort) ; } <<TextualRepresentation>>public dispatchOut (in operation : Operation, in onPort : Port) : Execution { // Delegates dispatching (through the port, to the environment) // to compositeReferent return this.compositeReferent.dispatchOut(operation, onPort) ; } This enumeration enables to characterize a CS_Link with respect to given CS_Object and CS_InteractionPoint. If the given interaction point belongs to the given object, and if the given interaction point is used as an end of the link, then the links targets the environment of the object (enumeration literal ToEnvironment) if all the feature values of the link (but one for the interaction point) refer to values which are not themselves values for features of the interaction point. If all the feature values of the link refer to values which are themselves values for features of the interaction point, the link targets the internals of the object (enumeration literal ToInternal). Otherwise, the link has no particular meaning in the context defined by the object and the interaction point (enumeration literal None). The behavior of fUML CallOperationActionActivation::match() is overriden, in order to account for the fact that a given signal instance may need to be matched with triggers where a list of ports is given. (NOTE: Addresses requirement R9 "Specifying one or more ports for an event implies that the event triggers the execution of an associated behavior only if the event was received via one of the specified ports.") // Imports import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.InvocationActions.Trigger; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.Ports.Port; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.Ports.PortList; import fUML.Semantics.Actions.CompleteActions.AcceptEventActionActivation; import fUML.Semantics.CommonBehaviors.Communications.SignalInstance; import fUML.Syntax.Actions.CompleteActions.AcceptEventAction; import fUML.Syntax.CommonBehaviors.Communications.Signal; import fUML.Syntax.CommonBehaviors.Communications.SignalEvent; import fUML.Syntax.CommonBehaviors.Communications.TriggerList; Java // Return true if the given signal instance matches a trigger of the accept // event action of this activation. // Matching implies that the type of the signalInstance matches the Signal // of one of the triggers. // When the type matches with the Signal, and if the trigger specifies a // list of ports, // the signalInstance matches the trigger only if it occurred on a port // identified in the list. AcceptEventAction action = (AcceptEventAction)(this.node) ; TriggerList triggers = action.trigger ; Signal signal = signalInstance.type ; Boolean matches = false; Integer i = 1; while (!matches & i <= triggers.size()) { Trigger t = triggers.getValue(i-1) ; matches = ((SignalEvent)t.event).signal == signal ; if (matches && t.port.size()>0 ) { PortList portsOfTrigger = t.port ; Port onPort = ((CS_SignalInstance)signalInstance).interactionPoint.definingPort ; Boolean portMatches = false ; Integer j = 1 ; while (! portMatches & j <= portsOfTrigger.size() ) { portMatches = onPort == portsOfTrigger.getValue(j-1) ; j = j + 1 ; } matches = portMatches ; } i = i + 1; } return matches; <<TextualRepresentation>>public match (in signalInstance : SignalInstance) : Boolean { // Return true if the given signal instance matches a trigger of the accept // action of this activation. // Matching implies that the type of the signalInstance matches the Signal // of one of the triggers. // When the type matches with the Signal, and if the trigger specifies a // list of ports, // the signalInstance matches the trigger only if it occured on a port // identified in the list. AcceptEventAction action = (AcceptEventAction)(this.node) ; TriggerList triggers = action.trigger ; Signal signal = signalInstance.type ; Boolean matches = false; Integer i = 1; while (!matches & i <= triggers.size()) { Trigger t = triggers.getValue(i-1) ; matches = ((SignalEvent)t.event).signal == signal ; if (matches && (t instanceof Composites::Syntax::Trigger)) { if (! (signalInstance instanceof SignalInstanceWithPort)) { matches = false ; } else { PortList portsOfTrigger = ((Composites::Syntax::Trigger)t).port ; Port onPort = ((SignalInstanceWithPort)signalInstance).interactionPoint .definingPort ; Boolean portMatches = false ; Integer j = 1 ; while (! portMatches & j <= portsOfTrigger.size() ) { portMatches = onPort == portsOfTrigger.getValue(j-1) ; j = j + 1 ; } matches = portMatches ; } } i = i + 1; } return matches; } CS_SignalInstance extends fUML SignalInstance with the ability to reference the specific interaction point on which it occured. This is introduced to address the following requirements R9 ("Specifying one or more ports for an event implies that the event triggers the execution of an associated behavior only if the event was received via one of the specified ports."). // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_InteractionPoint; import fUML.Semantics.Classes.Kernel.Value; import fUML.Semantics.CommonBehaviors.Communications.SignalInstance; The InteractionPoint on which this signal instance occured. Java // Create a new signal instance with the same type, interaction point and feature values as this signal instance. CS_SignalInstance newValue = (CS_SignalInstance) (super.copy()); newValue.type = this.type ; newValue.interactionPoint = this.interactionPoint ; return newValue; Java // Create a new signal instance with no type or feature values. return new CS_SignalInstance(); <<TextualRepresentation>>public copy () : Value { // Create a new signal instance with the same type, interaction point and feature values as this signal instance. SignalInstanceWithPort newValue = (SignalInstanceWithPort) super.copy(); newValue.type = this.type ; newValue.interactionPoint = this.interactionPoint ; return newValue; } Extends fUML CallOperationActionActivation::getCallExecution() to capture dispatching semantics of requests across ports. (Note: Adresses requirement R2 "Invocation actions may also be sent to a target via a given port, either on the sending object or on another object.") // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Reference; import fUML.Semantics.Actions.BasicActions.CallOperationActionActivation; import fUML.Semantics.Classes.Kernel.Object_; import fUML.Semantics.Classes.Kernel.Value; import fUML.Semantics.CommonBehaviors.BasicBehaviors.Execution; import fUML.Syntax.Actions.BasicActions.CallOperationAction; Java // If onPort is not specified, behaves like in fUML // If onPort is specified, and if the value on the target input pin is a // reference, dispatch the operation // to it and return the resulting execution object. // As compared to fUML, instead of dispatching directly to target reference // by calling operation dispatch: // - If the invoked BehavioralFeature is on a provided Interface but not on any required Interface, // then, when the InvocationAction is executed, the invocation is made into the object given on // the target InputPin through the given Port // - If the invoked BehavioralFeature is on a required Interface but not on any provided Interface, // then, if the InvocationAction is being executed inside the object given on the target InputPin, // the invocation is forwarded out of the target object through the given Port. // - If the invoked BehavioralFeature is on both a provided and a required Interface, // then, if the InvocationAction is being executed inside the object given on the target InputPin, // the invocation is made out of the target object through the given Port. // Otherwise the invocation is made into the target object through the given Port. CallOperationAction action = (CallOperationAction)(this.node); Execution execution = null ; if (action.onPort == null ) { execution = super.getCallExecution() ; } else { Value target = this.takeTokens(action.target).get(0); if (target instanceof CS_Reference) { // Tries to determine if the operation call has to be // dispatched to the environment or to the internals of // target, through onPort CS_Reference targetReference = (CS_Reference)target ; Object_ executionContext = this.group.activityExecution.context ; boolean operationIsOnProvidedInterface = this.isOperationProvided(action.onPort, action.operation) ; boolean operationIsOnRequiredInterface = this.isOperationRequired(action.onPort, action.operation) ; // Operation on a provided interface only if (operationIsOnProvidedInterface && !operationIsOnRequiredInterface) { execution = targetReference.dispatchIn(action.operation, action.onPort); } // Operation is on a required interface only else if (!operationIsOnProvidedInterface && operationIsOnRequiredInterface){ // If not executing in the context of the target, // Semantics are undefined. // Otherwise, dispatch outside. if (executionContext == targetReference.referent || targetReference.compositeReferent.contains(executionContext)) { execution = targetReference.dispatchOut(action.operation, action.onPort); } } // Operation is both on a provided and a required interface else if (operationIsOnProvidedInterface && operationIsOnRequiredInterface) { if (executionContext == targetReference.referent || targetReference.compositeReferent.contains(executionContext)) { execution = targetReference.dispatchOut(action.operation, action.onPort); } else { execution = targetReference.dispatchIn(action.operation, action.onPort); } } } } return execution; Java CallOperationAction action = (CallOperationAction)(this.node); // First determines if this is a call to a constructor and if a default // construction strategy needs to be applied. // This is a call to a constructor if the called operation has // stereotype <<Create>> applied. // The default construction strategy is used if no method is associated with the // <<Create>> operation. // Otherwise, behaves like in fUML. if (action.onPort == null && this.isCreate(action.operation) && action.operation.method.size() == 0) { Locus locus = this.getExecutionLocus() ; CS_ConstructStrategy strategy = ((CS_ConstructStrategy)locus.factory.getStrategy("constructStrategy")) ; Value target = this.takeTokens(action.target).get(0); if (target instanceof CS_Reference) { strategy.construct(action.operation, ((CS_Reference)target).compositeReferent) ; ParameterList parameters = action.operation.ownedParameter ; OutputPinList resultPins = action.result ; ValueList values = new ValueList() ; values.add(target) ; int i = 1 ; while(i <= parameters.size()) { Parameter parameter = parameters.get(i - 1); if(parameter.direction == ParameterDirectionKind.return_) { OutputPin resultPin = resultPins.get(0); this.putTokens(resultPin, values); } i = i + 1; } } } else { super.doAction(); } Java boolean isProvided = false ; if (operation.owner instanceof Interface) { // We have to look in provided interfaces of the port if // they define directly or indirectly the Operation Integer interfaceIndex = 1 ; // Iterates on provided interfaces of the port InterfaceList providedInterfaces = port.provided ; while (interfaceIndex <= providedInterfaces.size() && !isProvided) { Interface interface_ = providedInterfaces.get(interfaceIndex-1) ; // Iterates on members of the current Interface Integer memberIndex = 1 ; while (memberIndex <= interface_.member.size() && !isProvided) { NamedElement cddOperation = interface_.member.get(memberIndex-1) ; if (cddOperation instanceof Operation) { isProvided = operation == cddOperation ; } memberIndex = memberIndex + 1 ; } interfaceIndex = interfaceIndex + 1 ; } } return isProvided ; Java boolean isRequired = false ; Integer interfaceIndex = 1 ; // Iterates on provided interfaces of the port InterfaceList requiredInterfaces = port.required ; while (interfaceIndex <= requiredInterfaces.size() && !isRequired) { Interface interface_ = requiredInterfaces.get(interfaceIndex-1) ; // Iterates on members of the current Interface Integer memberIndex = 1 ; while (memberIndex <= interface_.member.size() && !isRequired) { NamedElement cddOperation = interface_.member.get(memberIndex-1) ; if (cddOperation instanceof Operation) { isRequired = operation == cddOperation ; } memberIndex = memberIndex + 1 ; } interfaceIndex = interfaceIndex + 1 ; } return isRequired ; Java CS_ExecutionFactory executionFactory = (CS_ExecutionFactory)this.getExecutionLocus().factory ; Class_ stereotypeCreate = executionFactory.getStereotypeClass("StandardProfile", "Create") ; if (stereotypeCreate == null) { // standard profile is not applied return false ; } return executionFactory.getStereotypeApplication(stereotypeCreate, o) != null ; <<TextualRepresentation>>public getCallExecution() : Execution { // If onPort is not specified, behaves like in fUML // If onPort is specified, and if the value on the target input pin is a // reference, dispatch the operation // to it and return the resulting execution object. // As compared to fUML, instead of dispatching directly to target reference // by calling operation dispatch, // dispatchOut is called, so that the operation call will be finally // dispatched to the environment (from where the execution will be taken). CallOperationAction action = (CallOperationAction)(this.node); Execution execution = null ; if (action.onPort == null ) { execution = super.getCallExecution() ; } else { Value target = this.takeTokens(action.target).getValue(0); if (target instanceof ReferenceToCompositeStructure) { execution = ((ReferenceToCompositeStructure)target) .dispatchOut(action.operation, action.onPort); } } return execution; } Extends semantics of fUML SendSignalActionActivation::doAction() to capture propagation of signals across ports. (Note: Addresses requirement R2 "Invocation actions may also be sent to a target via a given port, either on the sending object or on another object.") // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Reference; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.InternalStructures.Property; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.InternalStructures.PropertyList; import fUML.Semantics.Actions.BasicActions.SendSignalActionActivation; import fUML.Semantics.Classes.Kernel.Object_; import fUML.Semantics.Classes.Kernel.Reference; import fUML.Semantics.Classes.Kernel.Value; import fUML.Semantics.Classes.Kernel.ValueList; import fUML.Syntax.Actions.BasicActions.InputPin; import fUML.Syntax.Actions.BasicActions.InputPinList; import fUML.Syntax.Actions.BasicActions.SendSignalAction; import fUML.Syntax.CommonBehaviors.Communications.Signal; Java // If onPort is not specified, behaves like in fUML // If onPort is specified, // Get the value from the target pin. If the value is not a reference, // then do nothing. // Otherwise, construct a signal using the values from the argument pins // As compared to fUML, instead of sending directly to target reference // by calling operation send: // - If the InvocationAction is being executed inside the object given // on the target InputPin, the invocation is made out of the target object // through the given Port. // Otherwise the invocation is made into the target object through the // given Port. SendSignalAction action = (SendSignalAction)(this.node); if (action.onPort == null) { // Behaves like in fUML this.doActionDefault() ; } else { Value target = this.takeTokens(action.target).get(0) ; if (target instanceof CS_Reference) { // Constructs the signal instance Signal signal = action.signal; CS_SignalInstance signalInstance = new CS_SignalInstance(); signalInstance.type = signal; PropertyList attributes = signal.ownedAttribute ; InputPinList argumentPins = action.argument ; Integer i = 0 ; while ( i < attributes.size()) { Property attribute = attributes.get(i); InputPin argumentPin = argumentPins.get(i); ValueList values = this.takeTokens(argumentPin); signalInstance.setFeatureValue(attribute, values, 0); i = i + 1 ; } // Tries to determine if the signal has to be // sent to the environment or to the internals of // target, through onPort CS_Reference targetReference = (CS_Reference)target ; //Port onPort = action.onPort ; Object_ executionContext = this.group.activityExecution.context ; if (executionContext == targetReference.referent || targetReference.compositeReferent.contains(executionContext)) { targetReference.sendOut(signalInstance, action.onPort); } else { targetReference.sendIn(signalInstance, action.onPort); } } } Java // Get the value from the target pin. If the value is not a reference, // then do nothing. // Otherwise, construct a signal using the values from the argument pins // and send it to the referent object. // This operation captures same semantics as fUML // SendSignalActionActivation.doAction() except that it constructs // a CS_SignalInstance instead of a SignalInstance SendSignalAction action = (SendSignalAction) (this.node); Value target = this.takeTokens(action.target).getValue(0); if (target instanceof Reference) { Signal signal = action.signal; CS_SignalInstance signalInstance = new CS_SignalInstance(); signalInstance.type = signal; PropertyList attributes = signal.ownedAttribute; InputPinList argumentPins = action.argument; for (int i = 0; i < attributes.size(); i++) { Property attribute = attributes.getValue(i); InputPin argumentPin = argumentPins.getValue(i); ValueList values = this.takeTokens(argumentPin); signalInstance.setFeatureValue(attribute, values, 0); } ((Reference) target).send(signalInstance); } <<TextualRepresentation>>public doAction () { // If onPort is not specified, behaves like in fUML // If onPort is specified, // Get the value from the target pin. If the value is not a reference, // then do nothing. // Otherwise, construct a signal using the values from the argument pins // As compared to fUML, instead of sending directly to target reference // by calling operation send, // sendOut is called, so that the constructed signal will be finally sent // to the environment. SendSignalAction action = (SendSignalAction)(this.node); if (action.onPort == null) { super.doAction() ; } else { Value target = this.takeTokens(action.target).getValue(0) ; if (target instanceof ReferenceToCompositeStructure) { Signal signal = action.signal; SignalInstance signalInstance = new SignalInstance(); signalInstance.type = signal; PropertyList attributes = signal.ownedAttribute; InputPinList argumentPins = action.argument; Integer i = 0 ; while ( i < attributes.size()) { Property attribute = attributes.getValue(i); InputPin argumentPin = argumentPins.getValue(i); ValueList values = this.takeTokens(argumentPin); signalInstance.setFeatureValue(attribute, values, 0); } ReferenceToCompositeStructure targetReference = (ReferenceToCompositeStructure)target ; Port onPort = action.onPort ; targetReference.sendOut(signalInstance, onPort) ; } } } This semantic strategy is introduced to enable semantic variants related to propagation of requests through connectors, in the case where multiple propagation paths are possible. Concrete strategy classes shall provide a behavior for abstract operation select. // Imports import fUML.Semantics.Classes.Kernel.ReferenceList; import fUML.Semantics.Loci.LociL1.SemanticStrategy; import fUML.Semantics.Loci.LociL1.SemanticVisitor; Java // a CS_RequestPropagationStrategy are always named "requestPropagation" return "requestPropagation"; This class proposes a basic semantic variant for the semantic variation point captured by CS_RequestPropagationSrategy. This semantic variants consists in broadcasting the request to all possible targets in the case where the request concerns a signal sending. In the case where the request concerns an operation call, only the first target is kept. // Imports import fUML.Semantics.Actions.BasicActions.SendSignalActionActivation; import fUML.Semantics.Classes.Kernel.ReferenceList; import fUML.Semantics.Loci.LociL1.SemanticVisitor; Java // returns all potential targets in the case where the context is a SendSignalActionActivation // returns the first potential target in the case where the context is anything else ReferenceList selectedTargets = new ReferenceList() ; if (context instanceof SendSignalActionActivation) { for (int i = 0 ; i < potentialTargets.size() ; i++) { selectedTargets.addValue(potentialTargets.getValue(i)) ; } } else { if (potentialTargets.size() >= 1) { selectedTargets.addValue(potentialTargets.get(0)) ; } } return selectedTargets; Java // a CS_ConstructionStrategy is always named "constructStrategy" return "constructStrategy"; Java this.locus = context.locus ; return this.constructObject(context, (Class_)constructor.type) ; Java // Instantiate is possible if: // - p is composite // - p is typed // - This type is a Class and it is not abstract // - Or p is a Port and the type is an Interface if (p.isComposite) { if (p.typedElement.type != null) { if (p.typedElement.type instanceof Class_) { return ! ((Class_)p.typedElement.type).isAbstract ; } else if (p.typedElement.type instanceof Interface) { return p instanceof Port ; } } } return false ; Java CS_Reference referenceToContext = new CS_Reference() ; referenceToContext.referent = context ; referenceToContext.compositeReferent = (CS_Object)context ; // FIXME detect infinite recursive instantiation PropertyList allAttributes = type.attribute ; int i = 1 ; // Instantiate ports and parts while (i <= allAttributes.size()) { Property p = allAttributes.get(i - 1) ; if (p.default_ != null) { ValueSpecification defaultValueSpecification = p.default_ ; Evaluation evaluation = (Evaluation)context.locus.factory.instantiateVisitor(defaultValueSpecification) ; evaluation.specification = defaultValueSpecification ; evaluation.locus = context.locus ; if (evaluation instanceof CS_OpaqueExpressionEvaluation) { ValueList evaluations = ((CS_OpaqueExpressionEvaluation)evaluation).executeExpressionBehavior() ; for (int j = 0 ; j < evaluations.size() ; j++) { this.addStructuralFeatureValue(referenceToContext, p, evaluations.get(j)) ; } } else { Value defaultValue = evaluation.evaluate() ; this.addStructuralFeatureValue(referenceToContext, p, defaultValue) ; } } else if (this.canInstantiate(p)) { int j = 1 ; while (j <= p.multiplicityElement.lower) { Object_ value ; // if p is a Port typed by an Interface // creates an Object without type, but with FeatureValues corresponding to // structural features of the interface. if (p instanceof Port && p.typedElement.type instanceof Interface) { value = this.instantiateInterface((Interface)p.typedElement.type, this.locus) ; this.addStructuralFeatureValue(referenceToContext, p, value); } else { value = context.locus.instantiate((Class_)p.typedElement.type) ; // TODO account for existing constructors value = this.constructObject((CS_Object)value, (Class_)p.typedElement.type) ; this.addStructuralFeatureValue(referenceToContext, p, (CS_Object)value) ; if (((Class_)p.typedElement.type).isActive) { value.startBehavior((Class_)p.typedElement.type, new ParameterValueList()) ; } } j = j + 1 ; } } i = i + 1 ; } // Instantiate connectors NamedElementList allMembers = type.member ; i = 1 ; while (i <= allMembers.size()) { NamedElement member = allMembers.get(i - 1) ; if (member instanceof Connector) { Connector connector = (Connector)member ; if (this.isArrayPattern(connector)) { this.generateArrayPattern(referenceToContext, connector) ; } else if (this.isStarPattern(connector)) { this.generateStarPattern(referenceToContext, connector) ; } } i = i + 1 ; } return referenceToContext.referent ; Java ConnectorEnd end1 = connector.end.getValue(0) ; ConnectorEnd end2 = connector.end.getValue(1) ; ReferenceList end1Values = this.getValuesFromConnectorEnd(context, end1) ; ReferenceList end2Values = this.getValuesFromConnectorEnd(context, end2) ; for (int i = 0 ; i < end1Values.size() ; i++) { CS_Link link = new CS_Link() ; if (connector.type == null) { link.type = this.getDefaultAssociation() ; } else { link.type = connector.type ; } ValueList valuesForEnd1 = new ValueList() ; valuesForEnd1.add(end1Values.get(i)) ; ValueList valuesForEnd2 = new ValueList() ; valuesForEnd2.add(end2Values.get(i)) ; link.setFeatureValue(link.type.ownedEnd.getValue(0), valuesForEnd1, -1) ; link.setFeatureValue(link.type.ownedEnd.getValue(1), valuesForEnd2, -1) ; link.addTo(context.referent.locus) ; } Java ConnectorEnd end1 = connector.end.getValue(0) ; ConnectorEnd end2 = connector.end.getValue(1) ; ReferenceList end1Values = this.getValuesFromConnectorEnd(context, end1) ; ReferenceList end2Values = this.getValuesFromConnectorEnd(context, end2) ; for (int i = 0 ; i < end1Values.size() ; i++) { for (int j = 0 ; j < end2Values.size(); j++) { CS_Link link = new CS_Link() ; if (connector.type == null) { link.type = this.getDefaultAssociation() ; } else { link.type = connector.type ; } ValueList valuesForEnd1 = new ValueList() ; valuesForEnd1.add(end1Values.get(i)) ; ValueList valuesForEnd2 = new ValueList() ; valuesForEnd2.add(end2Values.get(j)) ; link.setFeatureValue(link.type.ownedEnd.get(0), valuesForEnd1, -1) ; link.setFeatureValue(link.type.ownedEnd.get(1), valuesForEnd2, -1) ; link.addTo(context.referent.locus) ; } } Java int lowerOfRole = end.role.actualConnectableElement.multiplicityElement.lower ; if (lowerOfRole == 0) { return 0 ; } else if (end.partWithPort == null) { return lowerOfRole ; } else { int lowerOfPart = end.partWithPort.multiplicityElement.lower ; return lowerOfRole * lowerOfPart ; } Java ReferenceList endValues = new ReferenceList() ; if (end.partWithPort != null) { FeatureValue valueForPart = context.getFeatureValue(end.partWithPort) ; if (valueForPart != null) { for (int i = 0 ; i < valueForPart.values.size() ; i++) { Reference reference = (Reference)valueForPart.values.get(i) ; FeatureValue valueForPort = reference.getFeatureValue((Port)end.role.actualConnectableElement) ; if (valueForPort != null) { for (int j = 0 ; j < valueForPort.values.size() ; j++) { endValues.add((Reference)valueForPort.values.get(j)) ; } } } } } else { FeatureValue valueForRole = context.getFeatureValue((Property)end.role.actualConnectableElement) ; if (valueForRole != null) { for (int i = 0 ; i < valueForRole.values.size() ; i++) { endValues.add((Reference)valueForRole.values.get(i)) ; } } } return endValues ; Java // This is an array pattern if: // - c is binary // - lower bound of the two connector ends is 1 // - Cardinality of ends are equals if (c.end.size() == 2) { if (c.end.get(0).role.actualConnectableElement.multiplicityElement.lower == 1) { if (c.end.get(1).role.actualConnectableElement.multiplicityElement.lower == 1) { if (this.canInstantiate(c.end.get(0).role.actualConnectableElement) && this.canInstantiate(c.end.get(1).role.actualConnectableElement)) { int cardinality1 = this.getCardinality(c.end.get(0)) ; int cardinality2 = this.getCardinality(c.end.get(1)) ; return cardinality1 == cardinality2 ; } } } } return false ; Java // This is an array pattern if: // - c is binary // - lower bound of end1 equals cardinality of end1 // - lower bound of end2 equals cardinality of end2 if (c.end.size() == 2) { if (this.canInstantiate(c.end.get(0).role.actualConnectableElement) && this.canInstantiate(c.end.get(1).role.actualConnectableElement)) { int cardinalityOfEnd1 = this.getCardinality(c.end.get(0)) ; int lowerBoundofEnd1 = c.end.get(0).role.actualConnectableElement.multiplicityElement.lower ; if (cardinalityOfEnd1 == lowerBoundofEnd1) { int cardinalityOfEnd2 = this.getCardinality(c.end.get(1)) ; int lowerBoundofEnd2 = c.end.get(1).role.actualConnectableElement.multiplicityElement.lower ; return cardinalityOfEnd2 == lowerBoundofEnd2 ; } } } return false ; Java FeatureValue featureValue = context.getFeatureValue(feature) ; if (featureValue != null) { ValueList values = featureValue.values ; if (feature instanceof Port) { // insert an interaction point CS_InteractionPoint interactionPoint = new CS_InteractionPoint() ; interactionPoint.definingPort = (Port)feature ; interactionPoint.referent = (CS_Object)value ; interactionPoint.owner = context ; values.add(interactionPoint) ; } else if (value instanceof CS_Object) { // insert a reference CS_Reference reference = new CS_Reference() ; reference.compositeReferent = (CS_Object)value ; reference.referent = (CS_Object)value ; values.add(reference) ; } else { values.add(value) ; } } JAVA // Computes an returns an Association with two untyped owned ends, // with multiplicity [*]. // This association can be used to type links instantiated from untyped connectors if (defaultAssociation == null) { defaultAssociation = new Association() ; defaultAssociation.name = "DefaultGeneratedAssociation"; Property end1 = new Property() ; end1.setName("x"); ; end1.setLower(0); end1.setUpper(-1); end1.setIsOrdered(true); end1.setIsUnique(true); defaultAssociation.addOwnedEnd(end1); Property end2 = new Property() ; end2.setName("y"); end2.setLower(0); end2.setUpper(-1); end2.setIsOrdered(true); end2.setIsUnique(true); defaultAssociation.addOwnedEnd(end2); } return defaultAssociation ; JAVA Class_ realizingClass = this.getRealizingClass(interface_) ; Object_ object = locus.instantiate(realizingClass) ; return object ; JAVA Class_ realizingClass = null ; // TODO For cached RealizingClasses, search based on InterfaceRealizations rather than name String realizingClassName = interface_.qualifiedName + "GeneratedRealizingClass" ; int i = 1 ; while (i <= generatedRealizingClasses.size() && realizingClass == null) { Class_ cddRealizingClass = generatedRealizingClasses.getValue(i - 1) ; if (cddRealizingClass.name.equals(realizingClassName)) { realizingClass = cddRealizingClass ; } i = i + 1 ; } if (realizingClass == null) { realizingClass = this.generateRealizingClass(interface_, realizingClassName) ; generatedRealizingClasses.addValue(realizingClass) ; } return realizingClass ; JAVA Class_ realizingClass = new Class_() ; realizingClass.setName(className) ; InterfaceRealization realization = new InterfaceRealization() ; realization.contract = interface_ ; realization.implementingClassifier = realizingClass ; realizingClass.interfaceRealization.addValue(realization); // TODO Deal with structural features of the interface // TODO Make a test case for reading/writing structural features of an interface return realizingClass ; The behavior of fUML AddStructuralFeatureActionActivation::doAction() is overriden. In the case where the targeted structural feature is a port and the value to be added is a Reference, an interaction point is created on the basis of the given Reference. It then behaves like in fUML, except that the execution continues using the created interaction point instead of the given Reference. // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_InteractionPoint; import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Link; import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Reference; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.InternalStructures.Property; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.Ports.Port; import fUML.Semantics.Actions.IntermediateActions.AddStructuralFeatureValueActionActivation; import fUML.Semantics.Classes.Kernel.FeatureValue; import fUML.Semantics.Classes.Kernel.Link; import fUML.Semantics.Classes.Kernel.LinkList; import fUML.Semantics.Classes.Kernel.Reference; import fUML.Semantics.Classes.Kernel.StructuredValue; import fUML.Semantics.Classes.Kernel.UnlimitedNaturalValue; import fUML.Semantics.Classes.Kernel.Value; import fUML.Semantics.Classes.Kernel.ValueList; import fUML.Semantics.Loci.LociL1.ChoiceStrategy; import fUML.Syntax.Actions.IntermediateActions.AddStructuralFeatureValueAction; import fUML.Syntax.Classes.Kernel.Association; import fUML.Syntax.Classes.Kernel.StructuralFeature; Java // If the feature is a port and the input value to be added is a // Reference, // Replaces this Reference by an InteractionPoint, and then behaves // as usual. // If the feature is not a port, behaves as usual AddStructuralFeatureValueAction action = (AddStructuralFeatureValueAction) (this.node); StructuralFeature feature = action.structuralFeature; if (!(feature instanceof Port)) { // Behaves as usual this.doActionDefault() ; } else { ValueList inputValues = this.takeTokens(action.value); // NOTE: Multiplicity of the value input pin is required to be 1..1. Value inputValue = inputValues.getValue(0); if (inputValue instanceof Reference) { // First constructs an InteractionPoint from the inputValue Reference reference = (Reference) inputValue; CS_InteractionPoint interactionPoint = new CS_InteractionPoint(); interactionPoint.referent = reference.referent; interactionPoint.definingPort = (Port) feature; // The value on action.object is necessarily instanceof // ReferenceToCompositeStructure (otherwise, the feature cannot // be a port) CS_Reference owner = (CS_Reference) this.takeTokens( action.object).getValue(0); interactionPoint.owner = owner; // Then replaces the Reference by an InteractionPoint // in the inputValues inputValues.remove(0); inputValues.addValue(0, interactionPoint); // Finally concludes with usual fUML behavior of // AddStructuralFeatureValueAction (i.e., the usual behavior // when // the value on action.object pin is a StructuredValue) Integer insertAt = 0; if (action.insertAt != null) { insertAt = ((UnlimitedNaturalValue) this.takeTokens( action.insertAt).getValue(0)).value.naturalValue; } if (action.isReplaceAll) { owner.setFeatureValue(feature, inputValues, 0); } else { FeatureValue featureValue = owner.getFeatureValue(feature); if (featureValue.values.size() > 0 & insertAt == 0) { // If there is no insertAt pin, then the structural // feature must // be unordered, and the insertion position is // immaterial. insertAt = ((ChoiceStrategy) this.getExecutionLocus().factory .getStrategy("choice")) .choose(featureValue.values.size()); } if (feature.multiplicityElement.isUnique) { // Remove any existing value that duplicates the input // value Integer j = position(interactionPoint, featureValue.values, 1); if (j > 0) { featureValue.values.remove(j - 1); if (insertAt > 0 & j < insertAt) { insertAt = insertAt - 1; } } } if (insertAt <= 0) { // Note: insertAt = -1 indicates an unlimited value of // "*" featureValue.values.addValue(interactionPoint); } else { featureValue.values.addValue(insertAt - 1, interactionPoint); } } if (action.result != null) { this.putToken(action.result, owner); } } else { // behaves as usual this.doActionDefault() ; } } Java // Get the values of the object and value input pins. // If the given feature is an association end, then create a link // between the object and value inputs. // Otherwise, if the object input is a structural value, then add a // value to the values for the feature. // If isReplaceAll is true, first remove all current matching links or // feature values. // If isReplaceAll is false and there is an insertAt pin, insert the // value at the appropriate position. // This operation captures same semantics as fUML // AddStructuralFeatureValueActionActivation.doAction(), except that // when the feature is an association end, a CS_Link will be created instead // of a Link AddStructuralFeatureValueAction action = (AddStructuralFeatureValueAction) (this.node); StructuralFeature feature = action.structuralFeature; Association association = this.getAssociation(feature); Value value = this.takeTokens(action.object).getValue(0); ValueList inputValues = this.takeTokens(action.value); // NOTE: Multiplicity of the value input pin is required to be 1..1. Value inputValue = inputValues.getValue(0); int insertAt = 0; if (action.insertAt != null) { insertAt = ((UnlimitedNaturalValue) this .takeTokens(action.insertAt).getValue(0)).value.naturalValue; } if (association != null) { LinkList links = this.getMatchingLinks(association, feature, value); Property oppositeEnd = this.getOppositeEnd(association, feature); int position = 0; if (oppositeEnd.multiplicityElement.isOrdered) { position = -1; } if (action.isReplaceAll) { for (int i = 0; i < links.size(); i++) { Link link = links.getValue(i); link.destroy(); } } else if (feature.multiplicityElement.isUnique) { for (int i = 0; i < links.size(); i++) { Link link = links.getValue(i); FeatureValue featureValue = link.getFeatureValue(feature); if (featureValue.values.getValue(0).equals(inputValue)) { position = link.getFeatureValue(oppositeEnd).position; if (insertAt > 0 & featureValue.position < insertAt) { insertAt = insertAt - 1; } link.destroy(); } } } CS_Link newLink = new CS_Link(); newLink.type = association; // This necessary when setting a feature value with an insertAt // position newLink.locus = this.getExecutionLocus(); newLink.setFeatureValue(feature, inputValues, insertAt); ValueList oppositeValues = new ValueList(); oppositeValues.addValue(value); newLink.setFeatureValue(oppositeEnd, oppositeValues, position); newLink.locus.add(newLink); } else if (value instanceof StructuredValue) { StructuredValue structuredValue = (StructuredValue) value; if (action.isReplaceAll) { structuredValue.setFeatureValue(feature, inputValues, 0); } else { FeatureValue featureValue = structuredValue .getFeatureValue(feature); if (featureValue.values.size() > 0 & insertAt == 0) { // *** If there is no insertAt pin, then the structural // feature must be unordered, and the insertion position is // immaterial. *** insertAt = ((ChoiceStrategy) this.getExecutionLocus().factory .getStrategy("choice")).choose(featureValue.values .size()); } if (feature.multiplicityElement.isUnique) { // Remove any existing value that duplicates the input value int j = position(inputValue, featureValue.values, 1); if (j > 0) { featureValue.values.remove(j - 1); if (insertAt > 0 & j < insertAt) { insertAt = insertAt - 1; } } } if (insertAt <= 0) { // Note: insertAt = -1 indicates an // unlimited value of "*" featureValue.values.addValue(inputValue); } else { featureValue.values.addValue(insertAt - 1, inputValue); } } } if (action.result != null) { this.putToken(action.result, value); } <<TextualRepresentation>>public doAction () { // If the feature is a port and the input value to be added is a Reference, // Replaces this Reference by an InteractionPoint, and then behaves // as usual. // If the feature is not a port, behaves as usual AddStructuralFeatureValueAction action = (AddStructuralFeatureValueAction)(this.node); StructuralFeature feature = action.structuralFeature; if (! (feature instanceof Port)) { // Behaves as usual super.doAction() ; } else { ValueList inputValues = this.takeTokens(action.value); // NOTE: Multiplicity of the value input pin is required to be 1..1. Value inputValue = inputValues.getValue(0); if (inputValue instanceof Reference) { // First constructs an InteractionPoint from the inputValue Reference reference = (Reference)inputValue ; InteractionPoint interactionPoint = new InteractionPoint() ; interactionPoint.referent = reference.referent ; interactionPoint.definingPort = (Port)feature ; // The value on action.object is necessarily instanceof // ReferenceToCompositeStructure (otherwise, the feature cannot // be a port) ReferenceToCompositeStructure owner = (ReferenceToCompositeStructure)this .takeTokens(action.object).getValue(0); interactionPoint.owner = owner ; // Then replaces the Reference by an InteractionPoint // in the inputValues inputValues.remove(0) ; inputValues.addValue(0,interactionPoint) ; // Finally concludes with usual fUML behavior of // AddStructuralFeatureValueAction (i.e., the usual behavior when // the value on action.object pin is a StructuredValue) Integer insertAt = 0; if (action.insertAt != null) { insertAt = ((UnlimitedNaturalValue)this .takeTokens(action.insertAt).getValue(0)) .value.naturalValue; } if (action.isReplaceAll) { owner.setFeatureValue(feature, inputValues, 0); } else { FeatureValue featureValue = owner.getFeatureValue(feature); if (featureValue.values.size() > 0 & insertAt == 0 ) { // If there is no insertAt pin, then the structural feature must // be unordered, and the insertion position is immaterial. insertAt = ((ChoiceStrategy)this.getExecutionLocus() .factory.getStrategy("choice")) .choose(featureValue.values.size()); } if (feature.multiplicityElement.'isUnique') { // Remove any existing value that duplicates the input value Integer j = position(inputValue, featureValue.values, 1); if (j > 0) { featureValue.values.remove(j-1); if (insertAt > 0 & j < insertAt) { insertAt = insertAt - 1; } } } if (insertAt <= 0) { // Note: insertAt = -1 indicates an unlimited value of "*" featureValue.values.addValue(inputValue); } else { featureValue.values.addValue(insertAt - 1, inputValue); } } } else { // behaves as usual super.doAction(); } } } // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Object; import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Reference; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.StructuredClasses.Class_; import fUML.Semantics.Actions.IntermediateActions.CreateObjectActionActivation; import fUML.Semantics.Classes.Kernel.Object_; import fUML.Semantics.Classes.Kernel.Reference; import fUML.Syntax.Actions.IntermediateActions.CreateObjectAction; Extends fUML semantics in the sense that the reference placed on the result pin is a CS_Reference (in the case where the instantiated object is a CS_Object) not a Reference. [Note: this extension can be avoided if fUML introduces a factory for Reference] Java // Create an object with the given classifier (which must be a class) as // its type, at the same locus as the action activation. // Place a reference to the object on the result pin of the action. // Extends fUML semantics in the sense that the reference placed // on the result pin is a CS_Reference (in the case where the instantiated object // is a CS_Object) not a Reference // Note that Locus.instantiate(Class) is extended in this specification // to produce a CS_Object instead of an Object in the case where the class // to be instantiated is not a behavior CreateObjectAction action = (CreateObjectAction) (this.node); Reference reference ; Object_ referent = this.getExecutionLocus().instantiate((Class_) (action.classifier)); if (referent instanceof CS_Object) { reference = new CS_Reference() ; ((CS_Reference)reference).compositeReferent = (CS_Object)referent ; } else { reference = new Reference() ; } reference.referent = referent ; this.putToken(action.result, reference); // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Object; import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Reference; import fUML.Semantics.Actions.IntermediateActions.ReadSelfActionActivation; import fUML.Syntax.Actions.BasicActions.OutputPin; import fUML.Syntax.Actions.IntermediateActions.ReadSelfAction; Extends fUML semantics in the sense that the reference placed on the result pin is a CS_Reference, not a Reference. [Note: this extension can be avoided if fUML introduces a factory for instantiating Reference] Java // Get the context object of the activity execution containing this // action activation and place a reference to it on the result output // pin. // Extends fUML semantics in the sense that the reference placed on // the result pin is a CS_Reference, not a Reference // Debug.println("[ReadSelfActionActivation] Start..."); CS_Reference context = new CS_Reference(); context.referent = this.getExecutionContext(); if (context.referent instanceof CS_Object) {// i.e. alternatively, it can be an execution context.compositeReferent = (CS_Object)context.referent ; } // Debug.println("[ReadSelfActionActivation] context object = " + // context.referent); OutputPin resultPin = ((ReadSelfAction) (this.node)).result; this.putToken(resultPin, context); // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Link; import fUML.Semantics.Actions.IntermediateActions.CreateLinkActionActivation; import fUML.Semantics.Classes.Kernel.ExtensionalValue; import fUML.Semantics.Classes.Kernel.ExtensionalValueList; import fUML.Semantics.Classes.Kernel.Link; import fUML.Semantics.Classes.Kernel.UnlimitedNaturalValue; import fUML.Syntax.Actions.IntermediateActions.CreateLinkAction; import fUML.Syntax.Actions.IntermediateActions.LinkEndCreationData; import fUML.Syntax.Actions.IntermediateActions.LinkEndCreationDataList; import fUML.Syntax.Classes.Kernel.Association; fUML semantics is extended in the sense that a CS_Link is created instead of a Link. [Note: This extension can be avoided if fUML introduces a factory for Link] Java // Get the extent at the current execution locus of the association for // which a link is being created. // Destroy all links that have a value for any end for which // isReplaceAll is true. // Create a new link for the association, at the current locus, with the // given end data values, // inserted at the given insertAt position (for ordered ends). // fUML semantics is extended in the sense that a CS_Link is created instead of // a Link CreateLinkAction action = (CreateLinkAction) (this.node); LinkEndCreationDataList endDataList = action.endData; Association linkAssociation = this.getAssociation(); ExtensionalValueList extent = this.getExecutionLocus().getExtent( linkAssociation); Link oldLink = null; for (int i = 0; i < extent.size(); i++) { ExtensionalValue value = extent.getValue(i); Link link = (Link) value; boolean noMatch = true; int j = 1; while (noMatch & j <= endDataList.size()) { LinkEndCreationData endData = endDataList.getValue(j - 1); if (endData.isReplaceAll & this.endMatchesEndData(link, endData)) { oldLink = link; link.destroy(); noMatch = false; } j = j + 1; } } CS_Link newLink = new CS_Link(); newLink.type = linkAssociation; // This necessary when setting a feature value with an insertAt position newLink.locus = this.getExecutionLocus(); for (int i = 0; i < endDataList.size(); i++) { LinkEndCreationData endData = endDataList.getValue(i); int insertAt; if (endData.insertAt == null) { insertAt = 0; } else { insertAt = ((UnlimitedNaturalValue) (this .takeTokens(endData.insertAt).getValue(0))).value.naturalValue; if (oldLink != null) { if (oldLink.getFeatureValue(endData.end).position < insertAt) { insertAt = insertAt - 1; } } } newLink.setFeatureValue(endData.end, this.takeTokens(endData.value), insertAt); } this.getExecutionLocus().add(newLink); Java // Get the value of the object input pin. // If the given feature is an association end, then // destroy all links that have the object input on the opposite end. // Otherwise, if the object input is a structured value, then // set the appropriate feature of the input value to be empty. ClearStructuralFeatureAction action = (ClearStructuralFeatureAction)(this.node); StructuralFeature feature = action.structuralFeature; Association association = this.getAssociation(feature); Value value = this.takeTokens(action.object).get(0); if(association != null) { LinkList links = this.getMatchingLinks(association, feature, value); for(int i = 0; i < links.size(); i++) { Link link = links.get(i); link.destroy(); } } else if(value instanceof StructuredValue) { // If the value is a data value, then it must be copied before // any change is made. if(!(value instanceof Reference)) { value = value.copy(); } else { // extension to fUML CS_LinkList linksToDestroy = this.getLinksToDestroy((StructuredValue)value, feature) ; for (int i = 0 ; i < linksToDestroy.size() ; i++) { linksToDestroy.get(i).destroy() ; } // } ((StructuredValue)value).setFeatureValue(action.structuralFeature, new ValueList(), 0); } if(action.result != null) { this.putToken(action.result, value); } Java CS_LinkList linksToDestroy = new CS_LinkList() ; if (value instanceof CS_Reference) { CS_Reference context = (CS_Reference)value ; // Retrieves the feature values for the structural feature associated with this action, // in the context of this reference FeatureValue featureValue = context.getFeatureValue(feature) ; if (feature instanceof Port) { // all values are interaction points // any link targeting this interaction point must be destroyed for (int i = 0 ; i < featureValue.values.size() ; i++) { CS_InteractionPoint interactionPoint = (CS_InteractionPoint)featureValue.values.get(i) ; CS_LinkList connectorInstances = context.compositeReferent.getLinks(interactionPoint) ; for (int j = 0 ; j < connectorInstances.size() ; j++) { CS_Link link = connectorInstances.get(j) ; linksToDestroy.add(link) ; } } } else { // feature is an attribute // Retrieve all potential link ends, // separating potential link ends corresponding to the given feature, // and potential link ends corresponding to other features. // By "potential link ends", we refer to the values of a given feature, // as well as interaction points associated with this value, if any. ValueList allValuesForFeature = new ValueList() ; ValueList allOtherValues = new ValueList() ; for (int i = 0 ; i < context.referent.featureValues.size() ; i++) { StructuralFeature currentFeature = context.referent.featureValues.get(i).feature ; ValueList values = this.getPotentialLinkEnds(context, currentFeature) ; for (int j = 0 ; j < values.size() ; j++) { Value v = values.get(j) ; if (currentFeature != feature) { allOtherValues.add(v) ; } else { allValuesForFeature.add(v) ; } } } // Retrieves all links available at the locus ExtensionalValueList extensionalValues = this.getExecutionLocus().extensionalValues ; CS_LinkList allLinks = new CS_LinkList() ; for (int i = 0 ; i < extensionalValues.size() ; i ++) { ExtensionalValue extensionalValue = extensionalValues.get(i) ; if (extensionalValue instanceof CS_Link) { allLinks.add((CS_Link)extensionalValue) ; } } // Retrieves links representing connector instances in the context object for (int i = 0 ; i < allLinks.size() ; i++) { CS_Link link = allLinks.get(i) ; boolean linkHasToBeDestroyed = false ; for (int j = 0 ; j < allValuesForFeature.size() && !linkHasToBeDestroyed; j++) { Value v = allValuesForFeature.get(j) ; StructuralFeature featureForV = link.getFeature(v) ; if (featureForV != null) { // Check if feature values of this link for other features // contains elements identified in allOtherValue for (int k = 0 ; k < link.featureValues.size() && !linkHasToBeDestroyed ; k++) { FeatureValue otherFeatureValue = link.featureValues.get(k) ; if (otherFeatureValue.feature != featureForV) { for (int l = 0 ; l < otherFeatureValue.values.size() && !linkHasToBeDestroyed ; l++) { for (int m = 0 ; m < allOtherValues.size() && !linkHasToBeDestroyed ; m++) { if (otherFeatureValue.values.get(l) == allOtherValues.get(m)) { linkHasToBeDestroyed = true ; } } } } } } } if (linkHasToBeDestroyed) { linksToDestroy.add(link) ; } } } } return linksToDestroy ; Java // Retrieves all feature values for the context object for the given feature, // as well as all interaction point for these values ValueList potentialLinkEnds = new ValueList() ; FeatureValue featureValue = context.getFeatureValue(feature) ; for (int i = 0 ; i < featureValue.values.size() ; i++) { Value v = featureValue.values.get(i) ; potentialLinkEnds.add(v) ; if (v instanceof CS_Reference) { // add all interaction points associated with v for (int j = 0 ; j < ((CS_Reference)v).referent.featureValues.size() ; j++) { if (((CS_Reference)v).referent.featureValues.get(j).feature instanceof Port) { ValueList interactionPoints = (((CS_Reference)v).referent.featureValues.get(j)).values ; for (int k = 0 ; k < interactionPoints.size() ; k++) { potentialLinkEnds.add(interactionPoints.get(k)) ; } } } } } return potentialLinkEnds ; <<TextualRepresentation>>public doAction () { // If the feature is a port and the input value to be added is a Reference, // Replaces this Reference by an InteractionPoint, and then behaves // as usual. // If the feature is not a port, behaves as usual AddStructuralFeatureValueAction action = (AddStructuralFeatureValueAction)(this.node); StructuralFeature feature = action.structuralFeature; if (! (feature instanceof Port)) { // Behaves as usual super.doAction() ; } else { ValueList inputValues = this.takeTokens(action.value); // NOTE: Multiplicity of the value input pin is required to be 1..1. Value inputValue = inputValues.getValue(0); if (inputValue instanceof Reference) { // First constructs an InteractionPoint from the inputValue Reference reference = (Reference)inputValue ; InteractionPoint interactionPoint = new InteractionPoint() ; interactionPoint.referent = reference.referent ; interactionPoint.definingPort = (Port)feature ; // The value on action.object is necessarily instanceof // ReferenceToCompositeStructure (otherwise, the feature cannot // be a port) ReferenceToCompositeStructure owner = (ReferenceToCompositeStructure)this .takeTokens(action.object).getValue(0); interactionPoint.owner = owner ; // Then replaces the Reference by an InteractionPoint // in the inputValues inputValues.remove(0) ; inputValues.addValue(0,interactionPoint) ; // Finally concludes with usual fUML behavior of // AddStructuralFeatureValueAction (i.e., the usual behavior when // the value on action.object pin is a StructuredValue) Integer insertAt = 0; if (action.insertAt != null) { insertAt = ((UnlimitedNaturalValue)this .takeTokens(action.insertAt).getValue(0)) .value.naturalValue; } if (action.isReplaceAll) { owner.setFeatureValue(feature, inputValues, 0); } else { FeatureValue featureValue = owner.getFeatureValue(feature); if (featureValue.values.size() > 0 & insertAt == 0 ) { // If there is no insertAt pin, then the structural feature must // be unordered, and the insertion position is immaterial. insertAt = ((ChoiceStrategy)this.getExecutionLocus() .factory.getStrategy("choice")) .choose(featureValue.values.size()); } if (feature.multiplicityElement.'isUnique') { // Remove any existing value that duplicates the input value Integer j = position(inputValue, featureValue.values, 1); if (j > 0) { featureValue.values.remove(j-1); if (insertAt > 0 & j < insertAt) { insertAt = insertAt - 1; } } } if (insertAt <= 0) { // Note: insertAt = -1 indicates an unlimited value of "*" featureValue.values.addValue(inputValue); } else { featureValue.values.addValue(insertAt - 1, inputValue); } } } else { // behaves as usual super.doAction(); } } } // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Object; import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Reference; import fUML.Semantics.Actions.CompleteActions.ReadExtentActionActivation; import fUML.Semantics.Classes.Kernel.ExtensionalValueList; import fUML.Semantics.Classes.Kernel.Object_; import fUML.Semantics.Classes.Kernel.Reference; import fUML.Semantics.Classes.Kernel.Value; import fUML.Semantics.Classes.Kernel.ValueList; import fUML.Syntax.Actions.CompleteActions.ReadExtentAction; Extends default fUML semantics in the sense that produced tokens contain CS_References instead of References, in the case where the object is a CS_Object. [Note: This extension can be avoided if fUML introduces a factory for Reference] Java // Get the extent, at the current execution locus, of the classifier // (which must be a class) identified in the action. // Place references to the resulting set of objects on the result pin. // Extends default fUML semantics in the sense that produced tokens contain // CS_References instead of References, in the case where the object is a // CS_Object ReadExtentAction action = (ReadExtentAction) (this.node); ExtensionalValueList objects = this.getExecutionLocus().getExtent( action.classifier); ValueList references = new ValueList(); for (int i = 0; i < objects.size(); i++) { Value object = objects.getValue(i); Reference reference = null ; if (object instanceof CS_Object) { reference = new CS_Reference() ; ((CS_Reference)reference).compositeReferent = (CS_Object)object ; } else { reference = new Reference() ; } reference.referent = (Object_) object; references.addValue(reference); } this.putTokens(action.result, references); JAVA // If the given classifier is not an Interface, behaves like in fUML. // Otherwise, check if the given type (or one of its direct or indirect ancestors) // has an InterfaceRealization relationships with the given classifier. boolean matched = false ; if (!(classifier instanceof Interface)) { matched = super.checkAllParents(type, classifier); } else if (! (type instanceof Class_)){ matched = false ; } else if (this.realizesInterface((Class_)type, (Interface)classifier)) { matched = true ; } else { ClassifierList directParents = type.general; int i = 1; while(!matched & i <= directParents.size()) { Classifier directParent = directParents.get(i - 1); matched = this.checkAllParents(directParent, classifier); i = i + 1; } } return matched ; JAVA // Checks if the given type has an InterfaceRealization relationship // with the given interface or a descendant of the interface. InterfaceRealizationList realizations = type.interfaceRealization ; boolean realized = false ; int i = 1 ; while (i <= realizations.size() && !realized) { InterfaceRealization realization = realizations.get(i - 1) ; Interface contract = realization.contract ; if (contract == interface_) { realized = true ; } else if (this.isDescendant(contract, interface_)) { realized = true ; } i = i + 1 ; } return realized ; JAVA // Checks if the given contract is a descendant of the given interface_ boolean matched = false ; ClassifierList descendants = contract.general ; int i = 1 ; while (i <= descendants.size() && ! matched) { if (descendants.getValue(i-1) instanceof Interface) { Interface descendant = (Interface)descendants.getValue(i-1) ; if (descendant == interface_) { matched = true ; } else { matched = this.isDescendant(descendant, interface_) ; } } i = i + 1 ; } return matched ; // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.Actions.CompleteActions.CS_ReadExtentActionActivation; import CompositeStructuresSyntaxAndSemantics.Semantics.Actions.IntermediateActions.CS_AddStructuralFeatureValueActionActivation; import CompositeStructuresSyntaxAndSemantics.Semantics.Actions.IntermediateActions.CS_CreateLinkActionActivation; import CompositeStructuresSyntaxAndSemantics.Semantics.Actions.IntermediateActions.CS_CreateObjectActionActivation; import CompositeStructuresSyntaxAndSemantics.Semantics.Actions.IntermediateActions.CS_ReadSelfActionActivation; import CompositeStructuresSyntaxAndSemantics.Semantics.Classes.Kernel.CS_InstanceValueEvaluation; import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.InvocationActions.CS_AcceptEventActionActivation; import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.InvocationActions.CS_CallOperationActionActivation; import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.InvocationActions.CS_SendSignalActionActivation; import fUML.Semantics.Loci.LociL1.SemanticVisitor; import fUML.Semantics.Loci.LociL3.ExecutionFactoryL3; import fUML.Syntax.Actions.BasicActions.CallOperationAction; import fUML.Syntax.Actions.BasicActions.SendSignalAction; import fUML.Syntax.Actions.CompleteActions.AcceptEventAction; import fUML.Syntax.Actions.CompleteActions.ReadExtentAction; import fUML.Syntax.Actions.IntermediateActions.AddStructuralFeatureValueAction; import fUML.Syntax.Actions.IntermediateActions.CreateLinkAction; import fUML.Syntax.Actions.IntermediateActions.CreateObjectAction; import fUML.Syntax.Actions.IntermediateActions.ReadSelfAction; import fUML.Syntax.Classes.Kernel.Element; import fUML.Syntax.Classes.Kernel.InstanceValue; Extends fUML semantics in the sense that newly introduced semantic visitors are instantiated instead of fUML visitors. Java // Extends fUML semantics in the sense that newly introduced // semantic visitors are instantiated instead of fUML visitors // Extends fUML semantics in the sense that newly introduced // semantic visitors are instantiated instead of fUML visitors SemanticVisitor visitor = null ; if (element instanceof ReadExtentAction) { visitor =new CS_ReadExtentActionActivation() ; } else if (element instanceof ReadIsClassifiedObjectAction) { visitor = new CS_ReadIsClassifiedObjectActionActivation() ; } else if (element instanceof AddStructuralFeatureValueAction) { visitor = new CS_AddStructuralFeatureValueActionActivation() ; } else if (element instanceof ClearStructuralFeatureAction) { visitor = new CS_ClearStructuralFeatureValueActionActivation() ; } else if (element instanceof CreateLinkAction) { visitor = new CS_CreateLinkActionActivation() ; } else if (element instanceof CreateObjectAction) { visitor = new CS_CreateObjectActionActivation() ; } else if (element instanceof ReadSelfAction) { visitor = new CS_ReadSelfActionActivation() ; } else if (element instanceof InstanceValue) { visitor = new CS_InstanceValueEvaluation() ; } else if (element instanceof AcceptEventAction) { visitor = new CS_AcceptEventActionActivation() ; } else if (element instanceof CallOperationAction) { visitor = new CS_CallOperationActionActivation() ; } else if (element instanceof SendSignalAction) { visitor = new CS_SendSignalActionActivation() ; } else if (element instanceof OpaqueExpression) { visitor = new CS_OpaqueExpressionEvaluation() ; } else { visitor = super.instantiateVisitor(element) ; } return visitor ; <<TextualRepresentation>>public instantiateVisitor (in element : Element ) : SemanticVisitor { // TODO return super.instantiateVisitor(element) ; } // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Object; import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Reference; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.StructuredClasses.Class_; import fUML.Debug; import fUML.Semantics.Classes.Kernel.Object_; import fUML.Semantics.Classes.Kernel.Reference; import fUML.Semantics.CommonBehaviors.BasicBehaviors.ParameterValueList; import fUML.Semantics.Loci.LociL1.Executor; fUML semantics is extended in the sense that when the instantiated object is a CS_Object, a CS_Reference is returned (instead of a Reference). [Note: this can be avoided if fUML introduces a factory for Reference] Java // Instantiate the given class and start any behavior of the resulting // object. // (The behavior of an object includes any classifier behaviors for an // active object or the class of the object itself, if that is a // behavior.) // fUML semantics is extended in the sense that when the instantiated object // is a CS_Object, a CS_Reference is returned (instead of a Reference) Debug.println("[start] Starting " + type.name + "..."); Object_ object = this.locus.instantiate(type); Debug.println("[start] Object = " + object); object.startBehavior(type, inputs); Reference reference ; if (object instanceof CS_Object) { reference = new CS_Reference(); ((CS_Reference)reference).compositeReferent = (CS_Object)object ; } else { reference = new Reference() ; } reference.referent = object; return reference; // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Object; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.StructuredClasses.Class_; import fUML.Semantics.Classes.Kernel.Object_; import fUML.Semantics.Loci.LociL1.Locus; import fUML.Syntax.CommonBehaviors.BasicBehaviors.Behavior; Extends fUML semantics by instantiating a CS_Object in the case where type is not a Behavior. Otherwise behaves like in fUML. Java // Extends fUML semantics by instantiating a CS_Object // in the case where type is not a Behavior. // Otherwise behaves like in fUML Object_ object = null; if (type instanceof Behavior) { object = super.instantiate(type); } else { object = new CS_Object() ; object.types.addValue(type); object.createFeatureValues(); this.add(object); } return object; Extends fUML RedefinitionBasedDispatchStrategy to account for the fact that the invoked operation may belong to an interface, and not to one of the classifiers of the target object (NOTE: Not mandatory to have it defined as an extension of RedefinitionBasedDispatchStrategy. Could be defined as direct specialization of DispatchStrategy) // Imports import CompositeStructuresSyntaxAndSemantics.Syntax.Classes.Interfaces.Operation; import CompositeStructuresSyntaxAndSemantics.Syntax.CommonBehaviors.Communications.Interface; import fUML.Semantics.Classes.Kernel.RedefinitionBasedDispatchStrategy; import fUML.Syntax.Classes.Kernel.Parameter; import fUML.Syntax.Classes.Kernel.ParameterList; Java // Override operationsMatch, in the case where baseOperation belongs // to an Interface. // In this case, ownedOperation matches baseOperation if it has the same name and signature // Otherwise, behaves like fUML RedefinitionBasedDispatchStrategy boolean matches = true ; if (baseOperation.namespace instanceof Interface) { matches = (baseOperation.name == ownedOperation.name) ; matches = matches && (baseOperation.ownedParameter.size() == ownedOperation.ownedParameter.size()) ; ParameterList ownedOperationParameters = ownedOperation.ownedParameter ; ParameterList baseOperationParameters = baseOperation.ownedParameter ; for (int i = 0 ; matches == true && i < ownedOperationParameters.size() ; i++) { Parameter ownedParameter = ownedOperationParameters.getValue(i) ; Parameter baseParameter = baseOperationParameters.getValue(i) ; matches = (ownedParameter.type == baseParameter.type) ; matches = matches && (ownedParameter.multiplicityElement.lower == ownedParameter.multiplicityElement.lower) ; matches = matches && (ownedParameter.multiplicityElement.upper == ownedParameter.multiplicityElement.upper) ; matches = matches && (ownedParameter.direction == ownedParameter.direction) ; } } else { matches = super.operationsMatch(ownedOperation, baseOperation) ; } return matches ; <<TextualRepresentation>>public operationsMatch (in ownedOperation : Operation , in baseOperation : Operation ) : Boolean { // Override operationsMatch, in the case where baseOperation belongs // to an Interface return false ; } // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Object; import fUML.Semantics.Classes.Kernel.FeatureValue; import fUML.Semantics.Classes.Kernel.ValueList; import fUML.Semantics.Loci.LociL1.SemanticStrategy; import fUML.Syntax.Classes.Kernel.StructuralFeature; This abstract strategy class enables to deal with realization of structural features by a behaviored classifier, in the case where these structural features belong to an interface realized by this classifier. Concrete realization of this abstract class shall specify behaviors for abstract operations read and write. Java // StructuralFeatureAccessStrategy are always named "structuralFeature" return "structuralFeature"; // This abstract operation is intented to return the feature value for the given structural feature, // in the context of the given object, in the case where the feature belongs to an Interface // This abstract operation is intented to capture the way the given structural feature is set, // in the context of the given object, in the case where the feature belongs to an Interface // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Object; import fUML.Semantics.Classes.Kernel.FeatureValue; import fUML.Semantics.Classes.Kernel.FeatureValueList; import fUML.Semantics.Classes.Kernel.ValueList; import fUML.Syntax.Classes.Kernel.StructuralFeature; This class provides a realization of semantic strategy CS_StructuralFeatureOfInterfaceAccessStrategy. This realization makes the hypothesis that, for a given behaviored classifier to actually realize an interface, it shall have structural features which exactly match structural features of the realized interface. Realizing features shall have same name, type and multiplicity as structural features of the interface. Java // returns the a copy of the first feature value of cs_Object where the name of the corresponding feature // matches the name of the feature given as a parameter // Otherwise, returns an empty feature value FeatureValueList featureValues = cs_Object.featureValues ; FeatureValue matchingFeatureValue = null ; for (int i = 0 ; i < featureValues.size() && matchingFeatureValue == null ; i++) { FeatureValue featureValue = featureValues.getValue(i) ; if (featureValue.feature.name.equals(feature.name)) { matchingFeatureValue = featureValue ; } } if (matchingFeatureValue != null) { matchingFeatureValue = matchingFeatureValue.copy() ; matchingFeatureValue.feature = feature ; } else { matchingFeatureValue = new FeatureValue() ; matchingFeatureValue.feature = feature ; matchingFeatureValue.values = new ValueList() ; matchingFeatureValue.position = 0 ; } return matchingFeatureValue ; Java // Retrieves the first feature value of cs_Object where the name of the corresponding feature // matches the name of the feature given as a parameter // Then updates the values for this feature value FeatureValueList featureValues = cs_Object.featureValues ; FeatureValue matchingFeatureValue = null ; for (int i = 0 ; i < featureValues.size() && matchingFeatureValue == null ; i++) { FeatureValue featureValue = featureValues.getValue(i) ; if (featureValue.feature.name.equals(feature.name)) { matchingFeatureValue = featureValue ; } } if (matchingFeatureValue != null) { cs_Object.setFeatureValue(matchingFeatureValue.feature, values, position) ; } // Imports import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Object; import CompositeStructuresSyntaxAndSemantics.Semantics.CompositeStructures.StructuredClasses.CS_Reference; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.InternalStructures.Classifier; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.InternalStructures.ClassifierList; import CompositeStructuresSyntaxAndSemantics.Syntax.CompositeStructures.StructuredClasses.Class_; import fUML.Debug; import fUML.Semantics.Classes.Kernel.DataValue; import fUML.Semantics.Classes.Kernel.EnumerationValue; import fUML.Semantics.Classes.Kernel.InstanceValueEvaluation; import fUML.Semantics.Classes.Kernel.Object_; import fUML.Semantics.Classes.Kernel.Reference; import fUML.Semantics.Classes.Kernel.StructuredValue; import fUML.Semantics.Classes.Kernel.Value; import fUML.Semantics.Classes.Kernel.ValueList; import fUML.Syntax.Classes.Kernel.DataType; import fUML.Syntax.Classes.Kernel.Enumeration; import fUML.Syntax.Classes.Kernel.EnumerationLiteral; import fUML.Syntax.Classes.Kernel.InstanceSpecification; import fUML.Syntax.Classes.Kernel.InstanceValue; import fUML.Syntax.Classes.Kernel.Slot; import fUML.Syntax.Classes.Kernel.SlotList; import fUML.Syntax.Classes.Kernel.ValueSpecification; import fUML.Syntax.Classes.Kernel.ValueSpecificationList; import fUML.Syntax.CommonBehaviors.BasicBehaviors.Behavior; Extends fUML semantics in the sense that when the instance specification is for an object which is not typed by a Behavior, a CS_Reference (to a CS_Object) is produced instead of a Reference (to an Object) Java // If the instance specification is for an enumeration, then return the // identified enumeration literal. // If the instance specification is for a data type (but not a primitive // value or an enumeration), then create a data value of the given data // type. // If the instance specification is for an object, then create an object // at the current locus with the specified types. // Set each feature of the created value to the result of evaluating the // value specifications for the specified slot for the feature. // Extends fUML semantics in the sense that when the instance specification // is for an object which is not typed by a Behaviore, A CS_Reference (to a // CS_Object) is produced instead of a Reference (to an Object) // Debug.println("[evaluate] InstanceValueEvaluation..."); InstanceSpecification instance = ((InstanceValue) this.specification).instance; ClassifierList types = instance.classifier; Classifier myType = types.getValue(0); Debug.println("[evaluate] type = " + myType.name); Value value; if (instance instanceof EnumerationLiteral) { // Debug.println("[evaluate] Type is an enumeration."); EnumerationValue enumerationValue = new EnumerationValue(); enumerationValue.type = (Enumeration) myType; enumerationValue.literal = (EnumerationLiteral) instance; value = enumerationValue; } else { StructuredValue structuredValue = null; if (myType instanceof DataType) { // Debug.println("[evaluate] Type is a data type."); DataValue dataValue = new DataValue(); dataValue.type = (DataType) myType; structuredValue = dataValue; } else { Object_ object = null; if (myType instanceof Behavior) { // Debug.println("[evaluate] Type is a behavior."); object = this.locus.factory.createExecution( (Behavior) myType, null); } else { // Debug.println("[evaluate] Type is a class."); object = new CS_Object(); for (int i = 0; i < types.size(); i++) { Classifier type = types.getValue(i); object.types.addValue((Class_) type); } } this.locus.add(object); Reference reference ; if (object instanceof CS_Object) { reference = new CS_Reference(); ((CS_Reference)reference).compositeReferent = (CS_Object)object ; } else { reference = new Reference() ; } reference.referent = object; structuredValue = reference; } structuredValue.createFeatureValues(); // Debug.println("[evaluate] " + instance.slot.size() + // " slot(s)."); SlotList instanceSlots = instance.slot; for (int i = 0; i < instanceSlots.size(); i++) { Slot slot = instanceSlots.getValue(i); ValueList values = new ValueList(); // Debug.println("[evaluate] feature = " + // slot.definingFeature.name + ", " + slot.value.size() + // " value(s)."); ValueSpecificationList slotValues = slot.value; for (int j = 0; j < slotValues.size(); j++) { ValueSpecification slotValue = slotValues.getValue(j); // Debug.println("[evaluate] Value = " + // slotValue.getClass().getName()); values.addValue(this.locus.executor.evaluate(slotValue)); } structuredValue.setFeatureValue(slot.definingFeature, values, 0); } value = structuredValue; } return value; Java // Execute the behavior associated with the context OpaqueExpression, if any. // If multiple return values are computed, then return the first one. // If no value are computed, return null ValueList evaluation = this.executeExpressionBehavior() ; if (evaluation.size() > 0) { return evaluation.get(0) ; } else { return null ; } Java // If a behavior is associated with the context OpaqueExpression, // then execute this behavior, and return computed values. // Otherwise, return an empty list of values. ValueList evaluation = new ValueList() ; OpaqueExpression expression = (OpaqueExpression)this.specification ; Behavior behavior = expression.behavior ; if (behavior != null) { ParameterValueList inputs = new ParameterValueList() ; ParameterValueList results = this.locus.executor.execute(behavior, null, inputs) ; for (int i = 0 ; i < results.size() ; i++) { // results.size should be 1 ParameterValue parameterValue = results.get(i) ; ValueList values = parameterValue.values ; for (int j = 0 ; j < values.size() ; j++) { evaluation.add(values.get(j)) ; } } } return evaluation ;