protected void updateSupplierDependency(CoreClassifier owner, Dependency newConnection)
{
List <Dependency> supplierDependency = owner.getSupplierDependency();
supplierDependency.Add(newConnection);
owner.setSupplierDependency(supplierDependency);
}
public CollectionType createCollectionType(
String name,
CoreClassifier elementType)
{
if (name.StartsWith("Bag"))
{
return(createBagType(elementType));
}
else if (name.StartsWith("Set"))
{
return(createSetType(elementType));
}
else if (name.StartsWith("Sequence"))
{
return(createSequenceType(elementType));
}
else if (name.StartsWith("OrderedSet"))
{
return(createOrderedSetType(elementType));
}
else if (name.StartsWith("Collection"))
{
return(createCollectionType(elementType));
}
else
{
return(null);
}
}
public override bool conformsTo(CoreClassifier type)
{
if (!(type is CollectionTypeImpl))
{
return(false);
}
if (((CollectionTypeImpl)type).getCollectionKind() == CollectionKindEnum.COLLECTION ||
((CollectionTypeImpl)type).getCollectionKind() == this.getKind())
{
CoreClassifier targetType = ((CollectionType)type).getElementType();
foreach (CollectionLiteralPartImpl collectionItem in getParts())
{
if (!collectionItem.conformsTo(targetType))
{
return(false);
}
}
}
else
{
return(false);
}
return(true);
}
private void createAbstraction(XElement xabstraction)
{
CoreModelElement client = null;
CoreModelElement supplier = null;
XAttribute xattributeclient = xabstraction.Attribute("client");
if (xattributeclient != null)
{
string xclientidref = xattributeclient.Value;
lookup.TryGetValue(xclientidref, out client);
}
XAttribute xattributesupplier = xabstraction.Attribute("supplier");
if (xattributesupplier != null)
{
string xsupplieridref = xattributesupplier.Value;
lookup.TryGetValue(xsupplieridref, out supplier);
}
CoreClassifier coreClassifier = (CoreClassifier)client;
CoreInterface coreInterface = (CoreInterface)supplier;
Dependency dependency = new DependencyImpl();
updateClient(dependency, coreClassifier);
updateSupplier(dependency, coreInterface);
updateClientDependency(coreInterface, dependency);
updateSupplierDependency(coreClassifier, dependency);
}
public CoreClassifier getExpressionType(CoreClassifier sourceType, CoreAssociationEnd associationEnd, CoreClassifier elementType)
{
if (sourceType is CollectionTypeImpl)
{
if ((sourceType is SetTypeImpl || sourceType is BagTypeImpl) && (!associationEnd.isOrdered())
)
{
return(getFactory().createBagType(elementType));
}
else
{
return(getFactory().createSequenceType(elementType));
}
}
else
{
if (isSingleElementAccess(sourceType, associationEnd))
{
return(elementType);
}
else if (associationEnd.isOrdered())
{
return(getFactory().createOrderedSetType(elementType));
}
else
{
return(getFactory().createSetType(elementType));
}
}
}
private bool isSingleElementAccess(CoreClassifier sourceType, CoreAssociationEnd associationEnd)
{
return
((sourceType is CoreAssociationClassImpl) ||
(associationEnd.isOneMultiplicity() && !associationEndHasQualifiers(associationEnd)) ||
(associationEnd.isOneMultiplicity() && associationEndHasQualifiers(associationEnd) && getQualifiers().Count > 0));
}
public VariableDeclaration lookupSourceForImplicitProperty(
string simpleName,
List <object> parms)
{
List <object> variables = this.getVariableElements();
if (variables.Count > 0)
{
foreach (NamedElement element in variables)
{
VariableDeclaration variable = (VariableDeclaration)element.getReferredElement();
CoreClassifier classifier = variable.getType();
if (element.isMayBeImplicit() &&
isFeatureDefinedInClassifier(classifier, simpleName,
parms))
{
return(variable);
}
}
}
if (this.hasParent())
{
return(this.getParent()
.lookupSourceForImplicitFeature(simpleName));
}
return(null);
}
/* (non-Javadoc)
* @see br.cos.ufrj.lens.odyssey.tools.psw.metamodels.core.interfaces.CoreClassifier#conformsTo(br.cos.ufrj.lens.odyssey.tools.psw.metamodels.core.interfaces.CoreClassifier)
*/
public override bool conformsTo(CoreClassifier c)
{
if (c.getName().Equals("OclAny"))
{
return(true);
}
if (!(c is TupleTypeImpl))
{
return(false);
}
TupleType typeToMatch = (TupleType)c;
if (this.getTupleParts().Count != typeToMatch.getTupleParts().Count)
{
return(false);
}
List <object> tupleTypes = new List <object>(getTupleParts());
for (int i = 0; i < tupleTypes.Count; i++)
{
TuplePartType element = (TuplePartType)tupleTypes[i];
CoreAttribute elementFound = typeToMatch.lookupAttribute(element.getName());
if (elementFound == null || !element.getFeatureType().conformsTo(elementFound.getFeatureType()))
{
return(false);
}
}
return(true);
}
public IteratorExp createIteratorExp(
String name,
CoreClassifier type,
OclExpression source,
OclExpression body,
List <object> iterators)
{
IteratorExp exp = new IteratorExpImpl();
exp.setFactory(this);
exp.setType(type);
exp.setSource(source);
exp.setBody(body);
exp.setName(name);
if (iterators != null)
{
foreach (VariableDeclaration var in iterators)
{
var.setLoopExp(exp);
((IteratorExpImpl)exp).addIterator(var);
}
}
if (body != null)
{
((OclExpressionImpl)body).setLoopExp(exp);
}
if (source != null)
{
((OclExpressionImpl)source).setAppliedProperty(exp);
}
return(exp);
}
private Generalization createGeneralization(XNamespace xnamespace, XElement xgeneralization)
{
Generalization generalization = new GeneralizationImpl();
XAttribute xattributechild = xgeneralization.Attribute("child");
if (xattributechild != null)
{
fillGeneralizationMode1(xgeneralization, generalization, xattributechild);
}
else
{
XElement xchild = xgeneralization.Element(xnamespace + "Generalization.child");
if (xchild != null)
{
fillGeneralizationMode2(xnamespace, xgeneralization, generalization, xchild);
}
}
CoreClassifier child = generalization.getChild();
updateChildGeneralizations(child, generalization);
CoreClassifier parent = generalization.getParent();
updateParentSpecializations(parent, generalization);
lookup.Add(xgeneralization.Attribute("xmi.id").Value, generalization);
return(generalization);
}
protected void updateChildGeneralizations(CoreClassifier owner, Generalization newGeneralization)
{
List <Generalization> generalizations = owner.getGeneralization();
generalizations.Add(newGeneralization);
owner.setGeneralization(generalizations);
}
// private void getAllInvariants(Map allInvariants) {
// InvariantsCollector collector = new InvariantsCollector(this.getJmiClassifier(), allInvariants);
// collector.traverseAllAncestors();
// }
public CoreModelElement addDefinedElement(
string source,
string name,
CoreClassifier type)
{
List <object> allSubClasses = classifier.getAllSubClasses();
foreach (CoreClassifier subClass in allSubClasses)
{
Environment env = subClass.getEnvironmentWithoutParents();
if (env.lookup(name) != null)
{
string errorMessage = "<{0}> already defined in a derived classifier";
throw new NameClashException(string.Format(errorMessage, new object[] { name }));
}
}
CoreFeature element = createOclDefinedAttribute(source, name, type);
element.setFeatureOwner(classifier);
element.setElemOwner(classifier);
this.definedFeatures.Add(name, element);
addElementToDefinedFeaturesBySource(source, element);
return(element);
}
public CoreOperation createSpecificOperation(CoreClassifier classifier, String name, List <object> paramNames, List <object> paramTypes, CoreClassifier returnType)
{
UmlPackage mainPackage = (UmlPackage)classifier.getModel().getMainPackage();
Operation operation = mainPackage.getFoundation().getCore().getOperation();
operation.setName(name);
operation.setNamespace((Classifier)this);
for (int i = 0; i < paramNames.Count; i++)
{
String paramName = (String)paramNames[i];
Parameter newParameter = mainPackage.getFoundation().getCore().getParameter();
newParameter.setBehavioralFeature(operation);
newParameter.setName(paramName);
newParameter.setType((Classifier)paramTypes[i]);
newParameter.setKind(ParameterDirectionKindEnum.PDK_IN);
}
Parameter returnParameter = mainPackage.getFoundation().getCore().getParameter();
returnParameter.setBehavioralFeature(operation);
returnParameter.setName("return");
returnParameter.setType((Classifier)returnType);
returnParameter.setKind(ParameterDirectionKindEnum.PDK_RETURN);
return((CoreOperation)operation);
}
public CoreClassifier getExpressionType(OclExpression source, CoreClassifier propertyType)
{
if (source != null && source.getType().GetType() == typeof(CollectionType))
{
CoreClassifier elementType;
if (propertyType.GetType() == typeof(CollectionType))
{
elementType = ((CollectionType)propertyType).getElementType();
}
else
{
elementType = propertyType;
}
if ((source.getType().GetType() == typeof(SetType) || source.getType().GetType() == typeof(BagType)))
{
return(getFactory().createBagType(elementType));
}
else
{
return(getFactory().createSequenceType(elementType));
}
}
else
{
return(propertyType);
}
}
public CollectionType createSpecificCollectionType(
CollectionKind collectionKind,
CoreClassifier elementType)
{
if (collectionKind.Equals(CollectionKindEnum.BAG))
{
return(createBagType(elementType));
}
if (collectionKind.Equals(CollectionKindEnum.SET))
{
return(createSetType(elementType));
}
if (collectionKind.Equals(CollectionKindEnum.SEQUENCE))
{
return(createSequenceType(elementType));
}
if (collectionKind.Equals(CollectionKindEnum.ORDERED_SET))
{
return(createOrderedSetType(elementType));
}
if (collectionKind.Equals(CollectionKindEnum.COLLECTION))
{
return(createCollectionType(elementType));
}
return(null);
}
public OperationCallExp createOperationCallExp(
OclExpression source,
CoreOperation operation,
List <object> arguments,
CoreClassifier returnType,
bool isMarkedPre)
{
OperationCallExp exp = new OperationCallExpImpl();
exp.setFactory(this);
exp.setReferredOperation(operation);
exp.setType(returnType);
exp.setSource((isMarkedPre ? createAtPreOperation(source) : source));
if (arguments != null)
{
foreach (OclExpression argument in arguments)
{
((OclExpressionImpl)argument).setParentOperation(exp);
((OperationCallExpImpl)exp).addArgument(argument);
}
}
((OclExpressionImpl)source).setAppliedProperty(exp);
return(exp);
}
/* (non-Javadoc)
* @see ocl20.CoreClassifier#getMostSpecificCommonSuperType(ocl20.CoreClassifier)
*/
public virtual CoreClassifier getMostSpecificCommonSuperType(
CoreClassifier otherClassifier)
{
List <object> myAncestors = this.getAllAncestors();
List <object> otherAncestors = otherClassifier.getAllAncestors();
if ((this == otherClassifier) || otherAncestors.Contains(this) ||
OCLVOID.Equals(otherClassifier.getName()) ||
OCLINVALID.Equals(otherClassifier.getName()))
{
return(this);
}
else if (myAncestors.Contains(otherClassifier))
{
return(otherClassifier);
}
else if (OCLVOID.Equals(this.getName()) ||
OCLINVALID.Equals(this.getName()))
{
return(otherClassifier);
}
else
{
foreach (CoreClassifier aSuperClass in otherAncestors)
{
if (myAncestors.Contains(aSuperClass) || (aSuperClass == this))
{
return(aSuperClass);
}
}
}
return((CoreClassifier)getGlobalEnvironment().lookup(OCLANY));
}
public void testClassifierAttribute_05()
{
CoreClassifier film = (CoreClassifier)environment.lookup("Film");
CoreOperation operation = film.lookupOperation("getTapes", null);
Assert.AreEqual(0, operation.getSpecifications().Count);
List <object> constraints =
doTestManyContextOK("context Film::getTapes() : Set(Tape) post: self.rentalFee@pre = 10 ",
getCurrentMethodName());
film = (CoreClassifier)environment.lookup("Film");
operation = film.lookupOperation("getTapes", null);
Assert.AreEqual(1, operation.getSpecifications().Count);
OclPrePostConstraint constraint = (OclPrePostConstraint)operation.getSpecifications()[0];
OclPostConstraint post = (OclPostConstraint)constraint.getPostConditions()[0];
OclExpression oclExpression = ((ExpressionInOclImpl)post.getExpression()).getBodyExpression();
this.checkOperationCallExp(((OperationCallExp)oclExpression), "=", "Boolean");
OperationCallExp opCall = (OperationCallExp)((OperationCallExp)oclExpression);
AttributeCallExp attExp = checkAttributeCallExp(opCall.getSource(), "rentalFee", "Integer");
opCall = (OperationCallExp)((AttributeCallExp)opCall.getSource()).getSource();
this.checkOperationCallExp(opCall, "atPre", "Film");
checkImplicitSource(opCall, "self", "Film");
}
protected void updateParentSpecializations(CoreClassifier owner, Generalization newSpecialization)
{
List <Generalization> specializations = owner.getSpecialization();
specializations.Add(newSpecialization);
owner.setSpecialization(specializations);
}
public void visitAttributeCallExp(AttributeCallExp exp)
{
if (exp.getSource() is AssociationEndCallExpImpl)
{
string typeName, name;
getTableReference(exp, out name, out typeName);
var columnName = string.Format("{0}_{1}", typeName.ToLower(), name.ToLower());
formula += string.Format("{0}[{1}]", currentClassifier.getName(), columnName);
otherFormula += string.Format(",COL({0}[{1}]))", typeName, name);
columnToFormula.Add(columnName, otherFormula);
}
else
{
string typeName, name;
getTableReference(exp, out name, out typeName);
// format table_name[column_name] (same of classifier.attribute)
formula += string.Format("{0}[{1}]", typeName, name);
if (currentClassifier == null)
{
currentClassifier = (CoreClassifier)exp.getReferredAttribute().getElemOwner();
}
}
}
/* (non-Javadoc)
* @see AstOclModelElementFactory#createNullLiteralExp(CoreClassifier)
*/
public NullLiteralExp createNullLiteralExp(CoreClassifier type)
{
NullLiteralExp exp = new NullLiteralExpImpl();
exp.setFactory(this);
exp.setType(type);
return(exp);
}
/* (non-Javadoc)
* @see AstOclModelElementFactory#createInvalidLiteralExp(CoreClassifier)
*/
public InvalidLiteralExp createInvalidLiteralExp(CoreClassifier type)
{
InvalidLiteralExp exp = new InvalidLiteralExpImpl();
exp.setFactory(this);
exp.setType(type);
return(exp);
}
private XWorkbook createXFormulas(string expressionText, XWorkbook xWorkbook)
{
PSWOclCompiler oclCompiler = new PSWOclCompiler(environment, tracker);
List <object> nodes = oclCompiler.compileOclStream(expressionText, "",
new StreamWriter(Console.OpenStandardOutput()), typeof(CSTContextDeclarationCS));
CSTOperationContextCS operationContextCS = ((CSTOperationContextCS)nodes[0]);
var constraints = operationContextCS.getConstraintsNodesCS();
CSTOperationConstraintCS operationConstraint = (CSTOperationConstraintCS)constraints[0];
ExpressionInOcl expressionInOcl = operationConstraint.getExpressionInOCL();
OclExpressionImpl bodyExpression = (OclExpressionImpl)expressionInOcl.getBodyExpression();
XFormulaCreatorVisitor visitor = new XFormulaCreatorVisitor();
bodyExpression.accept(visitor);
string formula = visitor.getFormula();
CoreClassifier classifier = (CoreClassifier)expressionInOcl.getContextualElement();
XDataTable targetTable = getTargetTable(xWorkbook, classifier);
var operation = operationContextCS.getOperationNodeCS();
var name = operation.getOperationName();
XDataTableColumn targetColumn =
targetTable.getDataTableColumns().FirstOrDefault(c => c.getName().Equals(name));
if (targetColumn == null)
{
throw new Exception("Coluna não encontrada!");
}
XTextExp xtext = new XTextExp();
xtext.setTextSymbol(formula);
targetColumn.setDataContent(xtext);
MessageBox.Show(formula);
var extraColumns = visitor.getExtraColumns();
foreach (KeyValuePair <string, string> pair in extraColumns)
{
string columnName = pair.Key;
string columnFormula = pair.Value;
targetTable = getTargetTable(xWorkbook, visitor.getCurrentClassifier());
var newTableColumn = new XDataTableColumn();
newTableColumn.setName(columnName);
newTableColumn.setDataTable(targetTable);
updateDataTable(targetTable, newTableColumn);
XTextExp xColumnFormula = new XTextExp();
xColumnFormula.setTextSymbol(columnFormula);
newTableColumn.setDataContent(xColumnFormula);
}
return(xWorkbook);
}
public static bool typeNeedsToBeParsed(CoreClassifier classifier)
{
if (!(classifier is CollectionTypeImpl))
{
return(typeNeedsToBeParsed(classifier.getName()));
}
return(false);
}
protected bool elementTypesConformance(CoreClassifier c)
{
if (!(this.getElementType() is CollectionTypeImpl) && (((CollectionType)c).getElementType() is CollectionTypeImpl))
{
return(false);
}
return(this.getElementType().conformsTo(((CollectionType)c).getElementType()) || isVoidType(((CollectionType)c).getElementType()));
}
public void test_09()
{
String stream = "Tuple(a : Film, b : String, c : Integer)";
CoreClassifier c = doParseTestOK(stream, this.getCurrentMethodName(), "Tuple(a : Film, b : String, c : Integer)", typeof(TupleType));
TupleType tuple = (TupleType)c;
List <object> parts = tuple.getTupleParts();
Assert.AreEqual(3, parts.Count);
}
public void visitIteratorExpBegin(IteratorExp exp)
{
if (exp.getName() == "collect")
{
var body = exp.getBody();
if (body is AttributeCallExpImpl)
{
var bodyImpl = (AttributeCallExpImpl)body;
currentClassifier = (CoreClassifier)bodyImpl.getReferredAttribute().getElemOwner();
bodyImpl.accept(this);
formula += ",";
}
else if (body is AssociationEndCallExpImpl)
{
var bodyImpl = (AssociationEndCallExpImpl)body;
var associationEnd = bodyImpl.getReferredAssociationEnd();
bool isOneMultiplicity = associationEnd.isOneMultiplicity();
if (!isOneMultiplicity)
{
string otherTypeName, otherKeyName, otherName, typeName, name;
getTargetAssociationReference(bodyImpl, associationEnd, out otherTypeName, out otherKeyName,
out otherName, out typeName, out name);
otherFormula = string.Format("=INDEX({0},MATCH([{1}],{0}[{2}],0)", typeName, otherName, name);
firstNavigationName = otherName;
}
navigationLevel++;
}
else if (body is OperationCallExpImpl)
{
var bodyImpl = (OperationCallExpImpl)body;
// get referred operation name
var operation = bodyImpl.getReferredOperation();
var name = operation.getName();
var expsource = (VariableExp)bodyImpl.getSource();
var variable = expsource.getReferredVariable();
var type = variable.getType();
var typeName = type.getName();
formula += string.Format("{0}[{1}]", typeName, name);
formula += ",";
if (currentClassifier == null)
{
currentClassifier = (CoreClassifier)operation.getElemOwner();
}
}
}
else if (exp.getName() == "select")
{
processSelectExpression(exp);
}
}
public void createSpecificStereotype(CoreClassifier classifier, CoreFeature feature, String stereotypeName)
{
UmlPackage mainPackage = (UmlPackage)classifier.getModel().getMainPackage();
//verificar
Stereotype stereotype = mainPackage.getFoundation().getExtensionMechanisms().getStereotype();
stereotype.setName(stereotypeName);
mainPackage.getFoundation().getExtensionMechanisms().getAStereotypeExtendedElement().add(stereotype, (Feature)feature);
}
public CoreAttribute addDefinedElement(
String source,
String name,
CoreClassifier type)
{
CoreModelElement element = constraintsHolder.addDefinedElement(source, name, type);
setDirty(true);
return((CoreAttribute)element);
}
protected String getParameterAsString(String parameterName, CoreClassifier parameterType)
{
StringBuilder result = new StringBuilder();
result.Append(parameterName);
result.Append(" : ");
result.Append(parameterType.getName());
return(result.ToString());
}
