// 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 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); } 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); Java // Get the values of the object and value input pins. // If the given feature is an association end, then destroy any // matching links. Otherwise, if the object input is a structural // value, remove values from the given feature and destroy all links // in which the removed values are involved. // If isRemoveDuplicates is true, then destroy all current matching // links or remove all values equal to the input value. // If isRemoveDuplicates is false and there is no removeAt input pin, // remove any one feature value equal to the input value (if there are // any that are equal). // If isRemoveDuplicates is false, and there is a removeAt input pin // remove the feature value at that position. RemoveStructuralFeatureValueAction action = (RemoveStructuralFeatureValueAction) (this.node); StructuralFeature feature = action.getStructuralFeature(); Association association = this.getAssociation(feature); Value value = this.takeTokens(action.getObject()).get(0); Value inputValue = null; if (action.getValue() != null) { // NOTE: Multiplicity of the value input pin is required to be 1..1. inputValue = this.takeTokens(action.getValue()).get(0); } int removeAt = 0; if (action.getRemoveAt() != null) { removeAt = ((UnlimitedNaturalValue) this.takeTokens(action.getRemoveAt()).get(0)).value; } if (association != null) { List<Link> links = this.getMatchingLinksForEndValue(association, feature, value, inputValue); if (action.isRemoveDuplicates()) { for (int i = 0; i < links.size(); i++) { Link link = links.get(i); link.destroy(); } } else if (action.getRemoveAt() == null) { // *** If there is more than one matching link, // non-deterministically choose one. *** if (links.size() > 0) { int i = ((ChoiceStrategy) this.getExecutionLocus().factory.getStrategy("choice")).choose(links.size()); links.get(i - 1).destroy(); } } else { boolean notFound = true; int i = 1; while (notFound & i <= links.size()) { Link link = links.get(i - 1); if (link.getFeatureValue(feature).position == removeAt) { notFound = false; 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(); } FeatureValue featureValue = ((StructuredValue) value).getFeatureValue(action.getStructuralFeature()); List<Value> removedValues = new ArrayList<Value>(); if (action.isRemoveDuplicates()) { int j = this.position(inputValue, featureValue.values, 1); while (j > 0) { removedValues.add(featureValue.values.get(j - 1)); featureValue.values.remove(j - 1); j = this.position(inputValue, featureValue.values, j); } } else if (action.getRemoveAt() == null) { List<Integer> positions = new ArrayList<Integer>(); int j = this.position(inputValue, featureValue.values, 1); while (j > 0) { positions.add(j); j = this.position(inputValue, featureValue.values, j); } if (positions.size() > 0) { // *** Nondeterministically choose which value to remove. // *** int k = ((ChoiceStrategy) this.getExecutionLocus().factory.getStrategy("choice")).choose(positions.size()); removedValues.add(featureValue.values.get(positions.get(k - 1) - 1)); featureValue.values.remove(positions.get(k - 1) - 1); } } else { if (featureValue.values.size() >= removeAt) { removedValues.add(featureValue.values.get(removeAt - 1)); featureValue.values.remove(removeAt - 1); } } // When values are removed from the list of values associated to the feature // (in the context of the target), these latter may be involved in links representing // instance of connectors. If this is the case, links in which the removed values are // involved are destroyed. for(int i = 0; i < removedValues.size(); i++){ List<CS_Link> linkToDestroy = this.getLinksToDestroy((StructuredValue)value, feature, removedValues.get(i)); for(int j = 0; j < linkToDestroy.size(); j++){ linkToDestroy.get(j).destroy(); } } } if (action.getResult() != null) { this.putToken(action.getResult(), value); } Editorial Note: In order to reduce the code duplication it is required to split the semantics of RemoveStructuralFeatureActionActivation into different operations. [2] public getLinksToDestroy (value : StructuredValue, feature : StructuralFeature, removedValue : Value) : CS_Link[*] // Get all links that are required to be destroyed due to the removal of the removedValue List<CS_Link> linksToDestroy = new ArrayList<CS_Link>(); 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 if (feature instanceof Port) { // The removed value is an interaction point. // All links in which this interaction is involved must be destroyed. CS_InteractionPoint interactionPoint = (CS_InteractionPoint) removedValue; List<CS_Link> 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 not a Port. Search for all potential link // ends existing in the context of this object. List<Value> allValuesForFeature = new ArrayList<Value>(); for (int i = 0; i < context.referent.featureValues.size(); i++) { StructuralFeature currentFeature = context.referent.featureValues.get(i).feature; if(feature != currentFeature){ List<Value> values = this.getPotentialLinkEnds(context, currentFeature); for (int j = 0; j < values.size(); j++) { allValuesForFeature.add(values.get(j)); } } } // Retrieves all links available at the locus List<ExtensionalValue> extensionalValues = this.getExecutionLocus().extensionalValues; List<CS_Link> allLinks = new ArrayList<CS_Link>(); for (int i = 0; i < extensionalValues.size(); i++) { ExtensionalValue extensionalValue = extensionalValues.get(i); if (extensionalValue instanceof CS_Link) { allLinks.add((CS_Link) extensionalValue); } } // In the set of links involving potential link ends. Search for all // links that involve the removed value in other end. Any link in that // fulfill this condition is registered in the set of link to be destroyed. 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) { 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++) { if(otherFeatureValue.values.get(l) == removedValue){ linkHasToBeDestroyed = true; } } } } } } if (linkHasToBeDestroyed) { linksToDestroy.add(link); } } } } Java // Get all links that are required to be destroyed due to the removal of the removedValue List<CS_Link> linksToDestroy = new ArrayList<CS_Link>(); 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 if (feature instanceof Port) { // The removed value is an interaction point. // All links in which this interaction is involved must be destroyed. CS_InteractionPoint interactionPoint = (CS_InteractionPoint) removedValue; List<CS_Link> 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 not a Port. Search for all potential link // ends existing in the context of this object. List<Value> allValuesForFeature = new ArrayList<Value>(); for (int i = 0; i < context.referent.featureValues.size(); i++) { StructuralFeature currentFeature = context.referent.featureValues.get(i).feature; if(feature != currentFeature){ List<Value> values = this.getPotentialLinkEnds(context, currentFeature); for (int j = 0; j < values.size(); j++) { allValuesForFeature.add(values.get(j)); } } } // Retrieves all links available at the locus List<ExtensionalValue> extensionalValues = this.getExecutionLocus().extensionalValues; List<CS_Link> allLinks = new ArrayList<CS_Link>(); for (int i = 0; i < extensionalValues.size(); i++) { ExtensionalValue extensionalValue = extensionalValues.get(i); if (extensionalValue instanceof CS_Link) { allLinks.add((CS_Link) extensionalValue); } } // In the set of links involving potential link ends. Search for all // links that involve the removed value in other end. Any link in that // fulfill this condition is registered in the set of link to be destroyed. 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) { 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++) { if(otherFeatureValue.values.get(l) == removedValue){ 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 List<Value> potentialLinkEnds = new ArrayList<Value>(); 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) { List<Value> interactionPoints = (((CS_Reference) v).referent.featureValues.get(j)).values; for (int k = 0; k < interactionPoints.size(); k++) { potentialLinkEnds.add(interactionPoints.get(k)); } } } } } return potentialLinkEnds; 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 ; 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 // 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); 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.getActivityExecution().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 ; 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 ; Java // If the accepted event occurrence is a CS_EventOccurrence then the wrapped // event occurrence is extracted. The acceptance process is the one define // by AcceptCallActionActivation defined in fUML. if(eventOccurrence instanceof CS_EventOccurrence){ super.accept(((CS_EventOccurrence) eventOccurrence).wrappedEventOccurrence); }else{ super.accept(eventOccurrence); } Java // If the accepted event occurrence is a CS_EventOccurrence then the wrapped // event occurrence is extracted. The acceptance process is the one define // by AcceptEventActionActivation defined in fUML. if(eventOccurrence instanceof CS_EventOccurrence){ super.accept(((CS_EventOccurrence) eventOccurrence).wrappedEventOccurrence); }else{ super.accept(eventOccurrence); } 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 target is to be the same as or a container of (directly or indirectly) // the object executing the Action, the Signal shall be related to a Reception belonging // to a required interface of onPort, and sendOut is called on the target reference // so that the signal will be sent to the environment // - if the target is NOT to be the same as or a container of (directly or indirectly) // the object executing the Action, the Signal shall be related to a Reception belonging // to a provided Interface of onPort, and operation sendIn is called so that the signal // will be sent to the internals of the target object SendSignalAction action = (SendSignalAction) (this.node); if (action.getOnPort() == null) { // Behaves like in fUML super.doAction(); } else { Value target = this.takeTokens(action.getTarget()).get(0); if (target instanceof CS_Reference) { // Constructs the signal instance Signal signal = action.getSignal(); SignalInstance signalInstance = new SignalInstance(); signalInstance.type = signal; List<Property> attributes = signal.getOwnedAttributes(); List<InputPin> argumentPins = action.getArguments(); Integer i = 0; while (i < attributes.size()) { Property attribute = attributes.get(i); InputPin argumentPin = argumentPins.get(i); List<Value> values = this.takeTokens(argumentPin); signalInstance.setFeatureValue(attribute, values, 0); i = i + 1; } // Construct the signal event occurrence SignalEventOccurrence signalEventOccurrence = new SignalEventOccurrence(); signalEventOccurrence.signalInstance = (SignalInstance) signalInstance.copy(); CS_EventOccurrence wrappingEventOccurrence = new CS_EventOccurrence(); wrappingEventOccurrence.wrappedEventOccurrence = signalEventOccurrence; // 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; Object_ executionContext = this.getActivityExecution().context; if (executionContext == targetReference.referent || targetReference.compositeReferent.contains(executionContext)) { wrappingEventOccurrence.sendOutTo(targetReference, action.onPort); } else { wrappingEventOccurrence.sendInTo(targetReference, action.onPort); } } } } 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; 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 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 AcceptCallAction) { visitor = new CS_AcceptCallActionActivation(); } 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 if (element instanceof CallEventBehavior) { visitor = new CS_CallEventExecution(); } else { visitor = super.instantiateVisitor(element) ; } return visitor ; 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; Java // Create a new call event execution that is a copy of this execution with no // referenced interaction point. CS_CallEventExecution copy = (CS_CallEventExecution) super.copy(); copy.interactionPoint = null; Java / Wrap the created event occurrence within a CS_EventOccurrence which // references the behavior port on which the call was dispatched. CS_EventOccurrence wrappingEventOccurrence = new CS_EventOccurrence(); wrappingEventOccurrence.interactionPoint = this.interactionPoint; wrappingEventOccurrence.wrappedEventOccurrence = super.createEventOccurrence(); return wrappingEventOccurrence; Java // Create a new call event execution. return new CS_CallEventExecution(); Java // Return the parametric data of the referenced event occurrence return this.wrappedEventOccurrence.getParameterValues(); Java <<TextualRepresentation>> public boolean match(Trigger trigger) { // If the trigger references ports then to match this latter it is required that // 1] the interaction point is instance of port referenced by the trigger // 2] the referenced event occurrence match operation returns true. // If the trigger does not reference ports then the behavior is the same than for fUML. boolean matches = false; if(trigger.port.size() > 0){ int i = 1; while(!matches & i <= trigger.port.size()){ if(this.interactionPoint.definingPort==trigger.port.get(i-1)){ matches = true; } i++; } if(matches){ matches = this.wrappedEventOccurrence.match(trigger); } }else{ matches = this.wrappedEventOccurrence.match(trigger); } return matches; } Java // If the specified target is a CS_Reference and the propagation must be done // to the environment, then the operation sendOut(EventOccurrence, Port) is called // and make the propagation to continue. // If the specified target is a CS_Reference but the propagation must be done to // the internals then the operation sendIn(EventOccurrence, Port) is called. // In the case were the target is not a CS_EventOccurrence then send(EventOccurence) // is called. if(this.target instanceof CS_Reference){ if(this.propagationInward == true){ ((CS_Reference)this.target).sendIn(this, this.onPort); }else{ ((CS_Reference)this.target).sendOut(this, this.onPort); } }else{ super.doSend(); } } Java // Propagate the sending of the event occurrence to the internals this.onPort = port; this.propagationInward = true; this.sendTo(target); Java // Propagate the sending of the event occurrence to the environment this.onPort = port; this.propagationInward = false; this.sendTo(target); 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 ; 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 ; 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) ; } Java // StructuralFeatureAccessStrategy are always named "structuralFeature" return "structuralFeature"; 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) { execution = this.dispatch(operation); if(execution instanceof CS_CallEventExecution){ ((CS_CallEventExecution)execution).interactionPoint = interactionPoint; } } 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 // 1] If the interaction is a behavior port then sends the event occurrence to the // target object using operation send. // 2] If this is not a behavior port, select appropriate delegation targets from // interactionPoint and propagates the event occurrence to these targets if (interactionPoint.definingPort.isBehavior) { this.send(eventOccurrence); } 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, 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 event occurrence is lost // Otherwise, do the following concurrently for (int i = 0; i < potentialTargets.size(); i++) { Reference target = potentialTargets.getValue(i); target.send(eventOccurrence); } } 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 event occurrence 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, 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, 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(eventOccurrence) ; } } 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(eventOccurrence, 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 event occurrence 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(eventOccurrence, 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 event occurrence 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(eventOccurrence); } 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 { ClassifierListdirectParents = type.general; int i = 1; while (!matched & i <= directParents.size()) { Classifier directParent = directParents.getValue(i - 1); matched = this.checkAllParents(directParent, classifier); i = i + 1; } } return matched; 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; 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.getValue(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 //Delegates dispatching to composite referent return this.compositeReferent.dispatchIn(operation, interactionPoint) ; Java // delegates sending to composite referent this.compositeReferent.sendIn(eventOccurrence, interactionPoint); Java // delegates sending to composite referent this.compositeReferent.sendOut(eventOccurrence, 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(eventOccurrence, 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(eventOccurrence, 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; Java // Overriden to do nothing Java // Delegates dispatching to the owning object return this.owner.dispatchIn(operation, this) ; Java // An event occurrence that passes through a CS_InteractionPoint is // (if necessary) wrapped in a CS_EventOccurrence. This event occurrence // is then sent to the owning object. CS_EventOccurrence wrappingEventOccurrence = null; if(eventOccurrence instanceof CS_EventOccurrence){ wrappingEventOccurrence = (CS_EventOccurrence) eventOccurrence; }else{ wrappingEventOccurrence = new CS_EventOccurrence(); wrappingEventOccurrence.wrappedEventOccurrence = eventOccurrence; } wrappingEventOccurrence.interactionPoint = this; this.owner.sendIn(wrappingEventOccurrence, this); Java // Delegates the type checking to the reference return this.referent.checkAllParents(type, classifier); 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 ; Java // a CS_RequestPropagationStrategy are always named "requestPropagation" return "requestPropagation"; 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 // 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