protected void addAllClassifiersFromInnerPackages(
bool firstLevel,
CorePackage aPackage,
Environment environment)
{
foreach (CoreModelElement element in aPackage.getElemOwnedElements())
{
if (element.getName() == null)
{
continue;
}
if (isClassifierToBeAdded(element))
{
addElementToEnvironment(element.getName(), element, environment);
}
else if (element.GetType() == typeof(CorePackage))
{
if (firstLevel)
{
addElementToEnvironment(element.getName(), element, environment);
}
bool notFirstLevel = true;
addAllClassifiersFromInnerPackages(notFirstLevel, (CorePackage)element, environment);
}
}
}
/* (non-Javadoc)
* @see br.cos.ufrj.lens.odyssey.tools.psw.parser.environment.Environment#addEnvironment(br.cos.ufrj.lens.odyssey.tools.psw.parser.environment.Environment)
*/
public Environment addEnvironment(Environment env)
{
if (env == null)
{
return(this);
}
List <object> otherEnvNamedElements = env.getNamedElements();
// check if names from env
// do not clash with the names locally defined in this environment
foreach (NamedElement element in otherEnvNamedElements)
{
if (this.lookupLocal(element.getName()) != null)
{
throw new NameClashException(
"element with this name already exists");
}
}
// now create a new Environment merging this environment with the env parameter.
Environment result = EnvironmentFactoryManager.getInstance(oclPackage).getEnvironmentInstance();
result.addNamedElements(this.getNamedElements());
result.addNamedElements(env.getNamedElements());
((EnvironmentImpl)result).addVariableDeclarations(this.getVariableDeclarations());
((EnvironmentImpl)result).addVariableDeclarations(((EnvironmentImpl)env).getVariableDeclarations());
return(result);
}
/* (non-Javadoc)
* @see br.cos.ufrj.lens.odyssey.tools.psw.parser.environment.Environment#lookupPathName(List<object>)
*/
public object lookupPathName(List <string> names)
{
if (names.Count == 1)
{
return(lookup((string)names[0]));
}
CoreModelElement result = lookupPathNameInsideInnerPackages(names);
if (result == null)
{
Environment rootEnvironment = getRootEnvironment();
if (rootEnvironment != null)
{
result = ((EnvironmentImpl)rootEnvironment).lookupPathNameInsideInnerPackages(names);
}
else
{
result = null;
}
}
return(result);
}
private void populateWithDefinedFeatures(Environment environment)
{
foreach (CoreFeature feature in constraintsHolder.getDefinedFeatures())
{
ModelElementNameGenerator nameGenerator = new CoreModelElementNameGeneratorImpl();
addElementToEnvironment(nameGenerator.generateName(feature), feature, environment);
}
}
public override void populateEnvironment(Environment environment)
{
populateWithFeatures(environment);
populateWithAssociationEnds(environment);
populateWithAssociationClasses(environment);
populateWithDefinedFeatures(environment);
populateWithAncestorsFeatures(this, environment);
populateWithOclAnyFeatures(environment);
}
private void populateWithAssociationClasses(Environment environment)
{
List <object> associationClasses = this.getAllAssociationClasses();
foreach (CoreAssociationClass associationClass in associationClasses)
{
ModelElementNameGenerator nameGenerator = new CoreModelElementNameGeneratorImpl();
addElementToEnvironment(nameGenerator.generateName(associationClass), associationClass, environment);
}
}
public virtual void populateEnvironment(Environment environment)
{
foreach (CoreModelElement element in getElemOwnedElements())
{
if (elementShouldBeAddedToEnvironment(element))
{
addElementToEnvironment(element.getName(), element, environment);
}
}
}
private void populateWithFeatures(Environment environment)
{
foreach (CoreModelElement element in getClassifierFeatures())
{
if (elementShouldBeAddedToEnvironment(element))
{
ModelElementNameGenerator nameGenerator = new CoreModelElementNameGeneratorImpl();
addElementToEnvironment(nameGenerator.generateName(element), element, environment);
}
}
}
public virtual Environment getEnvironmentWithoutParents()
{
if (isDirty || this.environmentWithoutParents == null)
{
this.environmentWithoutParents = EnvironmentFactoryManager.getInstance(this.getModel().getOclPackage()).getEnvironmentInstance();
populateEnvironment(this.environmentWithoutParents);
isDirty = false;
}
return(this.environmentWithoutParents);
}
private void populateWithOclAnyFeatures(Environment environment)
{
if (!OCLANY.Equals(this.getName()))
{
CoreClassifier oclAnyType = (CoreClassifier)getGlobalEnvironment().lookup(OCLANY);
if (oclAnyType != null)
{
environment.addNamespace(oclAnyType);
}
}
}
public Environment getRootEnvironment()
{
Environment root = getParent();
if (root != null)
{
while (root.getParent() != null)
{
root = root.getParent();
}
}
return(root);
}
public bool isInvalidSumOperation()
{
CollectionType collection = (CollectionType)getFeatureOwner();
if (getName().Equals("sum"))
{
Environment env = collection.getElementType().getEnvironmentWithoutParents();
if (env != null && env.lookupOperationLocal("+").Count == 0)
{
return(true);
}
}
return(false);
}
/* (non-Javadoc)
* @see ocl20.CoreClassifier#getAllAttributes()
*/
public virtual ICollection <object> getAllAttributes()
{
// List result = new ArrayList();
HashSet <object> result = new HashSet <object>();
Environment env = this.getEnvironmentWithoutAncestors();
result.AddRange(env.getAllOfType(typeof(CoreAttribute)));
return(result);
// for (Iterator iter = getClassifierFeatures().iterator(); iter.hasNext();) {
// CoreModelElement element = (CoreModelElement) iter.next();
// if (element instanceof CoreAttribute)
// result.add(element);
// }
// return result;
}
private CoreModelElement lookupFeature(
String name,
Type desiredType)
{
Environment env = this.getEnvironmentWithoutParents();
Object element = env.lookupLocal(name);
if ((element != null) && desiredType.IsInstanceOfType(element))
{
return((CoreModelElement)element);
}
else
{
return(null);
}
}
/* (non-Javadoc)
* @see ocl20.CoreClassifier#lookupSameSignatureOperation(java.lang.String, java.util.Collection, ocl20.CoreClassifier)
*/
public CoreOperation lookupSameSignatureOperation(String name, List <object> paramTypes, CoreClassifier returnType)
{
Environment env = this.getEnvironmentWithoutAncestors();
List <object> operations = env.lookupOperationLocal(name);
if (operations != null)
{
foreach (CoreOperation operation in operations)
{
if (operation.hasSameSignature(paramTypes, returnType))
{
return(operation);
}
}
}
return(null);
}
/* (non-Javadoc)
* @see ocl20.CoreClassifier#lookupOperation(java.lang.String, java.util.Collection)
*/
public virtual CoreOperation lookupOperation(String name, List <object> paramTypes)
{
Environment env = this.getEnvironmentWithoutParents();
List <object> operations = env.lookupOperationLocal(name);
if (operations != null)
{
List <object> matchingOperations = new List <object>();
foreach (CoreOperation operation in operations)
{
if (operation.hasMatchingSignature(paramTypes))
{
matchingOperations.Add(operation);
}
}
if (matchingOperations.Count == 1)
{
return((CoreOperation)matchingOperations[0]);
}
else
{
CoreOperation result = operationOwnerMatchingDesiredOwner(matchingOperations,
this);
if (result == null)
{
List <object> ancestors = getAllAncestors();
for (IEnumerator iter = ancestors.GetEnumerator(); iter.MoveNext() && (result == null);)
{
CoreClassifier ancestor = (CoreClassifier)iter.Current;
result = operationOwnerMatchingDesiredOwner(matchingOperations, ancestor);
}
}
return(result);
}
}
return(null);
}
private Environment getEnvironmentWithoutAncestors()
{
if (isDirty || envWithoutAncestors == null)
{
this.envWithoutAncestors =
EnvironmentFactoryManager.getInstance(this.getModel().getOclPackage()).getEnvironmentInstance();
populateWithFeatures(envWithoutAncestors);
populateWithAssociationEnds(envWithoutAncestors);
populateWithAssociationClasses(envWithoutAncestors);
populateWithDefinedFeatures(envWithoutAncestors);
if (isDirty)
{
base.resetEnvironments();
}
isDirty = false;
}
return(envWithoutAncestors);
}
/* (non-Javadoc)
* @see br.cos.ufrj.lens.odyssey.tools.psw.metamodels.core.interfaces.CoreClassifier#lookupOperation(java.lang.String, java.util.List)
*/
public override CoreOperation lookupOperation(String name, List <object> paramTypes)
{
Environment environment = getGenericTypeEnvironment();
if (environment != null)
{
List <object> operations = environment.lookupOperationLocal(name);
if (operations != null)
{
foreach (CoreOperation operation in operations)
{
CollectionOperationImpl result = (CollectionOperationImpl)getFactory().createCollectionOperation(operation, this);
if (result.hasMatchingSignature(paramTypes) && (!result.isInvalidSumOperation()))
{
return(result);
}
}
}
}
return(null);
}
/* (non-Javadoc)
* @see implocl20.CoreModelElementImpl#getElemOwnedElements()
*/
public override ICollection <object> getElemOwnedElements()
{
HashSet <object> resultAttr = new HashSet <object>();
HashSet <object> resultOper = new HashSet <object>();
HashSet <object> resultAssocEnd = new HashSet <object>();
Environment env = this.getEnvironmentWithoutAncestors();
resultAttr.AddRange(env.getAllOfType(typeof(CoreAttribute)));
resultOper.AddRange(env.getAllOfType(typeof(CoreOperation)));
resultAssocEnd.AddRange(env.getAllOfType(typeof(CoreAssociationEnd)));
List <object> allOwnedElements = new List <object>();
allOwnedElements.AddRange(resultAttr);
allOwnedElements.AddRange(resultOper);
allOwnedElements.AddRange(resultAssocEnd);
allOwnedElements.AddRange(this.getAllInvariants());
return(allOwnedElements);
}
public Environment getEnvironmentWithParents()
{
if (isDirty || this.environmentWithParents == null)
{
try {
this.environmentWithParents = EnvironmentFactoryManager.getInstance(this.getModel().getOclPackage()).getEnvironmentInstance();
this.environmentWithParents = this.environmentWithParents.addEnvironment(getEnvironmentWithoutParents());
} catch (NameClashException) {
// in this particular situation, there will be no name clash
}
CoreModelElement owner = this.getElemOwner();
if (owner != null && owner.GetType() == typeof(CoreNamespace))
{
this.environmentWithParents.setParent(((CoreNamespace)owner).getEnvironmentWithParents());
}
isDirty = false;
}
return(this.environmentWithParents);
}
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.GetType() == typeof(CoreClassifier) &&
wrapper.GetType() == typeof(CoreClassifier) &&
!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) {
}
}
}
public CoreModelElement doLookup(Environment env)
{
CoreModelElement foundElement = null;
foreach (NamedElement currentElement in ((EnvironmentImpl)env).getVariableDeclarations())
{
if (currentElement.isMayBeImplicit() &&
currentElement.getType() != null &&
((foundElement = doSpecificLookup(currentElement)) != null))
{
return(foundElement);
}
}
if (env.getParent() != null)
{
CoreModelElement result = doLookup(env.getParent());
return(result);
}
else
{
return(null);
}
}
public override void populateEnvironment(Environment environment)
{
bool isFirstLevel = true;
addAllClassifiersFromInnerPackages(isFirstLevel, this, environment);
}
public AncestorsPopulateEnvironmentStrategy(CoreClassifier cls, Environment env) : base(cls)
{
this.env = env;
}
protected override void resetEnvironments()
{
this.envWithoutAncestors = null;
base.resetEnvironments();
}
/**
* @param environment
*/
public void setParent(Environment environment)
{
this.parent = environment;
}
private void populateWithAncestorsFeatures(CoreClassifier classifier, Environment environment)
{
AncestorsPopulateEnvironmentStrategy visitor = new AncestorsPopulateEnvironmentStrategy(classifier, environment);
visitor.traverseAllAncestors();
}
public static void setEnvironment(CoreModel m)
{
model = m;
environment = m.getEnvironmentWithoutParents();
}
protected virtual void resetEnvironments()
{
this.environmentWithoutParents = null;
this.environmentWithParents = null;
}
