private String getModelName(Model existingModel, InstanceSpecification node) {
String modelName = existingModel.getName() + "_" + node.getName(); // $NON-NLS-1$
if (configuration != null) {
modelName += "_" + configuration.getBase_Class().getName(); // $NON-NLS-1$
} else {
modelName += "_" + srcModelComponentDeploymentPlan.getName(); // $NON-NLS-1$
}
return modelName;
}
@Override
public Value evaluate() {
// 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.
// Debug.println("[evaluate] InstanceValueEvaluation...");
InstanceSpecification instance = ((InstanceValue) this.specification).getInstance();
// List<Classifier> types = instance.getClassifiers();
// Classifier myType = types.get(0);
// Debug.println("[evaluate] type = " + myType.getName());
Value value;
if (instance instanceof EnumerationLiteral) {
// Debug.println("[evaluate] Type is an enumeration.");
EnumerationValue enumerationValue = new EnumerationValue();
// enumerationValue.type = (Enumeration)myType;
enumerationValue.type = ((EnumerationLiteral) instance).getEnumeration(); // ADDED
enumerationValue.literal = (EnumerationLiteral) instance;
value = enumerationValue;
Debug.println("[evaluate] type = " + enumerationValue.type.getName()); // ADDED
} else {
// ADDED:
List<Classifier> types = instance.getClassifiers();
Classifier myType = types.get(0);
Debug.println("[evaluate] type = " + myType.getName());
//
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 Object_();
for (int i = 0; i < types.size(); i++) {
Classifier type = types.get(i);
object.types.add((Class) type);
}
}
this.locus.add(object);
Reference reference = new Reference();
reference.referent = object;
structuredValue = reference;
}
structuredValue.createFeatureValues();
// Debug.println("[evaluate] " + instance.slot.size() +
// " slot(s).");
List<Slot> instanceSlots = instance.getSlots();
for (int i = 0; i < instanceSlots.size(); i++) {
Slot slot = instanceSlots.get(i);
List<Value> values = new ArrayList<Value>();
// Debug.println("[evaluate] feature = " +
// slot.definingFeature.getName() + ", " + slot.value.size() +
// " value(s).");
List<ValueSpecification> slotValues = slot.getValues();
for (int j = 0; j < slotValues.size(); j++) {
ValueSpecification slotValue = slotValues.get(j);
// Debug.println("[evaluate] Value = " +
// slotValue.getClass().getName());
values.add(this.locus.executor.evaluate(slotValue));
}
structuredValue.setFeatureValue(slot.getDefiningFeature(), values, 0);
}
value = structuredValue;
}
return value;
}
private void deployNode(
InstanceSpecification mainInstance,
Model existingModel,
Model tmpModel,
InstanceSpecification newRootIS,
EList<InstanceSpecification> nodes,
int nodeIndex,
InstanceSpecification node)
throws TransformationException, InterruptedException {
ModelManagement genModelManagement =
createTargetModel(existingModel, MapUtil.rootModelName, false);
Model generatedModel = genModelManagement.getModel();
// --------------------------------------------------------------------
checkProgressStatus();
// --------------------------------------------------------------------
// new model has name "root" and contains a package with the
// existing model
// Package originalRoot = genModel.createNestedPackage
// (existingModel.getName ());
LazyCopier targetCopy = new LazyCopier(tmpModel, generatedModel, true, true);
// TODO: distribution to nodes is currently not done. How
// can it be realized with a copy filter ?
targetCopy.preCopyListeners.add(FilterStateMachines.getInstance());
targetCopy.preCopyListeners.add(FilterRuleApplication.getInstance());
monitor.setTaskName(
String.format(Messages.InstantiateDepPlan_InfoDeployingForNode, node.getName()));
ILangSupport langSupport = configureLanguageSupport(mainInstance, existingModel, node);
if (langSupport == null) {
return;
}
Deploy deployment = new Deploy(targetCopy, langSupport, node, nodeIndex, nodes.size());
InstanceSpecification nodeRootIS = deployment.distributeToNode(newRootIS);
TransformationUtil.updateDerivedInterfaces(nodeRootIS);
// --------------------------------------------------------------------
checkProgressStatus();
// --------------------------------------------------------------------
removeDerivedInterfacesInRoot(generatedModel);
CompImplTrafos.transform(
deployment.getBootloader(), targetCopy, generatedModel, modelIsObjectOriented);
// --------------------------------------------------------------------
checkProgressStatus();
// --------------------------------------------------------------------
destroyDeploymentPlanFolder(generatedModel);
if (generateCode) {
GenerateCode codeGenerator =
new GenerateCode(langSupport.getProject(), langSupport, genModelManagement, monitor);
boolean option = (generationOptions & GenerationOptions.ONLY_CHANGED) != 0;
codeGenerator.generate(node, getTargetLanguage(mainInstance), option);
}
genModelManagement.dispose();
}