protected Environment getGenericTypeEnvironment()
{
CoreClassifier genericCollectionType = (CoreClassifier)OclTypesDefinition.getType(getCollectionTypeName() + "<T>");
if (genericCollectionType != null)
{
return(genericCollectionType.getEnvironmentWithoutParents());
}
else
{
return(null);
}
}
protected bool primitiveTypeRedeclaration(CoreModelElement element)
{
if (element.GetType() == typeof(CoreClassifier))
{
CoreClassifier cls = (CoreClassifier)element;
if (OclTypesDefinition.isOclType(element.getName()) &&
!"PrimitiveTypes".Equals(this.getName()) &&
cls.getModel().getEnvironmentWithoutParents().lookup(element.getName()) != null)
{
return(true);
}
}
return(false);
}
/* (non-Javadoc)
* @see ocl20.CoreOperation#getReturnType()
*/
public virtual CoreClassifier getReturnType()
{
CoreClassifier returnType = getSpecificReturnParameterType();
if (returnType != null && OclTypesDefinition.typeNeedsToBeParsed(returnType))
{
return(OclTypesFactory.createTypeFromString(returnType.getName()));
}
else
{
return(returnType);
}
// return getSpecificReturnParameterType();
}
/* (non-Javadoc)
* @see br.ufrj.cos.lens.odyssey.tools.psw.metamodels.core.interfaces.CoreClassifier#getMostSpecificCommonSuperType(br.ufrj.cos.lens.odyssey.tools.psw.metamodels.core.interfaces.CoreClassifier)
*/
public override CoreClassifier getMostSpecificCommonSuperType(CoreClassifier otherClassifier)
{
if (this.conformsTo(otherClassifier))
{
return(otherClassifier);
}
else if (otherClassifier.conformsTo(this))
{
return(this);
}
else
{
return((CoreClassifier)OclTypesDefinition.getType("OclAny"));
}
}
/* (non-Javadoc)
* @see br.ufrj.cos.lens.odyssey.tools.psw.metamodels.core.interfaces.CoreClassifier#getMostSpecificCommonSuperType(br.ufrj.cos.lens.odyssey.tools.psw.metamodels.core.interfaces.CoreClassifier)
*/
public override CoreClassifier getMostSpecificCommonSuperType(CoreClassifier otherClassifier)
{
if (this.GetType() == otherClassifier.GetType())
{
CollectionType otherCollection = (CollectionType)otherClassifier;
return(createSpecificCollectionType(getElementType().getMostSpecificCommonSuperType(otherCollection.getElementType())));
}
else if (otherClassifier is CollectionTypeImpl)
{
CollectionType otherCollection = (CollectionType)otherClassifier;
return(createGenericCollectionType(getElementType().getMostSpecificCommonSuperType(otherCollection.getElementType())));
}
else
{
return((CoreClassifier)OclTypesDefinition.getType("OclAny"));
}
}
public bool hasMatchingSignature(List <object> pParamTypes)
{
CollectionType ownerCollection = (CollectionType)getFeatureOwner();
List <object> parameters = new List <object>(getParametersTypesExceptReturn());
if (parameters.Count == 0 && pParamTypes == null)
{
return(true);
}
if (parameters.Count != pParamTypes.Count)
{
return(false);
}
List <object> paramTypes = new List <object>(pParamTypes);
for (int i = 0; i < parameters.Count; i++)
{
CoreClassifier parameter = (CoreClassifier)parameters[i];
CoreClassifier typeToBeMatched = (CoreClassifier)paramTypes[i];
if (parameter.getName().Equals("<T>"))
{
if (!typeToBeMatched.conformsTo(ownerCollection.getElementType()) && !ownerCollection.getElementType().getName().Equals("OclVoid"))
{
return(false);
}
}
else if (OclTypesDefinition.isOclGenericCollectionType(parameter.getName()))
{
parameter = getParameterRealType(parameter, typeToBeMatched);
if (parameter == null || (!typeToBeMatched.conformsTo(parameter) && !parameter.getName().Equals("OclVoid")))
{
return(false);
}
}
else if (!typeToBeMatched.conformsTo(parameter) && !ownerCollection.getElementType().getName().Equals("OclVoid"))
{
return(false);
}
}
return(true);
}
public static CoreClassifier createTypeFromString(String classifierName)
{
result = null;
if (!OclTypesDefinition.isOclCollectionType(classifierName) &&
!OclTypesDefinition.isOclTupleType(classifierName))
{
result = getType(classifierName);
}
if (result == null)
{
PSWOclCompiler oclCompiler = new PSWOclCompiler(environment, new ConstraintSourceTrackerImpl());
result = oclCompiler.parseType(environment, classifierName);
if (result.GetType() == typeof(CollectionType))
{
((CollectionTypeImpl)result).setInnerMostElementType(getType(((CollectionTypeImpl)result).getInnerMostElementType().getName()));
}
}
return(result);
}
public void testPrimitiveType()
{
Assert.IsTrue(OclTypesDefinition.isOclPrimitiveType("Boolean"));
Assert.IsTrue(OclTypesDefinition.isOclPrimitiveType("Integer"));
Assert.IsTrue(OclTypesDefinition.isOclPrimitiveType("Real"));
Assert.IsTrue(OclTypesDefinition.isOclPrimitiveType("String"));
Assert.IsTrue(OclTypesDefinition.isOclPrimitiveType("integer"));
Assert.IsTrue(OclTypesDefinition.isOclPrimitiveType("int"));
Assert.IsTrue(OclTypesDefinition.isOclPrimitiveType("Int"));
Assert.IsTrue(OclTypesDefinition.isOclPrimitiveType("Long"));
Assert.IsTrue(OclTypesDefinition.isOclPrimitiveType("long"));
Assert.AreEqual(OclTypesDefinition.getOclPrimitiveType("Integer"), OclTypesDefinition.getOclPrimitiveType("int"));
Assert.AreEqual(OclTypesDefinition.getOclPrimitiveType("Integer"), OclTypesDefinition.getOclPrimitiveType("integer"));
Assert.AreEqual(OclTypesDefinition.getOclPrimitiveType("Integer"), OclTypesDefinition.getOclPrimitiveType("long"));
Assert.AreEqual(OclTypesDefinition.getOclPrimitiveType("Integer"), OclTypesDefinition.getOclPrimitiveType("Byte"));
Assert.AreEqual(OclTypesDefinition.getOclPrimitiveType("Real"), OclTypesDefinition.getOclPrimitiveType("Double"));
Assert.AreEqual(OclTypesDefinition.getOclPrimitiveType("Real"), OclTypesDefinition.getOclPrimitiveType("float"));
Assert.AreEqual(OclTypesDefinition.getOclPrimitiveType("String"), OclTypesDefinition.getOclPrimitiveType("string"));
Assert.AreEqual(OclTypesDefinition.getOclPrimitiveType("Boolean"), OclTypesDefinition.getOclPrimitiveType("bool"));
}
protected void addElementToEnvironment(
String name,
CoreModelElement wrapper,
Environment environment)
{
try {
environment.addElement(name, wrapper, false);
} catch (NameClashException e) {
Object element = environment.lookupLocal(name);
try {
if (element is CoreClassifierImpl &&
wrapper is CoreClassifierImpl &&
!OclTypesDefinition.isOclPrimitiveType(wrapper.getName()))
{
environment.removeElement(name);
CoreClassifier cls = (CoreClassifier)element;
environment.addElement(cls.getFullPathName(), cls, false);
environment.addElement(((CoreClassifier)wrapper).getFullPathName(), cls, false);
}
} catch (NameClashException e2) {
}
}
}
/* (non-Javadoc)
* @see ocl20.CoreOperation#getParametersTypesExceptReturn()
*/
public List <object> getParametersTypesExceptReturn()
{
List <object> parameters = getSpecificParameterTypesExceptReturn();
List <object> result = new List <object>();
if (parameters != null)
{
foreach (CoreClassifier paramType in parameters)
{
if (OclTypesDefinition.typeNeedsToBeParsed(paramType.getName()))
{
result.Add(OclTypesFactory.createTypeFromString(paramType.getName()));
}
else
{
result.Add(paramType);
}
}
}
return(result);
// return adjustCollectionResult(getSpecificParameterTypesExceptReturn());
}
private CoreClassifier getPrimitiveType(CoreModelElement element)
{
return((element is CoreClassifierImpl)
? (CoreClassifier)OclTypesDefinition.getEnvironment().lookup(element.getName())
: null);
}
public override Environment getEnvironmentWithoutParents()
{
if (getIsDirty() || this.environmentWithoutParents == null)
{
try {
this.environmentWithoutParents = EnvironmentFactoryManager.getInstance(this.getOclPackage()).getEnvironmentInstance();
this.environmentWithoutParents = this.environmentWithoutParents.addEnvironment(OclTypesDefinition.getEnvironment());
populateEnvironment(this.environmentWithoutParents);
isDirty = false;
} catch (NameClashException e) {
Console.WriteLine(e.StackTrace);
}
}
return(this.environmentWithoutParents);
}
public CoreClassifier getReturnType(List <object> argumentTypes)
{
CollectionTypeImpl collection = (CollectionTypeImpl)getFeatureOwner();
CoreClassifier returnType = getJmiOperation().getReturnType();
if (getName().Equals("collect"))
{
CoreClassifier elementType = (CoreClassifier)argumentTypes[0];
if (elementType is CollectionTypeImpl)
{
elementType = ((CollectionTypeImpl)elementType).getInnerMostElementType();
}
CoreClassifier type = collection.getFactory().createCollectionType(collection.getReturnTypeForCollect(), elementType);
return(type);
}
else if (getName().Equals("collectNested"))
{
return(collection.getFactory().createCollectionType(returnType.getName(), (CoreClassifier)argumentTypes[0]));
}
else if (returnType.getName().Equals("<T>"))
{
return(collection.getElementType());
}
else if (OclTypesDefinition.isOclGenericCollectionType(returnType.getName()))
{
if (returnType.getName().IndexOf("<T>") >= 0)
{
if (((CollectionType)getFeatureOwner()).getElementType().getName().Equals("OclVoid"))
{
CoreClassifier argumentElementType;
if (argumentTypes.Count == 0)
{
argumentElementType = collection.getElementType();
}
else if (argumentTypes[0] is CollectionTypeImpl)
{
argumentElementType = ((CollectionType)argumentTypes[0]).getElementType();
}
else
{
argumentElementType = (CoreClassifier)argumentTypes[0];
}
return(collection.getFactory().createCollectionType(returnType.getName(), argumentElementType));
}
else
{
return(collection.getFactory().createCollectionType(returnType.getName(), collection.getElementType()));
}
}
else if (returnType.getName().IndexOf("<T2>") >= 0)
{
return(collection.getFactory().createCollectionType(returnType.getName(), collection.getInnerMostElementType()));
}
else
{
return(null);
}
}
else if (returnType.getName().StartsWith("Set(Tuple"))
{
if (argumentTypes.Count > 0)
{
CollectionType collectionParameter = (CollectionType)argumentTypes[0];
TupleTypeImpl tupleType = (TupleTypeImpl)collection.getFactory().createTupleType();
tupleType.addElement("first", collection.getElementType());
tupleType.addElement("second", collectionParameter.getElementType());
return(collection.getFactory().createCollectionType("Set", tupleType));
}
else
{
return(null);
}
}
else
{
return(returnType);
}
}
public override Environment getEnvironmentWithoutParents()
{
return(OclTypesDefinition.getType("OclAny").getEnvironmentWithoutParents());
}
public static void setUp(TestContext testContext)
{
OclTypesDefinition.getEnvironment();
}
