/* $Id: CoreHelperMDRImpl.java 18923 2010-12-18 12:19:00Z bobtarling $
*****************************************************************************
* Copyright (c) 2009-2010 Contributors - see below
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Thomas Neustupny
* Michiel van der Wulp
* Tom Morris
*****************************************************************************
*
* Some portions of this file was previously release using the BSD License:
*/
// Copyright (c) 2005-2008 The Regents of the University of California. All
// Rights Reserved. Permission to use, copy, modify, and distribute this
// software and its documentation without fee, and without a written
// agreement is hereby granted, provided that the above copyright notice
// and this paragraph appear in all copies. This software program and
// documentation are copyrighted by The Regents of the University of
// California. The software program and documentation are supplied "AS
// IS", without any accompanying services from The Regents. The Regents
// does not warrant that the operation of the program will be
// uninterrupted or error-free. The end-user understands that the program
// was developed for research purposes and is advised not to rely
// exclusively on the program for any reason. IN NO EVENT SHALL THE
// UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
// SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
// ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
// THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
// SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
// PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
// CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,
// UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
package org.argouml.model.mdr;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import javax.jmi.reflect.InvalidObjectException;
import org.apache.log4j.Logger;
import org.argouml.model.CoreFactory;
import org.argouml.model.CoreHelper;
import org.argouml.model.InvalidElementException;
import org.argouml.model.Model;
import org.argouml.model.ModelCommand;
import org.argouml.model.ModelManagementHelper;
import org.argouml.model.NotImplementedException;
import org.argouml.model.mdr.UndoCoreHelperDecorator.StringSetter;
import org.omg.uml.behavioralelements.activitygraphs.ActivityGraph;
import org.omg.uml.behavioralelements.activitygraphs.ClassifierInState;
import org.omg.uml.behavioralelements.activitygraphs.ObjectFlowState;
import org.omg.uml.behavioralelements.activitygraphs.Partition;
import org.omg.uml.behavioralelements.collaborations.AssociationEndRole;
import org.omg.uml.behavioralelements.collaborations.AssociationRole;
import org.omg.uml.behavioralelements.collaborations.ClassifierRole;
import org.omg.uml.behavioralelements.collaborations.Collaboration;
import org.omg.uml.behavioralelements.collaborations.CollaborationInstanceSet;
import org.omg.uml.behavioralelements.collaborations.Interaction;
import org.omg.uml.behavioralelements.collaborations.Message;
import org.omg.uml.behavioralelements.commonbehavior.Action;
import org.omg.uml.behavioralelements.commonbehavior.AttributeLink;
import org.omg.uml.behavioralelements.commonbehavior.ComponentInstance;
import org.omg.uml.behavioralelements.commonbehavior.DataValue;
import org.omg.uml.behavioralelements.commonbehavior.Instance;
import org.omg.uml.behavioralelements.commonbehavior.Link;
import org.omg.uml.behavioralelements.commonbehavior.LinkEnd;
import org.omg.uml.behavioralelements.commonbehavior.NodeInstance;
import org.omg.uml.behavioralelements.commonbehavior.Reception;
import org.omg.uml.behavioralelements.commonbehavior.Signal;
import org.omg.uml.behavioralelements.commonbehavior.Stimulus;
import org.omg.uml.behavioralelements.commonbehavior.SubsystemInstance;
import org.omg.uml.behavioralelements.statemachines.CompositeState;
import org.omg.uml.behavioralelements.statemachines.Event;
import org.omg.uml.behavioralelements.statemachines.Guard;
import org.omg.uml.behavioralelements.statemachines.Pseudostate;
import org.omg.uml.behavioralelements.statemachines.State;
import org.omg.uml.behavioralelements.statemachines.StateMachine;
import org.omg.uml.behavioralelements.statemachines.StateVertex;
import org.omg.uml.behavioralelements.statemachines.Transition;
import org.omg.uml.behavioralelements.usecases.Actor;
import org.omg.uml.behavioralelements.usecases.Extend;
import org.omg.uml.behavioralelements.usecases.Include;
import org.omg.uml.behavioralelements.usecases.UseCase;
import org.omg.uml.behavioralelements.usecases.UseCaseInstance;
import org.omg.uml.foundation.core.Abstraction;
import org.omg.uml.foundation.core.AssociationEnd;
import org.omg.uml.foundation.core.Attribute;
import org.omg.uml.foundation.core.BehavioralFeature;
import org.omg.uml.foundation.core.Binding;
import org.omg.uml.foundation.core.Classifier;
import org.omg.uml.foundation.core.Comment;
import org.omg.uml.foundation.core.Component;
import org.omg.uml.foundation.core.Constraint;
import org.omg.uml.foundation.core.DataType;
import org.omg.uml.foundation.core.Dependency;
import org.omg.uml.foundation.core.ElementResidence;
import org.omg.uml.foundation.core.Enumeration;
import org.omg.uml.foundation.core.EnumerationLiteral;
import org.omg.uml.foundation.core.Feature;
import org.omg.uml.foundation.core.Flow;
import org.omg.uml.foundation.core.GeneralizableElement;
import org.omg.uml.foundation.core.Generalization;
import org.omg.uml.foundation.core.Interface;
import org.omg.uml.foundation.core.Method;
import org.omg.uml.foundation.core.ModelElement;
import org.omg.uml.foundation.core.Namespace;
import org.omg.uml.foundation.core.Node;
import org.omg.uml.foundation.core.Operation;
import org.omg.uml.foundation.core.Parameter;
import org.omg.uml.foundation.core.Permission;
import org.omg.uml.foundation.core.Relationship;
import org.omg.uml.foundation.core.Stereotype;
import org.omg.uml.foundation.core.StructuralFeature;
import org.omg.uml.foundation.core.TagDefinition;
import org.omg.uml.foundation.core.TaggedValue;
import org.omg.uml.foundation.core.TemplateArgument;
import org.omg.uml.foundation.core.TemplateParameter;
import org.omg.uml.foundation.core.UmlAssociation;
import org.omg.uml.foundation.core.UmlClass;
import org.omg.uml.foundation.datatypes.AggregationKind;
import org.omg.uml.foundation.datatypes.AggregationKindEnum;
import org.omg.uml.foundation.datatypes.BooleanExpression;
import org.omg.uml.foundation.datatypes.CallConcurrencyKind;
import org.omg.uml.foundation.datatypes.ChangeableKind;
import org.omg.uml.foundation.datatypes.ChangeableKindEnum;
import org.omg.uml.foundation.datatypes.Expression;
import org.omg.uml.foundation.datatypes.Multiplicity;
import org.omg.uml.foundation.datatypes.OrderingKind;
import org.omg.uml.foundation.datatypes.ParameterDirectionKind;
import org.omg.uml.foundation.datatypes.ParameterDirectionKindEnum;
import org.omg.uml.foundation.datatypes.ProcedureExpression;
import org.omg.uml.foundation.datatypes.PseudostateKind;
import org.omg.uml.foundation.datatypes.ScopeKind;
import org.omg.uml.foundation.datatypes.ScopeKindEnum;
import org.omg.uml.foundation.datatypes.VisibilityKind;
import org.omg.uml.foundation.datatypes.VisibilityKindEnum;
import org.omg.uml.modelmanagement.ElementImport;
import org.omg.uml.modelmanagement.Subsystem;
import org.omg.uml.modelmanagement.UmlPackage;
/**
* The Core Helper implementation for MDR.<p>
*
* @since ARGO0.19.5
* @author Ludovic Maître
* @author Tom Morris
* derived from NSUML implementation by:
* @author Linus Tolke
*/
class CoreHelperMDRImpl implements CoreHelper {
/**
* Logger.
*/
private static final Logger LOG = Logger.getLogger(CoreHelperMDRImpl.class);
/**
* The model implementation.
*/
private MDRModelImplementation modelImpl;
/**
* Constructor.
*
* @param theModelImpl
* The MDRModelImplementation.
*/
public CoreHelperMDRImpl(MDRModelImplementation theModelImpl) {
super();
modelImpl = theModelImpl;
}
/**
* Return the first item from a collection using the most efficient method
* possible. Returns null for an empty collection.
*
* @param c
* The Collection.
* @return the first element of a Collection.
*/
private static Object getFirstItemOrNull(Collection c) {
if (c.size() == 0) {
return null;
}
if (c instanceof List) {
return ((List) c).get(0);
}
return c.iterator().next();
}
public boolean isSubType(Object type, Object subType) {
if (!(type instanceof Class) || !(subType instanceof Class)) {
throw new IllegalArgumentException("Metatypes are expected");
}
return ((Class) type).isAssignableFrom((Class) subType);
}
public Collection<GeneralizableElement> getAllSupertypes(Object cls1) {
if (!(cls1 instanceof Classifier)) {
throw new IllegalArgumentException();
}
GeneralizableElement ge = (GeneralizableElement) cls1;
Collection<GeneralizableElement> result =
new HashSet<GeneralizableElement>();
try {
Collection<GeneralizableElement> toBeAdded = getSupertypes(ge);
do {
Collection<GeneralizableElement> newlyAdded =
new HashSet<GeneralizableElement>();
for (GeneralizableElement element : toBeAdded) {
newlyAdded.addAll(getSupertypes(element));
}
result.addAll(toBeAdded);
toBeAdded = newlyAdded;
toBeAdded.removeAll(result);
} while (!toBeAdded.isEmpty());
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public Collection<GeneralizableElement> getSupertypes(Object genElement) {
Collection<GeneralizableElement> result =
new HashSet<GeneralizableElement>();
try {
if (genElement instanceof GeneralizableElement) {
for (Generalization gen : ((GeneralizableElement) genElement)
.getGeneralization()) {
result.add(gen.getParent());
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public Collection<Object> getUtilizedElements(Object artifact) {
throw new NotImplementedException("UML 1.4 artifacts have no manifestations with utilized elements");
}
public Collection<AssociationEnd> getAssociateEndsInh(Object classifier1) {
if (!(classifier1 instanceof Classifier)) {
throw new IllegalArgumentException();
}
Classifier classifier = (Classifier) classifier1;
Collection<AssociationEnd> result = new ArrayList<AssociationEnd>();
try {
result.addAll(modelImpl.getFacade().getAssociationEnds(classifier));
for (Generalization gen : classifier.getGeneralization()) {
Object parent = gen.getParent();
result.addAll(getAssociateEndsInh(parent));
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public void removeFeature(Object cls, Object feature) {
try {
if (cls instanceof Classifier && feature instanceof Feature) {
((Classifier) cls).getFeature().remove(feature);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("classifier: " + cls
+ " or feature: " + feature);
}
public void removeLiteral(Object enu, Object literal) {
try {
if (enu instanceof Enumeration
&& literal instanceof EnumerationLiteral) {
((Enumeration) enu).getLiteral().remove(literal);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("enumeration: " + enu
+ " or literal: " + literal);
}
public void setOperations(Object classifier, List operations) {
if (classifier instanceof Classifier) {
Classifier mclassifier = (Classifier) classifier;
List<Feature> result =
new ArrayList<Feature>(mclassifier.getFeature());
for (Feature feature : mclassifier.getFeature()) {
if (feature instanceof Operation) {
result.remove(feature);
}
}
result.addAll(operations);
// TODO: A minimal update strategy would be better here to
// minimize work and events firing, but it may be better to
// deprecate the method and force calls to manage updates
// themselves (since they probably usually want to just add
// or remove a single element) - tfm 20061108
mclassifier.getFeature().clear();
mclassifier.getFeature().addAll(result);
}
}
public void setAttributes(Object classifier, List attributes) {
if (classifier instanceof Classifier) {
Classifier mclassifier = (Classifier) classifier;
List<Feature> result =
new ArrayList<Feature>(mclassifier.getFeature());
for (Feature feature : mclassifier.getFeature()) {
if (feature instanceof Attribute) {
result.remove(feature);
}
}
result.addAll(attributes);
// TODO: This should use a minimal update strategy instead of
// removing everything and adding it again. - tfm
mclassifier.getFeature().clear();
mclassifier.getFeature().addAll(result);
}
}
public Collection<Attribute> getAttributesInh(Object classifier) {
if (!(classifier instanceof Classifier)) {
throw new IllegalArgumentException();
}
Collection result = new ArrayList();
try {
result.addAll(modelImpl.getFacade().getStructuralFeatures(
classifier));
for (Generalization gen : ((Classifier) classifier)
.getGeneralization()) {
result.addAll(getAttributesInh(gen.getParent()));
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public Collection<Operation> getOperationsInh(Object classifier) {
if (!(classifier instanceof Classifier)) {
throw new IllegalArgumentException();
}
Collection<Operation> result = new ArrayList<Operation>();
try {
result.addAll(modelImpl.getFacade().getOperations(classifier));
for (Generalization gen : ((Classifier) classifier)
.getGeneralization()) {
result.addAll(getOperationsInh(gen.getParent()));
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public Collection<GeneralizableElement> getParents(
Object generalizableElement) {
if (!(generalizableElement instanceof GeneralizableElement)) {
throw new IllegalArgumentException();
}
try {
return getParents((GeneralizableElement) generalizableElement);
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
/**
* Return the parents of a GeneralizableElement
* @param ge generalizable element
* @return parents of all generalizations
*/
static Collection<GeneralizableElement> getParents(
GeneralizableElement ge) {
Set<GeneralizableElement> result = new HashSet<GeneralizableElement>();
for (Generalization g : ge.getGeneralization()) {
result.add(g.getParent());
}
return result;
}
/**
* Return the parents of a GeneralizableElement and parents of those parents
* all the way up the hierarchy.
*
* @param ge generalizable element
* @return parents of all generalizations
*/
static Collection<GeneralizableElement> getAllParents(
GeneralizableElement ge) {
Collection<GeneralizableElement> result =
new HashSet<GeneralizableElement>(2000);
getAllParents(result, ge);
return result;
}
private static void getAllParents(
final Collection<GeneralizableElement> result,
final GeneralizableElement ge) {
for (Generalization g : ge.getGeneralization()) {
GeneralizableElement parent = g.getParent();
result.add(parent);
getAllParents(result, parent);
}
}
/**
* A recursive method that iterates through generalizable elements to find
* if the model element is visible from any super namespace.
*
* @param element the model element to test
* @param ge the namespace which is a generalizable element
* @param dupCheck Used to prevent recursion continuing endlessly due to
* cyclic generalizations in the model. This should be an empty Set
* except when this method calls itself recursively.
* @return true if the model element is visible from any part of the
* generalization hierarchy.
*/
private boolean isVisiblyOwned(
final ModelElement element,
final GeneralizableElement ge,
final Set<ModelElement> dupCheck) {
assert dupCheck != null;
assert ge != null;
assert element != null;
final boolean alreadyChecked = !dupCheck.add(ge);
if (alreadyChecked) {
LOG.warn("Cyclic generalization found " + getFullName(ge));
return false;
}
for (final Generalization g : ge.getGeneralization()) {
final GeneralizableElement parent = g.getParent();
if (parent instanceof Namespace
&& isVisiblyOwned(element, (Namespace) parent)) {
return true;
}
}
for (final Generalization g : ge.getGeneralization()) {
// Recurse into ourself for each parent
if (isVisiblyOwned(element, g.getParent(), dupCheck)) {
return true;
}
}
return false;
}
private String getFullName(ModelElement elem) {
String name = elem.getName();
while (elem.getNamespace() != null) {
elem = elem.getNamespace();
name = elem.getName() + "." + name;
}
return name;
}
public List<Parameter> getReturnParameters(Object bf) {
List<Parameter> returnParams = new ArrayList<Parameter>();
try {
for (Parameter parameter : ((BehavioralFeature) bf).getParameter()) {
if (ParameterDirectionKindEnum.PDK_RETURN.equals(parameter
.getKind())) {
returnParams.add(parameter);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return returnParams;
}
public Object getSpecification(Object object) {
if (!(object instanceof Method)) {
throw new IllegalArgumentException("Not a method : " + object);
}
try {
return ((Method) object).getSpecification();
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
public Collection<GeneralizableElement> getSubtypes(Object cls) {
if (!(cls instanceof Classifier)) {
throw new IllegalArgumentException();
}
Collection<GeneralizableElement> result =
new ArrayList<GeneralizableElement>();
try {
Collection<Generalization> gens = Model.getFacade()
.getSpecializations(cls);
for (Generalization gen : gens) {
result.add(gen.getChild());
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public Collection<BehavioralFeature> getAllBehavioralFeatures(Object element) {
if (!(element instanceof ModelElement)) {
throw new IllegalArgumentException();
}
List contents = new ArrayList();
List<BehavioralFeature> result = new ArrayList<BehavioralFeature>();
try {
contents.addAll(Model.getFacade()
.getTaggedValuesCollection(element));
contents.addAll(((ModelElement) element).getTemplateParameter());
Iterator it = contents.iterator();
while (it.hasNext()) {
Object o = it.next();
if (o instanceof Classifier) {
Classifier clazz = (Classifier) o;
if (!(clazz instanceof DataType)) {
for (Object o1 : clazz.getFeature()) {
if (o1 instanceof BehavioralFeature) {
result.add((BehavioralFeature) o1);
}
}
}
} else {
// TODO: 2nd next() for single hasNext()
result.addAll(getAllBehavioralFeatures(it.next()));
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public List<BehavioralFeature> getBehavioralFeatures(Object clazz) {
if (clazz instanceof Classifier) {
List<BehavioralFeature> ret = new ArrayList<BehavioralFeature>();
try {
for (Object o : modelImpl.getFacade().getFeatures(clazz)) {
if (o instanceof BehavioralFeature) {
ret.add((BehavioralFeature) o);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return ret;
} else {
throw new IllegalArgumentException("Argument is not a classifier");
}
}
public Collection<Interface> getAllInterfaces(Object ns) {
if (ns == null) {
return Collections.EMPTY_SET;
}
if (!(ns instanceof Namespace)) {
throw new IllegalArgumentException();
}
List<Interface> result = new ArrayList<Interface>();
for (Object o : ((Namespace) ns).getOwnedElement()) {
if (o instanceof Namespace) {
result.addAll(getAllInterfaces(o));
}
if (o instanceof Interface) {
result.add((Interface) o);
}
}
return result;
}
public Collection<UmlClass> getAllClasses(Object ns) {
if (ns == null) {
return Collections.EMPTY_SET;
}
if (!(ns instanceof Namespace)) {
throw new IllegalArgumentException();
}
List<UmlClass> result = new ArrayList<UmlClass>();
try {
for (Object o : ((Namespace) ns).getOwnedElement()) {
if (o instanceof Namespace) {
result.addAll(getAllClasses(o));
}
if (o instanceof UmlClass) {
result.add((UmlClass) o);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public Collection<Interface> getRealizedInterfaces(Object cls) {
Classifier classifier = (Classifier) cls;
if (classifier == null) {
return Collections.emptyList();
}
List<Interface> result = new ArrayList<Interface>();
// TODO: This should be using internalGetAllRealizedInterfaces()
try {
for (Dependency clientDependency
: classifier.getClientDependency()) {
if (clientDependency instanceof Abstraction) {
Abstraction abstraction = (Abstraction) clientDependency;
for (Stereotype stereo : abstraction.getStereotype()) {
if (stereo != null
&& CoreFactory.REALIZE_STEREOTYPE.equals(stereo
.getName())
// the following should always be true
&& stereo.getBaseClass()
.contains("Abstraction")) {
for (Object supplier : abstraction.getSupplier()) {
if (supplier instanceof Interface) {
result.add((Interface) supplier);
}
}
}
}
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public Collection<Classifier> getExtendedClassifiers(Object clazz) {
if (clazz == null) {
return Collections.EMPTY_SET;
}
List<Classifier> result = new ArrayList<Classifier>();
try {
for (Object gen : modelImpl.getFacade().getGeneralizations(clazz)) {
GeneralizableElement parent = ((Generalization) gen).getParent();
if (parent != null) {
// If we were handed a Classifier to start,
// this must be a Classifier
result.add((Classifier) parent);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public Object getGeneralization(Object achild, Object aparent) {
if (!(achild instanceof GeneralizableElement)
|| !(aparent instanceof GeneralizableElement)) {
throw new IllegalArgumentException();
}
GeneralizableElement child = (GeneralizableElement) achild;
GeneralizableElement parent = (GeneralizableElement) aparent;
try {
Iterator it =
modelImpl.getFacade().getGeneralizations(child).iterator();
while (it.hasNext()) {
Generalization gen = (Generalization) it.next();
if (gen.getParent() == parent) {
return gen;
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return null;
}
public String getBody(Object comment) {
if (comment instanceof Comment) {
/*
* In UML 1.3, the name is the only place to store text.
* In UML 1.4, there is a body as well, but some tools
* still seem to use name.
*/
try {
return ((Comment) comment).getBody();
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
throw new IllegalArgumentException();
}
public Collection<Flow> getFlows(Object source, Object target) {
if (!(source instanceof ModelElement)) {
throw new IllegalArgumentException("source");
}
if (!(target instanceof ModelElement)) {
throw new IllegalArgumentException("target");
}
List<Flow> ret = new ArrayList<Flow>();
try {
Collection<Flow> targetFlows = ((ModelElement) target).getTargetFlow();
for (Flow flow : ((ModelElement) source).getSourceFlow()) {
if (targetFlows.contains(flow)) {
ret.add(flow);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return ret;
}
public Collection<GeneralizableElement> getExtendingElements(Object clazz) {
if (clazz == null) {
return Collections.EMPTY_SET;
}
List<GeneralizableElement> list =
new ArrayList<GeneralizableElement>();
try {
for (Generalization gen : (Collection<Generalization>) modelImpl
.getFacade().getSpecializations(clazz)) {
GeneralizableElement client = gen.getChild();
if (client != null) {
list.add(client);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return list;
}
public Collection<Classifier> getExtendingClassifiers(Object clazz) {
if (clazz == null) {
return Collections.EMPTY_SET;
}
if (!(clazz instanceof Classifier)) {
throw new IllegalArgumentException();
}
List<Classifier> result = new ArrayList<Classifier>();
try {
for (Object gen : Model.getFacade().getSpecializations(clazz)) {
GeneralizableElement client = ((Generalization) gen).getChild();
if (client instanceof Classifier) {
result.add((Classifier) client);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public Collection<Component> getAllComponents(Object ns) {
if (ns == null) {
return Collections.EMPTY_SET;
}
if (!(ns instanceof Namespace)) {
throw new IllegalArgumentException();
}
List<Component> result = new ArrayList<Component>();
try {
for (Object o : ((Namespace) ns).getOwnedElement()) {
if (o instanceof Namespace) {
result.addAll(getAllComponents(o));
}
if (o instanceof Component) {
result.add((Component) o);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public Collection<DataType> getAllDataTypes(Object ns) {
if (ns == null) {
return Collections.EMPTY_SET;
}
if (!(ns instanceof Namespace)) {
throw new IllegalArgumentException();
}
List<DataType> result = new ArrayList<DataType>();
try {
for (Object o : ((Namespace) ns).getOwnedElement()) {
if (o instanceof Namespace) {
result.addAll(getAllDataTypes(o));
}
if (o instanceof DataType) {
result.add((DataType) o);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public Collection<Node> getAllNodes(Object ns) {
if (ns == null) {
return Collections.EMPTY_SET;
}
if (!(ns instanceof Namespace)) {
throw new IllegalArgumentException();
}
List<Node> result = new ArrayList<Node>();
try {
for (Object o : ((Namespace) ns).getOwnedElement()) {
if (o instanceof Namespace) {
result.addAll(getAllNodes(o));
}
if (o instanceof Node) {
result.add((Node) o);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public Collection<Classifier> getAssociatedClassifiers(Object aclassifier) {
Classifier classifier = (Classifier) aclassifier;
if (classifier == null) {
return Collections.EMPTY_SET;
}
List<Classifier> list = new ArrayList<Classifier>();
try {
for (AssociationEnd end : (Collection<AssociationEnd>) Model
.getFacade().getAssociationEnds(classifier)) {
UmlAssociation assoc = end.getAssociation();
for (AssociationEnd end2 : assoc.getConnection()) {
if (end2 != end) {
list.add(end2.getParticipant());
}
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return list;
}
public Collection<UmlAssociation> getAssociations(Object from, Object to) {
if (!(from instanceof Classifier) || !(to instanceof Classifier)) {
throw new IllegalArgumentException();
}
Set<UmlAssociation> ret = new HashSet<UmlAssociation>();
try {
for (AssociationEnd end : (Collection<AssociationEnd>) Model
.getFacade().getAssociationEnds(from)) {
UmlAssociation assoc = end.getAssociation();
for (AssociationEnd end2 : assoc.getConnection()) {
if (end2.getParticipant() == to) {
ret.add(assoc);
}
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return ret;
}
public Collection<Classifier> getAllClassifiers(Object namespace) {
if (namespace == null) {
throw new IllegalArgumentException();
}
List<Classifier> result = new ArrayList<Classifier>();
try {
for (Object o : ((Namespace) namespace).getOwnedElement()) {
if (o instanceof Namespace) {
result.addAll(getAllClassifiers(o));
}
if (o instanceof Classifier) {
result.add((Classifier) o);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public Collection<UmlAssociation> getAssociations(Object oclassifier) {
Collection<UmlAssociation> result = new ArrayList<UmlAssociation>();
try {
if (oclassifier instanceof Classifier) {
for (Object end : Model.getFacade().getAssociationEnds(
oclassifier)) {
result.add(((AssociationEnd) end).getAssociation());
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
public AssociationEnd getAssociationEnd(Object type, Object assoc) {
if (!(type instanceof Classifier)) {
throw new IllegalArgumentException();
}
if (!(assoc instanceof UmlAssociation)) {
throw new IllegalArgumentException();
}
try {
for (AssociationEnd end : (Collection<AssociationEnd>) Model
.getFacade().getAssociationEnds(type)) {
if (((UmlAssociation) assoc).getConnection().contains(end)) {
return end;
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return null;
}
public Collection<Attribute> getAllAttributes(Object clazz) {
if (clazz == null) {
return Collections.emptySet();
}
if (!(clazz instanceof Classifier)) {
throw new IllegalArgumentException();
}
List<Attribute> list = new ArrayList<Attribute>();
try {
for (Feature feature : ((Classifier) clazz).getFeature()) {
if (feature instanceof Attribute) {
list.add((Attribute) feature);
}
}
for (Object gen : modelImpl.getFacade().getGeneralizations(clazz)) {
list.addAll(getAllAttributes(gen));
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return list;
}
public Collection<ModelElement> getAllVisibleElements(Object ns) {
if (!(ns instanceof Namespace)) {
throw new IllegalArgumentException();
}
try {
return getAllVisibleElements((Namespace) ns);
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
/**
* Get all publicly visible elements in a namespace.
* @param ns the namespace
* @return all owned elements with a visibility of VK_PUBLIC
*/
static Collection<ModelElement> getAllVisibleElements(Namespace ns) {
Collection<ModelElement> result = new ArrayList<ModelElement>();
for (ModelElement element : ns.getOwnedElement()) {
if (VisibilityKindEnum.VK_PUBLIC.equals(element.getVisibility())) {
result.add(element);
}
}
return result;
}
public Object getSource(Object relationship) {
if (!(relationship instanceof Relationship)
&& !(relationship instanceof Link)
&& !(relationship instanceof Message)
&& !(relationship instanceof AssociationEnd)) {
throw new IllegalArgumentException("Argument "
+ relationship.toString() + " is not " + "a relationship");
}
try {
if (relationship instanceof Link) {
Iterator it =
modelImpl.getFacade()
.getConnections(relationship).iterator();
if (it.hasNext()) {
return modelImpl.getFacade().getInstance(it.next());
} else {
return null;
}
}
if (relationship instanceof UmlAssociation) {
UmlAssociation assoc = (UmlAssociation) relationship;
List<AssociationEnd> conns = assoc.getConnection();
if (conns == null || conns.isEmpty()) {
return null;
}
return conns.get(0).getParticipant();
}
if (relationship instanceof Generalization) {
Generalization gen = (Generalization) relationship;
return gen.getChild();
}
if (relationship instanceof Dependency) {
Dependency dep = (Dependency) relationship;
Collection<ModelElement> col = dep.getClient();
if (col.isEmpty()) {
return null;
}
return col.iterator().next();
}
if (relationship instanceof Flow) {
Flow flow = (Flow) relationship;
Collection<ModelElement> col = flow.getSource();
if (col.isEmpty()) {
return null;
}
return col.iterator().next();
}
if (relationship instanceof Extend) {
Extend extend = (Extend) relationship;
return extend.getExtension(); // we have to follow the
// arrows..
}
if (relationship instanceof Include) {
Include include = (Include) relationship;
return modelImpl.getFacade().getBase(include);
}
if (relationship instanceof AssociationEnd) {
return ((AssociationEnd) relationship).getAssociation();
}
if (relationship instanceof Message) {
return ((Message) relationship).getSender();
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return null;
}
public Object getDestination(Object relationship) {
if (!(relationship instanceof Relationship)
&& !(relationship instanceof Link)
&& !(relationship instanceof Message)
&& !(relationship instanceof AssociationEnd)) {
throw new IllegalArgumentException("Argument is not "
+ "a relationship");
}
try {
if (relationship instanceof Link) {
Iterator it = modelImpl.getFacade()
.getConnections(relationship).iterator();
if (it.hasNext()) {
it.next();
if (it.hasNext()) {
return modelImpl.getFacade().getInstance(it.next());
} else {
return null;
}
} else {
return null;
}
}
if (relationship instanceof UmlAssociation) {
UmlAssociation assoc = (UmlAssociation) relationship;
List<AssociationEnd> conns = assoc.getConnection();
if (conns.size() <= 1) {
return null;
}
return conns.get(1).getParticipant();
}
if (relationship instanceof Generalization) {
Generalization gen = (Generalization) relationship;
return gen.getParent();
}
if (relationship instanceof Dependency) {
Dependency dep = (Dependency) relationship;
Collection<ModelElement> col = dep.getSupplier();
if (col.isEmpty()) {
return null;
}
return getFirstItemOrNull(col);
}
if (relationship instanceof Flow) {
Flow flow = (Flow) relationship;
Collection<ModelElement> col = flow.getTarget();
if (col.isEmpty()) {
return null;
}
return getFirstItemOrNull(col);
}
if (relationship instanceof Extend) {
Extend extend = (Extend) relationship;
return extend.getBase();
}
if (relationship instanceof Include) {
Include include = (Include) relationship;
return modelImpl.getFacade().getAddition(include);
}
if (relationship instanceof AssociationEnd) {
return ((AssociationEnd) relationship).getParticipant();
}
if (relationship instanceof Message) {
return ((Message) relationship).getReceiver();
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return null;
}
public Collection<Dependency> getDependencies(Object supplierObj,
Object clientObj) {
if (!(supplierObj instanceof ModelElement)
|| !(clientObj instanceof ModelElement)) {
throw new IllegalArgumentException("invalid argument(s)");
}
ModelElement supplier = (ModelElement) supplierObj;
ModelElement client = (ModelElement) clientObj;
List<Dependency> ret = new ArrayList<Dependency>();
try {
Collection<Dependency> clientDependencies = client
.getClientDependency();
Iterator it =
Model.getFacade().getSupplierDependencies(supplier).iterator();
while (it.hasNext()) {
Dependency dep = (Dependency) it.next();
if (clientDependencies.contains(dep)) {
ret.add(dep);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return ret;
}
public Collection<Permission> getPackageImports(Object client) {
if (!(client instanceof Namespace)) {
throw new IllegalArgumentException("invalid argument");
}
List<Permission> result = new ArrayList<Permission>();
try {
for (Dependency dependency : ((ModelElement) client)
.getClientDependency()) {
if (dependency instanceof Permission
&& hasImportStereotype((Permission) dependency)) {
result.add((Permission) dependency);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return result;
}
/**
* Return true if the given Permission has any of our acceptable
* import stereotypes <code>import</code> or <code>access</code>.
* <p>
* NOTE: We don't currently consider the <code>friend</code> stereotype.
*
* @param permission Permission to test
* @return true if this is an import permission
*/
private boolean hasImportStereotype(Permission permission) {
return (Model.getExtensionMechanismsHelper().hasStereotype(permission,
ModelManagementHelper.IMPORT_STEREOTYPE)
|| Model.getExtensionMechanismsHelper().hasStereotype(
permission, ModelManagementHelper.ACCESS_STEREOTYPE)
// TODO: Do we want to <<friend>> stereotypes too?
// || Model.getExtensionMechanismsHelper().hasStereotype(
// permission, ModelManagementHelper.FRIEND_STEREOTYPE)
);
}
public Permission getPackageImport(Object supplier, Object client) {
for (Dependency dependency : getDependencies(supplier, client)) {
if (dependency instanceof Permission
&& Model.getExtensionMechanismsHelper()
.hasStereotype(dependency,
ModelManagementHelper.IMPORT_STEREOTYPE)) {
return (Permission) dependency;
}
}
return null;
}
public Collection getRelationships(Object source, Object dest) {
Set ret = new HashSet();
if (!(source instanceof ModelElement)) {
throw new IllegalArgumentException("source");
}
if (!(dest instanceof ModelElement)) {
throw new IllegalArgumentException("dest");
}
try {
ret.addAll(getFlows(source, dest));
ret.addAll(getFlows(dest, source));
ret.addAll(getDependencies(source, dest));
ret.addAll(getDependencies(dest, source));
if (source instanceof GeneralizableElement
&& dest instanceof GeneralizableElement) {
ret.add(getGeneralization(source, dest));
ret.add(getGeneralization(dest, source));
if (source instanceof Classifier
&& dest instanceof Classifier) {
ret.addAll(getAssociations(source, dest));
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return ret;
}
public boolean isValidNamespace(Object mObj, Object nsObj) {
if (!(mObj instanceof ModelElement) || !(nsObj instanceof Namespace)) {
return false;
}
ModelElement modelElement = (ModelElement) mObj;
Namespace ns = (Namespace) nsObj;
try {
if (modelElement == ns) {
return false;
}
if (ns instanceof Interface
|| ns instanceof Actor
|| ns instanceof DataType
|| ns instanceof DataValue
|| ns instanceof NodeInstance
|| ns instanceof Signal
// || ns instanceof UseCase // see comment below
|| ns instanceof UseCaseInstance
|| ns instanceof ClassifierInState) {
return false;
} else if (ns instanceof UseCase
&& modelElement instanceof Classifier) {
/*
* NOTE: Although WFR #3 in section 2.11.3.5 UseCase of the
* UML 1.4 spec says "A UseCase cannot contain any
* Classifiers," the OCL is actually self.contents->isEmpty
* which would seem to imply it can't contain any elements
* - tfm - 20060416
*/
return false;
} else if (ns instanceof Component) {
return (modelElement instanceof Component
&& modelElement != ns);
} else if (ns instanceof ComponentInstance) {
return (modelElement instanceof ComponentInstance
&& modelElement != ns);
} else if (ns
instanceof
org.omg.uml.behavioralelements.commonbehavior.Object) {
// Made following changes from OCL in UML 1.4 section 2.9.3.16:
// CollaborationInstance -> CollaborationInstanceSet
// Stimuli -> Stimulus
if (!(modelElement
instanceof
org.omg.uml.behavioralelements.commonbehavior.Object
|| modelElement instanceof DataValue
|| modelElement instanceof Link
|| modelElement instanceof UseCaseInstance
|| modelElement instanceof CollaborationInstanceSet
|| modelElement instanceof Stimulus)) {
return false;
}
} else if (ns instanceof SubsystemInstance) {
// Made following change from OCL in UML 1.4 section 2.9.3.22:
// CollaborationInstance -> CollaborationInstanceSet
if (!(modelElement
instanceof
org.omg.uml.behavioralelements.commonbehavior.Object
|| modelElement instanceof DataValue
|| modelElement instanceof Link
|| modelElement instanceof UseCaseInstance
|| modelElement instanceof CollaborationInstanceSet
|| modelElement instanceof SubsystemInstance
|| modelElement instanceof Stimulus)) {
return false;
}
} else if (ns instanceof Subsystem) {
if (!(modelElement instanceof UmlPackage
|| modelElement instanceof UmlClass
|| modelElement instanceof DataType
|| modelElement instanceof Interface
|| modelElement instanceof UseCase
|| modelElement instanceof Actor
|| modelElement instanceof Subsystem
|| modelElement instanceof Signal
|| modelElement instanceof UmlAssociation
|| modelElement instanceof Generalization
|| modelElement instanceof Dependency
|| modelElement instanceof Constraint
|| modelElement instanceof Collaboration
|| modelElement instanceof StateMachine
|| modelElement instanceof Stereotype)) {
return false;
}
} else if (modelElement instanceof ClassifierRole) {
return ns instanceof Collaboration;
} else if (ns instanceof Collaboration) {
/*
* Although not represented in the OCL (or our Java), the
* English text of WFR #4 of Section 2.10.3.4 in the UML 1.4
* spec is more restrictive - "[4] A Collaboration may only
* contain ClassifierRoles and AssociationRoles, the
* Generalizations and the Constraints between them, and
* Actions used in the Collaboration's Interactions."
*/
if (!(modelElement instanceof ClassifierRole
|| modelElement instanceof AssociationRole
|| modelElement instanceof Generalization
|| modelElement instanceof Action
|| modelElement instanceof Constraint)) {
return false;
}
} else if (ns instanceof UmlPackage) {
// A Profile is a special package having the <<profile>>
// stereotype which can only contain the following types
if (isProfilePackage(ns)) {
if (!(modelElement instanceof Stereotype
|| modelElement instanceof Constraint
|| modelElement instanceof TagDefinition
|| modelElement instanceof DataType)) {
return false;
}
} else {
if (!(modelElement instanceof UmlPackage
|| modelElement instanceof Classifier
|| modelElement instanceof UmlAssociation
|| modelElement instanceof Generalization
|| modelElement instanceof Dependency
/* The next 2 needed for issue 2148: */
|| modelElement instanceof Extend
|| modelElement instanceof Include
|| modelElement instanceof Constraint
|| modelElement instanceof Collaboration
|| modelElement instanceof StateMachine
|| modelElement instanceof Stereotype)) {
return false;
}
}
} else if (ns instanceof UmlClass) {
if (!(modelElement instanceof UmlClass
|| modelElement instanceof UmlAssociation
|| modelElement instanceof Generalization
|| modelElement instanceof UseCase
|| modelElement instanceof Constraint
|| modelElement instanceof Dependency
|| modelElement instanceof Collaboration
// Having StateMachine here would be non-standard.
// See issue 4284. Hence removed:
/* || modelElement instanceof StateMachine */
|| modelElement instanceof DataType
|| modelElement instanceof Interface)) {
return false;
}
} else if (ns instanceof ClassifierRole) {
ClassifierRole cr = (ClassifierRole) ns;
if (!(cr.getAvailableContents().contains(modelElement) || cr.
getAvailableFeature().contains(modelElement))) {
return false;
}
}
if (modelElement instanceof StructuralFeature) {
if (!isValidNamespace((StructuralFeature) modelElement, ns)) {
return false;
}
// TODO: Issue 6144. It is proposed to allow any paclage to return as a potential
// namespace. Commenting out until this is reviewed and clearly accepted by all.
// } else if (modelElement instanceof GeneralizableElement) {
// GeneralizableElement ge = (GeneralizableElement) modelElement;
// if (!isValidNamespace(ge, ns)) {
// return false;
// }
} else if (modelElement instanceof Generalization) {
if (!isValidNamespace((Generalization) modelElement, ns)) {
return false;
}
}
if (modelElement instanceof UmlAssociation) {
if (!isValidNamespace((UmlAssociation) modelElement, ns)) {
return false;
}
} else if (modelElement instanceof Collaboration) {
if (!isValidNamespace((Collaboration) modelElement, ns)) {
return false;
}
}
return true;
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
private boolean isProfilePackage(Namespace ns) {
// A Profile is a special package having the <<profile>> stereotype
return Model.getFacade().isStereotype(ns, "profile");
}
/**
* The base of a AssociationRole or ClassifierRole should be contained in
* the given Namespace. If no base is set (yet), then allow any namespace.
*
* @param collab the given collaboration
* @param ns the given candidate namespace
* @return true if the given namespace may contain the collaboration
*/
private boolean isValidNamespace(Collaboration collab, Namespace ns) {
for (ModelElement m : collab.getOwnedElement()) {
if (m instanceof ClassifierRole) {
ClassifierRole role = (ClassifierRole) m;
for (Classifier base : role.getBase()) {
if (!ns.getOwnedElement().contains(base)) {
return false;
}
}
} else if (m instanceof AssociationRole) {
AssociationRole ar = (AssociationRole) m;
UmlAssociation a = ar.getBase();
if (a != null && !ns.getOwnedElement().contains(a)) {
return false;
}
}
}
return true;
}
private boolean isValidNamespace(Generalization gen, Namespace ns) {
// TODO: Implement following WFR for GeneralizableElements
// [4] The parent must be included in the Namespace of the
// GeneralizableElement.
// self.generalization->forAll(g |
// self.namespace.allContents->includes(g.parent) )
// return ModelManagementHelperMDRImpl.getContents(ns).contains(
// gen.getParent());
// There actually don't appear to be any restrictions on the
// namespace for a Generalization. The UML 1.4 WFR 2.5.3.20 #3
// refers to GeneralizableElements, not Generalizations - tfm
return true;
// These old checks don't appear to be supported by the
// UML 1.4 spec. - tfm 20080514
// if (gen.getParent() == null || gen.getChild() == null) {
// return true;
// }
// Namespace ns1 = gen.getParent().getNamespace();
// Namespace ns2 = gen.getChild().getNamespace();
// if (ns == getFirstSharedNamespace(ns1, ns2)) {
// return true;
// }
// return false;
}
private boolean isValidNamespace(StructuralFeature struc, Namespace ns) {
// Technically this is legal, but a StructuralFeature should probably
// only ever have an owner instead of a namespace. - tfm
if (struc.getType() == null || struc.getOwner() == null) {
return true;
}
/*
* The following from the original NSUML implemenetation was attempting
* to implement WFR #1 from section 2.5.3.32 of the UML 1.4 spec, but if
* there is an owner set, no namespace is valid. The checks for this
* WFR, if desired, need to go in setOwner() and setType() - tfm
*/
// return struc.getOwner().getNamespace().getOwnedElement().contains(
// struc.getType());
return false;
}
private boolean isValidNamespace(
final UmlAssociation assoc,
final Namespace ns) {
for (AssociationEnd end : assoc.getConnection()) {
if (!isVisible(end.getParticipant(), ns)) {
return false;
}
}
return true;
}
/**
* Return true if the given element is visible from this namespace.
* <blockquote>The OCL that this is intended to check is this:
* self.allConnections->forAll(r | self.namespace.allContents->includes
(r.participant) ) or
self.allConnections->forAll(r | self.namespace.allContents->excludes
(r.participant) implies
self.namespace.clientDependency->exists (d |
d.oclIsTypeOf(Permission) and
d.stereotype.name = 'access' and
d.supplier.oclAsType(Namespace).ownedElement->select (e |
e.elementOwnership.visibility =
#public)->includes (r.participant) or
d.supplier.oclAsType(GeneralizableElement).
allParents.oclAsType(Namespace).ownedElement->select (e |
e. elementOwnership.visibility =
#public)->includes (r.participant) or
d.supplier.oclAsType(Package).allImportedElements->select (e |
e. elementImport.visibility =
#public) ->includes (r.participant) ) )
</blockquote>
* <p>
* NOTE: This is very similar to the logic in
* {@link ModelManagementHelperMDRImpl#getAllImportedElements(Object)}
* which returns a collection of imported elements. Here we quit as soon
* as we find the element that we're testing for (and we don't deal with
* the <code>friend</code> or <code>access</code> stereotypes.
*
* @param ns
* The namespace to check visibility from
* @param element
* the element to check for visibility
* @return Return true if the given element is visible from this namespace.
*/
private boolean isVisible(ModelElement element, Namespace ns) {
if (ns == null || element == null) {
return false;
}
// self.allConnections->forAll(r
// | self.namespace.allContents->includes(r.participant) )
Collection nsAllContents =
modelImpl.getModelManagementHelper().getAllContents(ns);
if (nsAllContents.contains(element)) {
return true;
}
// or
// self.allConnections->forAll(
// r | self.namespace.allContents->excludes
// (r.participant) implies
// self.namespace.clientDependency->exists (d |
// d.oclIsTypeOf(Permission) and
// d.stereotype.name = 'access' and
// TODO: this actually returns permissions with stereotypes
// of both <<access>> and <<import>> when the spec calls for
// only the former, but that seems to give different semantics
// to the way package imports work. Review to see which is wrong.
final Collection<Permission> permissions = getPackageImports(ns);
for (Permission imp : permissions) {
final Collection<ModelElement> suppliers = imp.getSupplier();
for (ModelElement me : suppliers) {
// d.supplier.oclAsType(Namespace).ownedElement->select (e |
// e.elementOwnership.visibility =
// #public)->includes (r.participant) or
if (me instanceof Namespace
&& isVisiblyOwned(element, (Namespace) me)) {
return true;
}
// d.supplier.oclAsType(GeneralizableElement).
// allParents.oclAsType(Namespace).ownedElement->select (e |
// e. elementOwnership.visibility =
// #public)->includes (r.participant) or
if (me instanceof GeneralizableElement) {
// TODO: Performance. Consider instantiating this just
// once outside the for loops and clear at this point
// instead.
final Set<ModelElement> dupCheck =
new HashSet<ModelElement>(10);
if (isVisiblyOwned(
element,
(GeneralizableElement) me,
dupCheck)) {
return true;
}
}
// d.supplier.oclAsType(Package).allImportedElements->select (
// e | e. elementImport.visibility =
// #public) ->includes (r.participant) ) )
if (me instanceof UmlPackage) {
final Collection<ElementImport> imports =
((UmlPackage) me).getElementImport();
for (ElementImport ei : imports) {
if (element.equals(ei.getImportedElement())
&& VisibilityKindEnum.VK_PUBLIC.equals(ei
.getVisibility())) {
return true;
}
}
}
}
}
return false;
}
/**
* Returns true if ModelElement is owned by the given Namespace and it is
* publicly visible.
*
* @param me ModelElement
* @param ns Namespace
* @return true if ModelElement is owned by the given Namespace and it is
* publicly visible.
*/
private boolean isVisiblyOwned(ModelElement me, Namespace ns) {
return ns.getOwnedElement().contains(me)
&& VisibilityKindEnum.VK_PUBLIC.equals(me.getVisibility());
}
/**
* This code tests WFR [4] of a GeneralizableElement,
* according OMG UML 1.4.2 standard page 59:
*
* [4]The parent must be included in the Namespace
* of the GeneralizableElement.
* self.generalization->forAll(g |
* self.namespace.allContents->includes(g.parent) )
*/
// TODO: Issue 6144. It is proposed to allow any paclage to return as a potential
// namespace. Commenting out until this is reviewed and clearly accepted by all.
// private boolean isValidNamespace(
// GeneralizableElement generalizableElement,
// Namespace namespace) {
//
// Collection<Generalization> generalizations =
// generalizableElement.getGeneralization();
//
// ModelManagementHelperMDRImpl modelManagementHelper =
// (ModelManagementHelperMDRImpl) modelImpl.getModelManagementHelper();
//
// for (Generalization generalization : generalizations) {
// final GeneralizableElement parent = generalization.getParent();
// final Set<ModelElement> results = new HashSet<ModelElement>(2000);
// final Set<ModelElement> dupCheck = new HashSet<ModelElement>(2000);
// modelManagementHelper.getAllContents(results, namespace, dupCheck);
// if (!results.contains(parent)) {
// return false;
// }
// }
// return true;
// }
public Namespace getFirstSharedNamespace(Object ns1, Object ns2) {
if (ns1 == null || ns2 == null) {
throw new IllegalArgumentException("null argument");
}
if (!(ns1 instanceof Namespace)) {
throw new IllegalArgumentException(
"Expecting a Namespace argument. Got a "
+ ns1.getClass().getName());
}
if (!(ns2 instanceof Namespace)) {
throw new IllegalArgumentException(
"Expecting a Namespace argument. Got a "
+ ns2.getClass().getName());
}
if (ns1 == ns2) {
return (Namespace) ns1;
}
try {
// Get the namespace hierarchy for each element
Iterator<Namespace> path1 = getPath((Namespace) ns1).iterator();
Iterator<Namespace> path2 = getPath((Namespace) ns2).iterator();
// Traverse the lists looking for the last (innermost) match
Namespace lastMatch = null;
while (path1.hasNext() && path2.hasNext()) {
Namespace element = path1.next();
if (element != path2.next()) {
return lastMatch;
}
lastMatch = element;
}
return lastMatch;
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
/*
* Return a list of namespaces enclosing this element.
* The list is ordered outer to inner. i.e. it starts at the root model.
*/
private List<Namespace> getPath(Namespace element) {
LinkedList<Namespace> path = new LinkedList<Namespace>();
path.add(element);
Namespace ns = element.getNamespace();
while (ns != null) {
path.addFirst(ns);
ns = ns.getNamespace();
}
return path;
}
public Collection<Namespace> getAllPossibleNamespaces(Object modelElement,
Object model) {
LOG.debug("getAllPossibleNamespaces start");
ModelElement m = (ModelElement) modelElement;
Collection<Namespace> ret = new HashSet<Namespace> ();
if (m == null) {
LOG.debug("getAllPossibleNamespaces end");
return ret;
}
try {
if (isValidNamespace(m, model)) {
ret.add((Namespace) model);
}
Collection<Namespace> namespaces = modelImpl
.getModelManagementHelper().getAllModelElementsOfKind(
model, Namespace.class);
for (Namespace ns : namespaces) {
if (isValidNamespace(m, ns)) {
ret.add(ns);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
if (LOG.isDebugEnabled()) {
// This is an expensive method that we should ensure is called
// rarely. Hence info level to track easily.
LOG.debug(
"getAllPossibleNamespaces returns "
+ ret.size() + " items");
}
return ret;
}
public Collection<GeneralizableElement> getChildren(Object o) {
if (o instanceof GeneralizableElement) {
Collection<GeneralizableElement> col =
new ArrayList<GeneralizableElement>();
Collection<Generalization> generalizations = new ArrayList<Generalization>();
try {
if (o instanceof GeneralizableElement) {
Collection<Generalization> specializations =
Model.getFacade().getSpecializations(o);
for (Generalization specialization : specializations) {
getChildren(col, specialization, generalizations);
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return col;
}
throw new IllegalArgumentException("Illegal arguments: " + o);
}
/**
* Adds all children recursively to the Collection in the first argument.
* The algorithm assumes that there is a cycle when a node has been visited
* twice using already known generalizations.
*
* @param currentChildren
* collection to collect them in.
* @param gen
* element whose children are added.
* @param generalizations
* the list of already traversed generalizations.
* @throws IllegalStateException
* if there is a circular reference.
*/
private void getChildren(Collection<GeneralizableElement> currentChildren,
Generalization gen, Collection<Generalization> generalizations) {
GeneralizableElement child = gen.getChild();
if (currentChildren.contains(child) && generalizations.contains(gen)) {
throw new IllegalStateException("Circular inheritance occured.");
} else {
currentChildren.add(child);
generalizations.add(gen);
}
Collection<Generalization> specializations =
Model.getFacade().getSpecializations(child);
for (Generalization specialization : specializations) {
getChildren(currentChildren, specialization, generalizations);
}
}
public Collection getAllRealizedInterfaces(Object o) {
try {
return internalGetAllRealizedInterfaces(o, new ArrayList(),
new HashSet());
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
/**
* Helper method for getAllRealizedInterfaces.
*
* @param o
* @param col
* @param visited
* @return Collection
*/
private Collection internalGetAllRealizedInterfaces(Object o,
Collection col, Set visited) {
visited.add(o);
if (o != null) {
if (o instanceof Classifier) {
Classifier clazz = (Classifier) o;
for (Dependency dependency : clazz.getClientDependency()) {
Stereotype stereo =
(Stereotype) getFirstItemOrNull(
dependency.getStereotype());
if (dependency instanceof Abstraction && stereo != null
&& CoreFactory.REALIZE_STEREOTYPE.equals(stereo
.getName())
&& "Abstraction".equals(stereo.getBaseClass())) {
col.addAll(dependency.getSupplier());
}
}
for (Object supertype : getSupertypes(o)) {
if (!visited.contains(supertype)) {
internalGetAllRealizedInterfaces(supertype, col,
visited);
}
}
}
}
return col;
}
public final boolean hasCompositeEnd(Object association) {
if (!(association instanceof UmlAssociation)) {
throw new IllegalArgumentException();
}
UmlAssociation association1 = (UmlAssociation) association;
try {
for (AssociationEnd end : association1.getConnection()) {
if (end.getAggregation() == AggregationKindEnum.AK_COMPOSITE) {
return true;
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return false;
}
public final boolean equalsAggregationKind(Object associationEnd,
String kindType) {
if (!(associationEnd instanceof AssociationEnd)) {
throw new IllegalArgumentException();
}
AssociationEnd associationEnd1 = (AssociationEnd) associationEnd;
// TODO: This should either be extended to support all AggreationKinds
// or it should be simplified/removed from the API - tfm - 20070331
if (kindType.equals("composite")) {
return AggregationKindEnum.AK_COMPOSITE.equals(associationEnd1.
getAggregation());
} else {
throw new IllegalArgumentException("kindType: " + kindType
+ " not supported");
}
}
public void removeAnnotatedElement(Object handle, Object me) {
if (handle instanceof Comment && me instanceof ModelElement) {
try {
if (((Comment) handle).getAnnotatedElement().contains(me)) {
((Comment) handle).getAnnotatedElement().remove(me);
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or model element: " + me);
}
public void removeClientDependency(Object handle, Object dep) {
try {
if (handle instanceof ModelElement && dep instanceof Dependency) {
ModelElement me = (ModelElement) handle;
Collection deps = me.getClientDependency();
if (deps != null && deps.contains(dep)) {
deps.remove(dep);
}
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException();
}
public void removeConnection(Object handle, Object connection) {
try {
if (handle instanceof UmlAssociation
&& connection instanceof AssociationEnd) {
((UmlAssociation) handle).getConnection().remove(connection);
return;
}
if (handle instanceof Link && connection instanceof LinkEnd) {
((Link) handle).getConnection().remove(connection);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle
+ " or connection: " + connection);
}
public void removeConstraint(Object handle, Object cons) {
try {
if (handle instanceof ModelElement && cons instanceof Constraint) {
((ModelElement) handle).getConstraint().remove(cons);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle + " or cons: "
+ cons);
}
public void removeOwnedElement(Object handle, Object value) {
try {
if (handle instanceof Namespace && value instanceof ModelElement) {
ModelElement elem = (ModelElement) value;
if (!(elem.getNamespace().equals(handle))) {
throw new IllegalStateException(
"ModelElement isn't in Namespace");
}
elem.setNamespace(null);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle + " or value: "
+ value);
}
public void removeParameter(Object handle, Object parameter) {
try {
if (parameter instanceof Parameter) {
if (handle instanceof ObjectFlowState) {
((ObjectFlowState) handle).getParameter().remove(
parameter);
return;
}
if (handle instanceof Event) {
((Event) handle).getParameter().remove(parameter);
return;
}
if (handle instanceof BehavioralFeature) {
((BehavioralFeature) handle).getParameter().remove(
parameter);
return;
}
if (handle instanceof Classifier) {
((Parameter) parameter).setType(null);
return;
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle
+ " or parameter: " + parameter);
}
public void removeQualifier(Object handle, Object qualifier) {
try {
if (qualifier instanceof Attribute) {
if (handle instanceof AssociationEnd) {
((AssociationEnd) handle).getQualifier().remove(
qualifier);
return;
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle
+ " or qualifier: " + qualifier);
}
public void removeSourceFlow(Object handle, Object flow) {
try {
if (handle instanceof ModelElement && flow instanceof Flow) {
((ModelElement) handle).getSourceFlow().remove(flow);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle + " or flow: "
+ flow);
}
public void removeSupplierDependency(Object supplier, Object dependency) {
try {
if (supplier instanceof ModelElement
&& dependency instanceof Dependency) {
((Dependency) dependency).getSupplier().remove(supplier);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("supplier: " + supplier
+ " or dependency: " + dependency);
}
public void removeTargetFlow(Object handle, Object flow) {
try {
if (handle instanceof ModelElement && flow instanceof Flow) {
((ModelElement) handle).getTargetFlow().remove(flow);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle + " or flow: "
+ flow);
}
public void removeTemplateArgument(Object handle, Object argument) {
try {
if (argument instanceof TemplateArgument) {
if (handle instanceof Binding) {
((Binding) handle).getArgument().remove(argument);
return;
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle
+ " or parameter: " + argument);
}
public void removeTemplateParameter(Object handle, Object parameter) {
try {
if (parameter instanceof TemplateParameter) {
if (handle instanceof ModelElement) {
((ModelElement) handle).getTemplateParameter().remove(
parameter);
return;
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle
+ " or parameter: " + parameter);
}
public void addAnnotatedElement(Object comment, Object annotatedElement) {
if (comment instanceof Comment
&& annotatedElement instanceof ModelElement) {
((Comment) comment).getAnnotatedElement().add((ModelElement) annotatedElement);
return;
}
throw new IllegalArgumentException("comment: " + comment
+ " or annotatedElement: " + annotatedElement);
}
public void addClient(Object handle, Object element) {
if (handle instanceof Dependency && element instanceof ModelElement) {
((Dependency) handle).getClient().add((ModelElement) element);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or element: " + element);
}
public void addClientDependency(Object handle, Object dependency) {
if (handle instanceof ModelElement
&& dependency instanceof Dependency) {
((ModelElement) handle).getClientDependency().add(
(Dependency) dependency);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or dependency: " + dependency);
}
public void addComment(Object element, Object comment) {
if (element instanceof ModelElement && comment instanceof Comment) {
((ModelElement) element).getComment().add((Comment) comment);
return;
}
throw new IllegalArgumentException("element: " + element);
}
public void addConnection(Object handle, Object connection) {
if (handle instanceof UmlAssociation
&& connection instanceof AssociationEnd) {
List<AssociationEnd> ends =
((UmlAssociation) handle).getConnection();
ends.add((AssociationEnd) connection);
// UML 1.4 WFR 2.5.3.1 #3
if (ends.size() >= 3) {
for (AssociationEnd end : ends) {
end.setAggregation(AggregationKindEnum.AK_NONE);
}
}
return;
}
if (handle instanceof Link && connection instanceof LinkEnd) {
((Link) handle).getConnection().add((LinkEnd) connection);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or connection: " + connection);
}
public void addConnection(Object handle, int position, Object connection) {
if (handle instanceof UmlAssociation
&& connection instanceof AssociationEnd) {
((UmlAssociation) handle).getConnection().add(position,
(AssociationEnd) connection);
List<AssociationEnd> ends =
((UmlAssociation) handle).getConnection();
// UML 1.4 WFR 2.5.3.1 #3 - no aggregation for N-ary associations
if (ends.size() >= 3) {
for (AssociationEnd end : ends) {
end.setAggregation(AggregationKindEnum.AK_NONE);
}
}
return;
}
/* Strange, but the Link.getConnection()
* returns a Collection, not a List!
* This is a bug, compared to the UML standard (IMHO, mvw).
* Hence, the LinkEnd is added to the end instead... */
if (handle instanceof Link && connection instanceof LinkEnd) {
((Link) handle).getConnection().add((LinkEnd) connection);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or connection: " + connection);
}
public void addConstraint(Object handle, Object mc) {
if (handle instanceof ModelElement && mc instanceof Constraint) {
((ModelElement) handle).getConstraint().add((Constraint) mc);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or mc: "
+ mc);
}
public void addDeploymentLocation(Object handle, Object node) {
if (handle instanceof Component && node instanceof Node) {
((Component) handle).getDeploymentLocation().add((Node) node);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or node: "
+ node);
}
public void addElementResidence(Object handle, Object node) {
// TODO: This is ambiguous as to whether it should be adding a container
// or resident.
if (handle instanceof ModelElement
&& node instanceof ElementResidence) {
((ElementResidence) node).setResident((ModelElement) handle);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or node: "
+ node);
}
public void removeElementResidence(Object handle, Object node) {
try {
if (handle instanceof ModelElement
&& node instanceof ElementResidence) {
((ElementResidence) node).setResident(null);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle + " or node: "
+ node);
}
/**
* Get ElementResidences.
*
* TODO: Unused. Should be added to Facade? - tfm
*
* @param handle A modelElement
* @return Collection The ElementResidence for this model element
*/
public Collection<ElementResidence> getElementResidence(Object handle) {
try {
if (handle instanceof ModelElement) {
return ((org.omg.uml.UmlPackage) ((ModelElement) handle)
.refOutermostPackage()).getCore()
.getAResidentElementResidence().getElementResidence(
(ModelElement) handle);
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle);
}
public void addFeature(Object handle, int index, Object f) {
if (handle instanceof Classifier && f instanceof Feature) {
((Classifier) handle).getFeature().add(index, (Feature) f);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or f: " + f);
}
public void addLiteral(Object handle, int index, Object literal) {
if (handle instanceof Enumeration
&& literal instanceof EnumerationLiteral) {
((Enumeration) handle).getLiteral().add(index,
(EnumerationLiteral) literal);
return;
}
throw new IllegalArgumentException("enumeration: " + handle
+ " or literal: " + literal);
}
public void addFeature(Object handle, Object f) {
if (handle instanceof Classifier && f instanceof Feature) {
((Classifier) handle).getFeature().add((Feature) f);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void addLink(Object handle, Object link) {
if (handle instanceof UmlAssociation && link instanceof Link) {
((Link) link).setAssociation((UmlAssociation) handle);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or link: "
+ link);
}
public void addManifestation(Object handle, Object manifestation) {
throw new NotImplementedException( "UML 1.4 has no manifestations");
}
public void addMethod(Object handle, Object m) {
if (handle instanceof Operation && m instanceof Method) {
((Method) m).setVisibility(((Operation) handle).getVisibility());
((Method) m).setOwnerScope(((Operation) handle).getOwnerScope());
((Method) m).setSpecification((Operation) handle);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or m: " + m);
}
public void addOwnedElement(Object handle, Object me) {
if (handle instanceof Namespace && me instanceof ModelElement) {
Namespace ns = (Namespace) handle;
ModelElement elem = (ModelElement) me;
elem.setNamespace(ns);
ns.getOwnedElement().add(elem);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or me: "
+ me);
}
public void addParameter(Object handle, int index, Object parameter) {
if (parameter instanceof Parameter) {
if (handle instanceof Event) {
((Event) handle).getParameter().add(index,
(Parameter) parameter);
return;
}
if (handle instanceof BehavioralFeature) {
((BehavioralFeature) handle).getParameter().add(index,
(Parameter) parameter);
return;
}
}
throw new IllegalArgumentException("handle: " + handle
+ " or parameter: " + parameter);
}
public void addParameter(Object handle, Object parameter) {
if (parameter instanceof Parameter) {
if (handle instanceof ObjectFlowState) {
((ObjectFlowState) handle).getParameter().add(
(Parameter) parameter);
return;
}
if (handle instanceof Event) {
((Event) handle).getParameter().add((Parameter) parameter);
return;
}
if (handle instanceof BehavioralFeature) {
((BehavioralFeature) handle).getParameter().add(
(Parameter) parameter);
return;
}
if (handle instanceof Classifier) {
((Parameter) parameter).setType((Classifier) handle);
return;
}
}
throw new IllegalArgumentException("handle: " + handle
+ " or parameter: " + parameter);
}
public void addQualifier(Object handle, int index, Object qualifier) {
if (qualifier instanceof Attribute) {
if (handle instanceof AssociationEnd) {
((AssociationEnd) handle).getQualifier().add(index,
(Attribute) qualifier);
return;
}
}
throw new IllegalArgumentException("handle: " + handle
+ " or qualifier: " + qualifier);
}
public void addRaisedSignal(Object handle, Object sig) {
if (sig instanceof Signal) {
if (handle instanceof Message) {
((org.omg.uml.UmlPackage) ((Signal) sig)
.refOutermostPackage()).getCommonBehavior()
.getAContextRaisedSignal().add(
(BehavioralFeature) handle, (Signal) sig);
return;
}
if (handle instanceof Operation) {
((org.omg.uml.UmlPackage) ((Signal) sig).refOutermostPackage())
.getCommonBehavior().getAContextRaisedSignal().add(
(BehavioralFeature) handle, (Signal) sig);
return;
}
}
throw new IllegalArgumentException("handle: " + handle + " or sig: "
+ sig);
}
/**
* Dummy method for exceptions in MDR metamodel.
*
* @author Andreas Rueckert <a_rueckert@gmx.net>
*
* @see org.argouml.model.CoreHelper#addRaisedException(java.lang.Object, java.lang.Object)
*/
public void addRaisedException(Object handle, Object Exception) {
throw new NotImplementedException( "UML 1.4 has no exceptions for operations");
}
public void addSourceFlow(Object handle, Object flow) {
if (handle instanceof ModelElement && flow instanceof Flow) {
((ModelElement) handle).getSourceFlow().add((Flow) flow);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or flow: "
+ flow);
}
public void addSupplier(Object handle, Object element) {
if (handle instanceof Dependency && element instanceof ModelElement) {
((Dependency) handle).getSupplier().add((ModelElement) element);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or element: " + element);
}
public void addSupplierDependency(Object supplier, Object dependency) {
if (supplier instanceof ModelElement
&& dependency instanceof Dependency) {
((Dependency) dependency).getSupplier()
.add((ModelElement) supplier);
return;
}
throw new IllegalArgumentException("supplier: " + supplier
+ " or dependency: " + dependency);
}
public void addTargetFlow(Object handle, Object flow) {
if (handle instanceof ModelElement && flow instanceof Flow) {
((ModelElement) handle).getTargetFlow().add((Flow) flow);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or flow: "
+ flow);
}
public void addTemplateArgument(Object handle, int index, Object argument) {
if (argument instanceof TemplateArgument) {
if (handle instanceof Binding) {
((Binding) handle).getArgument().add(index,
(TemplateArgument) argument);
return;
}
}
throw new IllegalArgumentException("handle: " + handle
+ " or parameter: " + argument);
}
public void addTemplateArgument(Object handle, Object argument) {
if (argument instanceof TemplateArgument
&& handle instanceof Binding) {
((Binding) handle).getArgument().add((TemplateArgument) argument);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or argument: " + argument);
}
public void addTemplateParameter(Object handle, int index,
Object parameter) {
if (parameter instanceof TemplateParameter) {
if (handle instanceof ModelElement) {
((ModelElement) handle).getTemplateParameter().add(
index, (TemplateParameter) parameter);
return;
}
}
throw new IllegalArgumentException("handle: " + handle
+ " or parameter: " + parameter);
}
public void addTemplateParameter(Object handle, Object parameter) {
if (parameter instanceof TemplateParameter) {
if (handle instanceof ModelElement) {
((ModelElement) handle).getTemplateParameter().add(
(TemplateParameter) parameter);
return;
}
}
throw new IllegalArgumentException("handle: " + handle
+ " or parameter: " + parameter);
}
public void setAbstract(Object handle, boolean flag) {
if (handle instanceof GeneralizableElement) {
((GeneralizableElement) handle).setAbstract(flag);
return;
}
if (handle instanceof Operation) {
((Operation) handle).setAbstract(flag);
return;
}
if (handle instanceof Reception) {
((Reception) handle).setAbstract(flag);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setActive(Object handle, boolean active) {
if (handle instanceof UmlClass) {
((UmlClass) handle).setActive(active);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setAggregation(Object handle, Object aggregationKind) {
if (handle instanceof AssociationEnd
&& aggregationKind instanceof AggregationKind) {
AggregationKind ak = (AggregationKind) aggregationKind;
AssociationEnd ae = (AssociationEnd) handle;
// We silently ignore requests which conflict with
// UML 1.4 WFR 2.5.3.1 #3 - no aggregation for n-ary associations
if (ak == AggregationKindEnum.AK_NONE
|| ae.getAssociation().getConnection().size() < 3) {
ae.setAggregation(ak);
} else {
ae.setAggregation(AggregationKindEnum.AK_NONE);
}
// If we made something aggregate, make sure the other ends conform
// to UML 1.4 WFR 2.5.3.1 #2 - no more than one aggregate end
if (ak == AggregationKindEnum.AK_AGGREGATE
|| ak == AggregationKindEnum.AK_COMPOSITE) {
for (AssociationEnd end : ae.getAssociation().getConnection()) {
if (!end.equals(ae)
&& end.getAggregation() != AggregationKindEnum.AK_NONE) {
end.setAggregation(AggregationKindEnum.AK_NONE);
}
}
}
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or aggregationKind: " + aggregationKind);
}
public void setAnnotatedElements(Object handle, Collection elems) {
if (handle instanceof Comment && elems instanceof List) {
CollectionHelper.update(
((Comment) handle).getAnnotatedElement(), elems);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setAssociation(Object handle, Object association) {
if (association instanceof UmlAssociation) {
if (handle instanceof AssociationEnd) {
((AssociationEnd) handle).
setAssociation((UmlAssociation) association);
return;
}
if (handle instanceof Link) {
((Link) handle).setAssociation((UmlAssociation) association);
return;
}
} else if (association instanceof AssociationRole) {
if (handle instanceof AssociationEndRole) {
((AssociationEndRole) handle).
setAssociation((AssociationRole) association);
return;
}
}
throw new IllegalArgumentException("handle: " + handle
+ " or association: " + association);
}
public void setLeaf(Object handle, boolean flag) {
if (handle instanceof Reception) {
((Reception) handle).setLeaf(flag);
return;
}
if (handle instanceof Operation) {
((Operation) handle).setLeaf(flag);
return;
}
if (handle instanceof GeneralizableElement) {
((GeneralizableElement) handle).setLeaf(flag);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setRaisedSignals(Object handle, Collection raisedSignals) {
throw new NotImplementedException();
}
public void setBody(Object handle, Object expr) {
if (handle instanceof Method
&& (expr == null || expr instanceof ProcedureExpression)) {
ProcedureExpression oldPe = ((Method)handle).getBody();
if (!equal(oldPe, (ProcedureExpression) expr)) {
((Method) handle).setBody(null);
if (oldPe != null) {
Model.getUmlFactory().delete(oldPe);
}
((Method) handle).setBody((ProcedureExpression) expr);
}
return;
}
if (handle instanceof Constraint
&& (expr == null || expr instanceof BooleanExpression)) {
BooleanExpression oldBe = ((Constraint)handle).getBody();
if (!equal(oldBe, (BooleanExpression) expr)) {
((Constraint) handle).setBody((BooleanExpression) expr);
if (oldBe != null) {
Model.getUmlFactory().delete(oldBe);
}
}
return;
}
throw new IllegalArgumentException("handle: " + handle + " or expr: "
+ expr);
}
private boolean equal(Expression expr1, Expression expr2) {
if (expr1 == null) {
if (expr2 == null) {
return true;
} else {
return false;
}
} else {
return expr1.equals(expr2);
}
}
@Deprecated
public void setChangeability(Object handle, Object ck) {
if (ck == null || ck instanceof ChangeableKind) {
ChangeableKind changeableKind = (ChangeableKind) ck;
if (handle instanceof StructuralFeature) {
((StructuralFeature) handle).setChangeability(changeableKind);
return;
}
if (handle instanceof AssociationEnd) {
((AssociationEnd) handle).setChangeability(changeableKind);
return;
}
}
throw new IllegalArgumentException("handle: " + handle + " or ck: "
+ ck);
}
public void setReadOnly(Object handle, boolean isReadOnly) {
setChangeability(handle, isReadOnly ? ChangeableKindEnum.CK_FROZEN
: ChangeableKindEnum.CK_CHANGEABLE);
}
public void setChild(Object handle, Object child) {
if (handle instanceof Generalization) {
((Generalization) handle).setChild((GeneralizableElement) child);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or child: "
+ child);
}
public void setConcurrency(Object handle, Object concurrencyKind) {
if (handle instanceof Operation
&& concurrencyKind instanceof CallConcurrencyKind) {
((Operation) handle).
setConcurrency((CallConcurrencyKind) concurrencyKind);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or concurrencyKind: " + concurrencyKind);
}
public void setConnections(Object handle, Collection elems) {
if (handle instanceof UmlAssociation && elems instanceof List) {
List<AssociationEnd> ends =
((UmlAssociation) handle).getConnection();
CollectionHelper.update(ends, elems);
// UML 1.4 WFR 2.5.3.1 #3 - no aggregation for N-ary associations
if (ends.size() >= 3) {
for (AssociationEnd end : ends) {
end.setAggregation(AggregationKindEnum.AK_NONE);
}
}
return;
}
if (handle instanceof Link && elems instanceof List) {
CollectionHelper.update(
((Link) handle).getConnection(), elems);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setDefaultElement(Object handle, Object element) {
if (handle instanceof TemplateParameter
&& element instanceof ModelElement) {
((TemplateParameter) handle)
.setDefaultElement((ModelElement) element);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or model element: " + element);
}
public void setDefaultValue(Object handle, Object expr) {
if (handle instanceof Parameter
&& (expr == null || expr instanceof Expression)) {
Expression oldExp = ((Parameter) handle).getDefaultValue();
if (!equal(oldExp, (Expression) expr)) {
((Parameter) handle).setDefaultValue((Expression) expr);
if (oldExp != null) {
Model.getUmlFactory().delete(oldExp);
}
}
return;
}
throw new IllegalArgumentException("handle: " + handle + " or expr: "
+ expr);
}
public void setDiscriminator(Object handle, String discriminator) {
if (handle instanceof Generalization) {
((Generalization) handle).setDiscriminator(discriminator);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setFeature(Object elem, int i, Object impl) {
if (elem instanceof Classifier && impl instanceof Feature) {
((Classifier) elem).getFeature().add(i, (Feature) impl);
return;
}
throw new IllegalArgumentException("elem: " + elem + " or impl: "
+ impl);
}
public void setFeatures(Object handle, Collection features) {
if (handle instanceof Classifier) {
List featuresList = null;
if (features instanceof List) {
featuresList = (List) features;
} else {
featuresList = new ArrayList(features);
}
// TODO: A minimal update strategy would be better here to
// minimize work and events firing, but it may be better to
// deprecate the method and force calls to manage updates
// themselves (since they probably usually want to just add
// or remove a single element) - tfm 20061108
((Classifier) handle).getFeature().clear();
((Classifier) handle).getFeature().addAll(featuresList);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setContainer(Object handle, Object container) {
if (handle instanceof ElementResidence
&& (container instanceof Component || container == null)) {
ElementResidence er = (ElementResidence) handle;
er.setContainer((Component) container);
} else {
throw new IllegalArgumentException("handle: " + handle
+ " or container: " + container);
}
}
public void setInitialValue(Object at, Object expr) {
if (at instanceof Attribute
&& (expr == null || expr instanceof Expression)) {
Expression oldExp = ((Attribute) at).getInitialValue();
if (!equal(oldExp, (Expression) expr)) {
((Attribute) at).setInitialValue((Expression) expr);
if (oldExp != null) {
Model.getUmlFactory().delete(oldExp);
}
}
return;
}
throw new IllegalArgumentException("at: " + at + " or expr: " + expr);
}
public void setKind(Object handle, Object kind) {
if (handle instanceof Parameter
&& kind instanceof ParameterDirectionKind) {
((Parameter) handle).setKind((ParameterDirectionKind) kind);
return;
}
if (handle instanceof Pseudostate && kind instanceof PseudostateKind) {
((Pseudostate) handle).setKind((PseudostateKind) kind);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or kind: "
+ kind);
}
public void setModelElementContainer(Object handle, Object container) {
/*
* <em>Warning: when changing the implementation of this method be
* warned that the sequence of the if then else tree DOES matter.</em>
* Most notabely, do not move the setNamespace method any level up in
* the tree.<p>
*/
if (handle instanceof Partition && container instanceof ActivityGraph) {
((Partition) handle).setActivityGraph((ActivityGraph) container);
} else if (handle instanceof ModelElement
&& container instanceof Partition) {
((Partition) container).getContents().add((ModelElement) handle);
} else if (handle instanceof Constraint
&& container instanceof Stereotype) {
((Stereotype) container).getStereotypeConstraint().add(
(Constraint) handle);
} else if (handle instanceof Interaction
&& container instanceof Collaboration) {
((Interaction) handle).setContext((Collaboration) container);
} else if (handle instanceof ElementResidence
&& (container instanceof Component || container == null)) {
ElementResidence er = (ElementResidence) handle;
er.setContainer((Component) container);
} else if (handle instanceof AttributeLink
&& container instanceof Instance) {
((AttributeLink) handle).setInstance((Instance) container);
} else if (handle instanceof Message
&& container instanceof Interaction) {
((Message) handle).setInteraction((Interaction) container);
} else if (handle instanceof LinkEnd && container instanceof Link) {
((LinkEnd) handle).setLink((Link) container);
} else if (handle instanceof AttributeLink
&& container instanceof LinkEnd) {
((AttributeLink) handle).setLinkEnd((LinkEnd) container);
} else if (handle instanceof TaggedValue
&& container instanceof Stereotype) {
((TaggedValue) handle).getStereotype().clear();
((TaggedValue) handle).getStereotype().add((Stereotype) container);
} else if (handle instanceof TaggedValue
&& container instanceof ModelElement) {
((TaggedValue) handle).setModelElement((ModelElement) container);
} else if (handle instanceof StateVertex
&& container instanceof CompositeState) {
((StateVertex) handle).setContainer((CompositeState) container);
} else if (handle instanceof ElementImport
&& container instanceof UmlPackage) {
((ElementImport) handle).setUmlPackage((UmlPackage) container);
} else if (handle instanceof Transition && container instanceof State) {
((State) container).getInternalTransition()
.add((Transition) handle);
} else if (handle instanceof State
&& container instanceof StateMachine) {
((State) handle).setStateMachine((StateMachine) container);
} else if (handle instanceof Transition
&& container instanceof StateMachine) {
((Transition) handle).setStateMachine((StateMachine) container);
} else if (handle instanceof Action
&& container instanceof Transition) {
((Transition) container).setEffect((Action) handle);
} else if (handle instanceof Guard && container instanceof Transition) {
((Guard) handle).setTransition((Transition) container);
} else if (handle instanceof ModelElement
&& container instanceof Namespace) {
((ModelElement) handle).setNamespace((Namespace) container);
} else {
throw new IllegalArgumentException("handle: " + handle
+ " or container: " + container);
}
}
public void setMultiplicity(Object handle, String arg) {
setMultiplicity(handle,createMultiplicity(arg));
}
private void setMultiplicity(Object handle, Multiplicity arg) {
Multiplicity previousMult =
(Multiplicity) Model.getFacade().getMultiplicity(handle);
if (handle instanceof AssociationRole) {
((AssociationRole) handle).setMultiplicity(arg);
} else if (handle instanceof ClassifierRole) {
((ClassifierRole) handle).setMultiplicity(arg);
} else if (handle instanceof StructuralFeature) {
((StructuralFeature) handle).setMultiplicity(arg);
} else if (handle instanceof AssociationEnd) {
((AssociationEnd) handle).setMultiplicity(arg);
} else if (handle instanceof TagDefinition) {
((TagDefinition) handle).setMultiplicity(arg);
}
if (previousMult != null &&
Model.getFacade().getModelElementContainer(previousMult)
== null) {
if (LOG.isDebugEnabled()) {
LOG.debug("Previous multiplicity of " + handle + " will be deleted." + arg);
}
Model.getUmlFactory().delete(previousMult);
}
}
@Deprecated
public void setMultiplicity(Object handle, Object arg) {
if (arg instanceof String) {
setMultiplicity(handle, (String) arg);
return;
}
if (arg == null || arg instanceof Multiplicity) {
setMultiplicity(handle, (Multiplicity) arg);
} else {
throw new IllegalArgumentException("handle: " + handle + " or arg: "
+ arg);
}
}
private Multiplicity createMultiplicity(String sarg) {
boolean allDigits = true;
for (int i=0; i < sarg.length(); ++i) {
if (!Character.isDigit(sarg.charAt(i))) {
allDigits = false;
}
}
if (allDigits || sarg.indexOf('.') > -1 || sarg.indexOf(',') > -1) {
return modelImpl.getDataTypesFactoryInternal()
.createMultiplicityInternal(sarg);
} else {
// TODO: We have multiple string representations for multiplicities
// these should be consolidated. This form is used by
// org.argouml.uml.reveng
if ("1_N".equals(sarg)) {
return modelImpl.getDataTypesFactoryInternal()
.createMultiplicityInternal(1, -1);
} else {
return modelImpl.getDataTypesFactoryInternal()
.createMultiplicityInternal(1, 1);
}
}
}
public void setMultiplicity(Object handle, int lower, int upper) {
Multiplicity arg = modelImpl.getDataTypesFactoryInternal()
.createMultiplicityInternal(lower, upper);
setMultiplicity(handle, arg);
}
public void setName(final Object handle, final String name) {
if (handle instanceof ModelElement) {
createCommand(
new StringSetter() {
public void set(String value) {
((ModelElement) handle).setName(value);
}
},
name,
Model.getFacade().getName(handle),
"name = " + name);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or name: "
+ name);
}
public void setBody(Object handle, String body) {
if ((handle instanceof Comment) && (body != null)) {
// All text was stored in name field in UML 1.3
((Comment) handle).setBody(body);
}
}
public void setNamespace(Object handle, Object ns) {
if (handle instanceof ModelElement
&& (ns == null || ns instanceof Namespace)) {
Namespace oldNs = ((ModelElement) handle).getNamespace();
if (((ns == null) && (oldNs == null))
|| ((oldNs != null) && oldNs.equals(ns))) {
return;
}
((ModelElement) handle).setNamespace((Namespace) ns);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or ns: "
+ ns);
}
public void setNavigable(Object handle, boolean flag) {
if (handle instanceof AssociationEnd) {
((AssociationEnd) handle).setNavigable(flag);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setOrdering(Object handle, Object ok) {
if (handle instanceof AssociationEnd && ok instanceof OrderingKind) {
((AssociationEnd) handle).setOrdering((OrderingKind) ok);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or ok: "
+ ok);
}
public void setOwner(Object handle, Object owner) {
if (handle instanceof Feature
&& (owner == null || owner instanceof Classifier)) {
setNamespace(handle, null);
((Feature) handle).setOwner((Classifier) owner);
return;
}
if (handle instanceof TagDefinition
&& (owner == null || owner instanceof Stereotype)) {
setNamespace(handle, null);
((TagDefinition) handle).setOwner((Stereotype) owner);
if (owner != null) {
((Stereotype) owner).getDefinedTag()
.add((TagDefinition) handle);
}
return;
}
throw new IllegalArgumentException("handle: " + handle + " or owner: "
+ owner);
}
public void setStatic(Object handle, boolean isStatic) {
if (handle instanceof Feature) {
((Feature) handle)
.setOwnerScope(isStatic ? ScopeKindEnum.SK_CLASSIFIER
: ScopeKindEnum.SK_INSTANCE);
return;
}
if (handle instanceof AssociationEnd) {
((AssociationEnd) handle)
.setTargetScope(isStatic ? ScopeKindEnum.SK_CLASSIFIER
: ScopeKindEnum.SK_INSTANCE);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setParameter(Object handle, Object parameter) {
if (handle instanceof TemplateParameter
&& parameter instanceof ModelElement) {
((TemplateParameter) handle).setParameter((ModelElement) parameter);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or parameters: " + parameter);
}
public void setParameters(Object handle, Collection parameters) {
if (handle instanceof ObjectFlowState || handle instanceof Classifier
|| handle instanceof Event
|| handle instanceof BehavioralFeature) {
Collection params = Model.getFacade().getParameters(handle);
if (!params.isEmpty()) {
Collection actualParams = new ArrayList(params);
for (Object param : actualParams) {
removeParameter(handle, param);
}
}
for (Object param : parameters) {
addParameter(handle, param);
}
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or parameters: " + parameters);
}
public void setParent(Object handle, Object parent) {
if (handle instanceof Generalization
&& parent instanceof GeneralizableElement) {
((Generalization) handle).setParent((GeneralizableElement) parent);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or parent: "
+ parent);
}
public void setPowertype(Object handle, Object pt) {
if (handle instanceof Generalization
&& (pt == null || pt instanceof Classifier)) {
((Generalization) handle).setPowertype((Classifier) pt);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or pt: "
+ pt);
}
public void setQualifiers(Object handle, List elems) {
if (handle instanceof AssociationEnd) {
((AssociationEnd) handle).getQualifier().clear();
((AssociationEnd) handle).getQualifier().addAll(elems);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setQuery(Object handle, boolean flag) {
if (handle instanceof BehavioralFeature) {
((BehavioralFeature) handle).setQuery(flag);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setResident(Object handle, Object resident) {
if (handle instanceof ElementResidence
&& (resident == null || resident instanceof ModelElement)) {
((ElementResidence) handle).setResident((ModelElement) resident);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or resident: " + resident);
}
public void setResidents(Object handle, Collection residents) {
if (handle instanceof NodeInstance) {
CollectionHelper.update(
((NodeInstance) handle).getResident(), residents);
return;
}
if (handle instanceof ComponentInstance) {
CollectionHelper.update(
((ComponentInstance) handle).getResident(), residents);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setRoot(Object handle, boolean flag) {
if (handle instanceof Reception) {
((Reception) handle).setRoot(flag);
return;
}
if (handle instanceof Operation) {
((Operation) handle).setRoot(flag);
return;
}
if (handle instanceof GeneralizableElement) {
((GeneralizableElement) handle).setRoot(flag);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setSources(Object handle, Collection specifications) {
if (handle instanceof Flow) {
CollectionHelper.update(
((Flow) handle).getSource(), specifications);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setSpecification(Object handle, boolean specification) {
if (handle instanceof ModelElement) {
((ModelElement) handle).setSpecification(specification);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setSpecification(Object operation, String specification) {
if (operation instanceof Operation) {
((Operation) operation).setSpecification(specification);
return;
}
if (operation instanceof Reception) {
((Reception) operation).setSpecification(specification);
return;
}
throw new IllegalArgumentException("operation: " + operation);
}
public void setSpecification(Object method, Object specification) {
if (method instanceof Method && specification instanceof Operation) {
((Method) method).setSpecification((Operation) specification);
return;
}
throw new IllegalArgumentException("method: " + method
+ " or operation: " + specification);
}
public void setSpecifications(Object handle, Collection specifications) {
if (handle instanceof AssociationEnd) {
((AssociationEnd) handle).getSpecification().addAll(specifications);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
@Deprecated
public void setTaggedValue(Object handle, String tag, String value) {
if (handle instanceof ModelElement) {
TaggedValue tv =
(TaggedValue) modelImpl.getFacade().getTaggedValue(handle,
tag);
if (tv == null) {
tv =
(TaggedValue) modelImpl.getExtensionMechanismsFactory().
buildTaggedValue(tag, value);
((ModelElement) handle).getTaggedValue().add(tv);
} else {
modelImpl.getExtensionMechanismsHelper().setDataValues(tv,
new String[] {value});
}
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
@Deprecated
public void setTargetScope(Object handle, Object scopeKind) {
if (scopeKind instanceof ScopeKind) {
if (handle instanceof StructuralFeature) {
((StructuralFeature) handle).
setTargetScope((ScopeKind) scopeKind);
return;
}
if (handle instanceof AssociationEnd) {
((AssociationEnd) handle).setTargetScope((ScopeKind) scopeKind);
return;
}
}
throw new IllegalArgumentException("handle: " + handle
+ " or scopeKind: " + scopeKind);
}
public void setType(Object handle, Object type) {
if (type == null || type instanceof Classifier) {
if (handle instanceof ObjectFlowState) {
((ObjectFlowState) handle).setType((Classifier) type);
return;
}
if (handle instanceof ClassifierInState) {
((ClassifierInState) handle).setType((Classifier) type);
return;
}
if (handle instanceof Parameter) {
((Parameter) handle).setType((Classifier) type);
return;
}
if (handle instanceof AssociationEnd) {
((AssociationEnd) handle).setParticipant((Classifier) type);
return;
}
if (handle instanceof StructuralFeature) {
((StructuralFeature) handle).setType((Classifier) type);
return;
}
}
throw new IllegalArgumentException("handle: " + handle + " or type: "
+ type);
}
public void setVisibility(Object handle, Object visibility) {
if (visibility instanceof VisibilityKind) {
if (handle instanceof ModelElement) {
((ModelElement) handle).
setVisibility((VisibilityKind) visibility);
return;
}
if (handle instanceof ElementResidence) {
((ElementResidence) handle).
setVisibility((VisibilityKind) visibility);
return;
}
if (handle instanceof ElementImport) {
((ElementImport) handle).
setVisibility((VisibilityKind) visibility);
return;
}
}
throw new IllegalArgumentException("handle: " + handle
+ " or visibility: " + visibility);
}
public void removeDeploymentLocation(Object handle, Object node) {
try {
if (handle instanceof Component && node instanceof Node) {
((Component) handle).getDeploymentLocation().remove(node);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle + " or node: "
+ node);
}
public void addStereotype(Object modelElement, Object stereo) {
if (modelElement instanceof ModelElement
&& stereo instanceof Stereotype) {
ModelElement me = (ModelElement) modelElement;
Stereotype stereotype = (Stereotype) stereo;
if (!(me.getStereotype().contains(stereo))) {
me.getStereotype().add(stereotype);
}
return;
}
throw new IllegalArgumentException("handle: " + modelElement
+ " or stereo: " + stereo);
}
public void addAllStereotypes(Object modelElement, Collection stereos) {
if (modelElement instanceof ModelElement) {
ModelElement me = (ModelElement) modelElement;
me.getStereotype().addAll(stereos);
return;
}
throw new IllegalArgumentException("handle: " + modelElement
+ " or stereos: " + stereos);
}
public void removeStereotype(Object modelElement, Object stereo) {
try {
if (modelElement instanceof ModelElement
&& stereo instanceof Stereotype) {
ModelElement me = (ModelElement) modelElement;
Stereotype stereotype = (Stereotype) stereo;
if (me.getStereotype().contains(stereo)) {
me.getStereotype().remove(stereotype);
}
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + modelElement
+ " or stereo: " + stereo);
}
/*
* @see org.argouml.model.CoreHelper#clearStereotypes(java.lang.Object)
*/
public void clearStereotypes(Object modelElement) {
if (modelElement instanceof ModelElement) {
((ModelElement) modelElement).getStereotype().clear();
return;
}
throw new IllegalArgumentException("handle: " + modelElement);
}
public void setEnumerationLiterals(Object enumeration, List literals) {
if (enumeration instanceof Enumeration) {
((Enumeration) enumeration).getLiteral().clear();
((Enumeration) enumeration).getLiteral().addAll(literals);
}
}
public Collection<String> getAllMetatypeNames() {
Set<String> names = new HashSet<String>();
for (Object element : modelImpl.getModelPackage().getMofClass()
.refAllOfClass()) {
String name = ((javax.jmi.model.ModelElement) element).getName();
if (names.add(name)) {
LOG.debug(" Class " + name);
} else {
LOG.error("Found duplicate class " + name + " in metamodel");
}
}
return names;
}
public Collection<String> getAllMetaDatatypeNames() {
Set<String> names = new HashSet<String>();
// Returns nothing
for (Object element : modelImpl.getModelPackage().getDataType()
.refAllOfClass()) {
String name = ((javax.jmi.model.DataType) element).getName();
if (names.add(name)) {
LOG.debug(" DataType " + name);
} else {
LOG.error("Found duplicate datatype " + name + " in metamodel");
}
}
// ScopeKind, VisibilityKind, PseudostateKind, etc
// Doesn't include Boolean though, despite what UML 1.4 spec says
for (Object element : modelImpl.getModelPackage().getEnumerationType()
.refAllOfClass()) {
String name = ((javax.jmi.model.EnumerationType) element).getName();
if (names.add(name)) {
LOG.debug(" EnumerationType " + name);
} else {
LOG.error("Found duplicate EnumerationType " + name
+ " in metamodel");
}
}
// Boolean, String, Integer, Long, Float, Double, etc
for (Object element : modelImpl.getModelPackage().getPrimitiveType()
.refAllOfClass()) {
String name = ((javax.jmi.model.PrimitiveType) element).getName();
if (names.add(name)) {
LOG.debug(" PrimitiveType " + name);
} else {
LOG.error("Found duplicate primitive type " + name
+ " in metamodel");
}
}
return names;
}
/**
* Create a command for a setter of a String value.
*
* @param accesser The accesser.
* @param newValue The new value.
* @param oldValue The old value.
*/
private void createCommand(
final StringSetter accesser,
final String newValue,
final String oldValue,
final String descr) {
if (newValue == oldValue) {
return;
}
if (newValue != null
&& newValue.equals(oldValue)) {
return;
}
ModelCommand command = new ModelCommand() {
public void undo() {
accesser.set(oldValue);
}
public Object execute() {
accesser.set(newValue);
return null;
}
public boolean isUndoable() {
return true;
}
public boolean isRedoable() {
return true;
}
public String toString() {
return descr;
}
};
Model.execute(command);
}
}