/* $Id: CollaborationsHelperMDRImpl.java 18402 2010-05-19 16:30:45Z bobtarling $
*****************************************************************************
* Copyright (c) 2009 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:
* bobtarling
*****************************************************************************
*
* Some portions of this file was previously release using the BSD License:
*/
// Copyright (c) 1996-2009 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.List;
import java.util.Set;
import javax.jmi.reflect.InvalidObjectException;
import org.apache.log4j.Logger;
import org.argouml.model.CollaborationsHelper;
import org.argouml.model.CoreHelper;
import org.argouml.model.InvalidElementException;
import org.argouml.model.Model;
import org.argouml.model.ModelManagementHelper;
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.Interaction;
import org.omg.uml.behavioralelements.collaborations.Message;
import org.omg.uml.behavioralelements.commonbehavior.Action;
import org.omg.uml.behavioralelements.commonbehavior.Instance;
import org.omg.uml.behavioralelements.commonbehavior.Stimulus;
import org.omg.uml.foundation.core.AssociationEnd;
import org.omg.uml.foundation.core.Classifier;
import org.omg.uml.foundation.core.Feature;
import org.omg.uml.foundation.core.ModelElement;
import org.omg.uml.foundation.core.Namespace;
import org.omg.uml.foundation.core.Operation;
import org.omg.uml.foundation.core.UmlAssociation;
import org.omg.uml.modelmanagement.UmlPackage;
/**
* Helper class for UML BehavioralElements::Collaborations Package.
* <p>
* @since ARGO0.19.5
* @author Ludovic Maître
* @author Tom Morris
* Derived from NSUML implementation by:
* @author Thierry Lach
*/
class CollaborationsHelperMDRImpl implements CollaborationsHelper {
/**
* The model implementation.
*/
private MDRModelImplementation modelImpl;
private static final Logger LOG = Logger.getLogger(CollaborationsHelperMDRImpl.class);
/**
* Constructor.
*
* @param implementation
* To get other helpers and factories.
*/
CollaborationsHelperMDRImpl(MDRModelImplementation implementation) {
modelImpl = implementation;
}
public Collection<ClassifierRole> getAllClassifierRoles(Object ns) {
if (!(ns instanceof Namespace)) {
throw new IllegalArgumentException();
}
try {
List<ClassifierRole> list = new ArrayList<ClassifierRole>();
for (Object o : ((Namespace) ns).getOwnedElement()) {
if (o instanceof Namespace) {
list.addAll(getAllClassifierRoles(o));
}
if (o instanceof ClassifierRole) {
list.add((ClassifierRole) o);
}
}
return list;
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
public Collection getAllPossibleAssociationRoles(Object roleArg) {
if (!(roleArg instanceof ClassifierRole)) {
throw new IllegalArgumentException();
}
ClassifierRole role = (ClassifierRole) roleArg;
try {
if (role.getBase().isEmpty()) {
return Collections.emptyList();
}
Set associations = new HashSet();
for (Classifier base : role.getBase()) {
associations.addAll(
modelImpl.getCoreHelper().getAssociations(base));
}
return associations;
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
public Collection<Classifier> getClassifierRoles(Object role) {
if (role == null) {
return Collections.emptySet();
}
if (!(role instanceof ClassifierRole)) {
throw new IllegalArgumentException();
}
List<Classifier> roles = new ArrayList<Classifier>();
try {
Collection<AssociationEnd> associationEnds =
Model.getFacade().getAssociationEnds(role);
if (!associationEnds.isEmpty()) {
for (AssociationEnd end : associationEnds) {
if (end instanceof AssociationEndRole) {
UmlAssociation assoc = end.getAssociation();
for (AssociationEnd end2 : assoc.getConnection()) {
Classifier classifier = end2.getParticipant();
if (classifier != role
&& classifier instanceof ClassifierRole) {
roles.add(classifier);
}
}
}
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return roles;
}
public Object getAssociationRole(Object afrom, Object ato) {
if (afrom == null || ato == null) {
throw new IllegalArgumentException();
}
ClassifierRole from = (ClassifierRole) afrom;
ClassifierRole to = (ClassifierRole) ato;
try {
Collection<AssociationEnd> ends =
Model.getFacade().getAssociationEnds(from);
for (AssociationEnd end : ends) {
if (end instanceof AssociationEndRole) {
UmlAssociation assoc = end.getAssociation();
for (AssociationEnd end2 : assoc.getConnection()) {
Classifier classifier = end2.getParticipant();
if (classifier == to) {
return assoc;
}
}
}
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return null;
}
public Collection<Message> getAllPossibleActivators(Object ames) {
Message mes = (Message) ames;
if (mes == null || mes.getInteraction() == null) {
return Collections.unmodifiableCollection(Collections.EMPTY_LIST);
}
try {
Interaction inter = mes.getInteraction();
Collection<Message> predecessors = mes.getPredecessor();
Collection<Message> allMessages = inter.getMessage();
List<Message> list = new ArrayList<Message>();
for (Message m : allMessages) {
if (!predecessors.contains(m) && mes != m
&& !hasAsActivator(m, mes)
&& !m.getPredecessor().contains(mes)) {
list.add(m);
}
}
return list;
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
public boolean hasAsActivator(Object message, Object activator) {
if (!(message instanceof Message)) {
throw new IllegalArgumentException();
}
if (!(activator instanceof Message)) {
throw new IllegalArgumentException();
}
try {
Message messActivator = ((Message) message).getActivator();
if (messActivator == null) {
return false;
}
if (messActivator == activator
|| messActivator.getPredecessor().contains(activator)) {
return true;
}
return hasAsActivator(messActivator, activator);
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
public void setActivator(Object ames, Object anactivator) {
if (ames == null) {
throw new IllegalArgumentException("message is null");
}
if (!(ames instanceof Message)) {
throw new IllegalArgumentException("message");
}
if (anactivator != null && !(anactivator instanceof Message)) {
throw new IllegalArgumentException(
"An activator must be a message");
}
Message mes = (Message) ames;
Message activator = (Message) anactivator;
if (mes == activator) {
throw new IllegalArgumentException("In setActivator: message may "
+ "not be equal to activator");
}
if (activator != null) {
if (mes.getInteraction() != activator.getInteraction()) {
throw new IllegalArgumentException(
"In setActivator: interaction "
+ "of message should equal "
+ "interaction of activator");
}
// we must find out if the activator itself does not have
// message as it's activator
if (hasAsActivator(activator, mes)) {
throw new IllegalArgumentException(
"In setActivator: message may "
+ "not be the activator for "
+ "the original activator");
}
// An activator can't also be a predecessor of a message
if (mes.getPredecessor().contains(activator)) {
mes.getPredecessor().remove(activator);
}
}
List<Message> listToChange = new ArrayList<Message>();
Collection<Message> predecessors = mes.getPredecessor();
listToChange.addAll(predecessors);
listToChange.add(mes);
Interaction inter = mes.getInteraction();
for (Message mes2 : inter.getMessage()) {
if (mes2.getPredecessor().contains(mes)) {
listToChange.add(mes2);
}
}
// This causes problems. It can make multiple return messages
// refer to the same activator even if not returning to the same
// classifier role as the activator emenates from.
// I'm not sure that changing the activator of one message
// should amend any other messages but this is certainly changing
// too many - Bob.
for (Message mes2 : listToChange) {
mes2.setActivator(activator);
}
}
public Collection<Message> getAllPossiblePredecessors(Object amessage) {
Message message = (Message) amessage;
if (message == null) {
throw new IllegalArgumentException(
"In getAllPossiblePredecessors: "
+ "argument message is null");
}
try {
Interaction inter = message.getInteraction();
List<Message> list = new ArrayList<Message>();
for (Message mes : inter.getMessage()) {
if (mes.getActivator() == message.getActivator()
&& message != mes
&& !mes.getPredecessor().contains(message)
&& !message.getPredecessor().contains(message)) {
list.add(mes);
}
}
return list;
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
public void addBase(Object arole, Object abase) {
ClassifierRole role = (ClassifierRole) arole;
Classifier base = (Classifier) abase;
if (role == null || base == null) {
throw new IllegalArgumentException("In addBase: either the role "
+ "or the base is null");
}
role.getBase().add(base);
if (modelImpl.getFacade().getBases(role).size() == 1) {
role.getAvailableContents().clear();
role.getAvailableContents().addAll(base.getOwnedElement());
role.getAvailableFeature().clear();
role.getAvailableFeature().addAll(base.getFeature());
} else {
for (ModelElement elem : base.getOwnedElement()) {
if (!role.getAvailableContents().contains(elem)) {
role.getAvailableContents().add(elem);
}
}
for (Feature feature : base.getFeature()) {
if (!role.getAvailableFeature().contains(feature)) {
role.getAvailableFeature().add(feature);
}
}
}
}
public void setBases(Object role, Collection bases) {
if (role == null || bases == null) {
throw new IllegalArgumentException("In setBases: either the role "
+ "or the collection bases is " + "null");
}
CollectionHelper.update(((ClassifierRole) role).getBase(), bases);
}
public Collection<Feature> allAvailableFeatures(Object arole) {
LOG.info("allAvailableFeatures start");
if (arole instanceof ClassifierRole) {
try {
List<Feature> returnList = new ArrayList<Feature>();
ClassifierRole role = (ClassifierRole) arole;
for (ModelElement genElem
: CoreHelperMDRImpl.getAllParents(role)) {
if (genElem instanceof ClassifierRole) {
returnList.addAll(allAvailableFeatures(genElem));
}
}
for (Classifier classifier : role.getBase()) {
returnList.addAll(classifier.getFeature());
}
LOG.info("allAvailableFeatures " + returnList.size());
return returnList;
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
throw new IllegalArgumentException("Cannot get available features on "
+ arole);
}
public Collection allAvailableContents(Object arole) {
LOG.info("allAvailableContents start");
try {
if (arole instanceof ClassifierRole) {
List returnList = new ArrayList();
ClassifierRole role = (ClassifierRole) arole;
for (ModelElement genElem
: CoreHelperMDRImpl.getAllParents(role)) {
if (genElem instanceof ClassifierRole) {
returnList.addAll(allAvailableContents(genElem));
}
}
for (Classifier baseClassifier : role.getBase()) {
returnList.addAll(baseClassifier.getOwnedElement());
}
LOG.info("allAvailableContents " + returnList.size());
return returnList;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("Cannot get available contents on "
+ arole);
}
public Collection getAllPossibleBases(Object role) {
try {
if (role instanceof ClassifierRole) {
return getAllPossibleBases((ClassifierRole) role);
} else if (role instanceof AssociationRole) {
return getAllPossibleBases((AssociationRole) role);
} else {
throw new IllegalArgumentException("Illegal type " + role);
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
/**
* Returns all possible bases for some AssociationRole taking into account
* the wellformednessrules as defined in section 2.10.3 of the UML 1.3 spec.
* <p>
* Beware: this function does not return the actual base!
* Which is by design; there are easier ways to retrieve the actual base.
*
* @param aRole
* the given associationrole
* @return Collection all possible bases
*/
private Collection getAllPossibleBases(AssociationRole aRole) {
Set<UmlAssociation> ret = new HashSet<UmlAssociation>();
if (aRole == null || aRole.getNamespace() == null) {
return ret;
}
// find the bases of the connected classifierroles so that we can see
// what associations are between them. If there are bases then the
// associations between those bases form the possible bases. Otherwise
// the bases are formed by all associations in the namespace of the
// collaboration
Set<Classifier> bases = new HashSet<Classifier>();
for (AssociationEnd end : aRole.getConnection()) {
assert end instanceof AssociationEndRole;
ClassifierRole type = (ClassifierRole) end.getParticipant();
if (type != null) {
bases.addAll(type.getBase());
}
}
if (bases.isEmpty()) {
ModelManagementHelper mmh = modelImpl.getModelManagementHelper();
Namespace ns =
((Collaboration) aRole.getNamespace()).getNamespace();
ret.addAll(
mmh.getAllModelElementsOfKind(ns, UmlAssociation.class));
ret.removeAll(mmh.getAllModelElementsOfKind(ns,
AssociationRole.class));
} else {
CoreHelper ch = modelImpl.getCoreHelper();
/* This double 'for' loop may be optimised as follows:
* - Use arrays in stead of a Set for bases
* - Have the second loop start from the element after base1
* ... but I chose not to do this, since the gain is small,
* and this is only used for a lazily filled combo.
* BTW: This is also used by Notation.*/
for (Classifier base1 : bases) {
for (Classifier base2 : bases) {
// include associations to self - see issue 5602
ret.addAll(ch.getAssociations(base1, base2));
}
}
}
// An Association can only have a single unnamed ClassifierRole, so
Collection<UmlAssociation> listToRemove = new ArrayList<UmlAssociation>();
for (UmlAssociation association : ret) {
Collection<AssociationRole> associationRoles =
((org.omg.uml.UmlPackage) (association)
.refOutermostPackage()).getCollaborations()
.getABaseAssociationRole().getAssociationRole(association);
if (associationRoles.isEmpty()) {
continue;
}
// if we are unnamed eliminate all classifiers which are already
// the base of some role
if (aRole.getName() == null || aRole.getName().equals("")) {
listToRemove.add(association);
} else {
// eliminate Classifiers which already have an unnamed role
for (AssociationRole ar : associationRoles) {
if (ar.getName() == null || ar.getName().equals("")) {
listToRemove.add(association);
}
}
}
}
ret.removeAll(listToRemove);
return ret;
}
/**
* Returns all possible bases for some classifierrole taking into account
* the wellformednessrules as defined in section 2.10.3 of the UML 1.4 spec.
* <p>
*
* @param role
* the given classifierrole
* @return Collection all possible bases
*/
private Collection getAllPossibleBases(ClassifierRole role) {
if (role == null || modelImpl.getFacade().getNamespace(role) == null) {
return Collections.EMPTY_SET;
}
Collaboration collaboration = (Collaboration) role.getNamespace();
Namespace ns = collaboration.getNamespace();
ModelManagementHelper mmh = modelImpl.getModelManagementHelper();
Collection<Classifier> returnList = mmh.getAllModelElementsOfKind(ns,
Classifier.class);
// WFR 2.10.3.3 #4
returnList.removeAll(mmh.getAllModelElementsOfKind(ns,
ClassifierRole.class));
// A Classifier can only have a single unnamed ClassifierRole, so
// TODO: This probably belongs in a critic instead of here
Collection<Classifier> listToRemove = new ArrayList<Classifier>();
for (Classifier classifier : returnList) {
Collection<ClassifierRole> classifierRoles =
((org.omg.uml.UmlPackage) (classifier)
.refOutermostPackage()).getCollaborations()
.getAClassifierRoleBase().getClassifierRole(classifier);
if (classifierRoles.isEmpty()) {
continue;
}
// if we are unnamed eliminate all classifiers which are already
// the base of some role
if (role.getName() == null || role.getName().equals("")) {
listToRemove.add(classifier);
} else {
// eliminate Classifiers which already have an unnamed role
for (ClassifierRole cr : classifierRoles) {
if (cr.getName() == null || cr.getName().equals("")) {
listToRemove.add(classifier);
}
}
}
}
returnList.removeAll(listToRemove);
/* We need to verify that ns is a Package,
* if not - find its parent package!
* Otherwise this causes an exception when creating
* a sequence diagram for a ClassifierRole.*/
if (!(ns instanceof UmlPackage)) {
while (ns != null) {
ns = ns.getNamespace();
if (ns instanceof UmlPackage) {
break;
}
}
}
// now get all classifiers imported from other packages
// TODO: This should probably happen automatically in
// getAllModelElementsOfKind() - tfm
if (modelImpl.getFacade().isAPackage(ns)) {
returnList.addAll(getAllImportedClassifiers(ns));
}
return returnList;
}
/**
* Return a collection of classifiers that are imported from other packages
* into the given namespace.
*
* @param obj the given namespace
* @return a collection of classifiers
*/
private Collection<Classifier> getAllImportedClassifiers(Object obj) {
Collection c = modelImpl.getModelManagementHelper()
.getAllImportedElements(obj);
return filterClassifiers(c);
}
private Collection<Classifier> filterClassifiers(Collection in) {
Collection<Classifier> out = new ArrayList<Classifier>();
for (Object o : in) {
if (o instanceof Classifier && !(o instanceof ClassifierRole))
out.add((Classifier) o);
}
return out;
}
public void setBase(Object arole, Object abase) {
if (arole == null) {
throw new IllegalArgumentException("role is null");
}
if (arole instanceof AssociationRole) {
AssociationRole role = (AssociationRole) arole;
UmlAssociation base = (UmlAssociation) abase;
// TODO: Must we calculate the whole list?
if (base != null && !getAllPossibleBases(role).contains(base)) {
throw new IllegalArgumentException("base is not allowed for "
+ "this role");
}
role.setBase(base);
ClassifierRole sender = (ClassifierRole) modelImpl.getCoreHelper()
.getSource(role);
ClassifierRole receiver = (ClassifierRole) modelImpl
.getCoreHelper().getDestination(role);
Collection<Classifier> senderBases = sender.getBase();
Collection<Classifier> receiverBases = receiver.getBase();
AssociationEndRole senderRole = (AssociationEndRole) modelImpl.
getCoreHelper().getAssociationEnd(sender, role);
AssociationEndRole receiverRole = (AssociationEndRole) modelImpl.
getCoreHelper().getAssociationEnd(receiver, role);
if (base != null) {
for (AssociationEnd end : base.getConnection()) {
if (senderBases.contains(end.getParticipant())) {
senderRole.setBase(end);
} else if (receiverBases.contains(end.getParticipant())) {
receiverRole.setBase(end);
}
}
}
return;
} else if (arole instanceof AssociationEndRole) {
AssociationEndRole role = (AssociationEndRole) arole;
AssociationEnd base = (AssociationEnd) abase;
role.setBase(base);
return;
}
throw new IllegalArgumentException("role");
}
public boolean isAddingCollaborationAllowed(Object context) {
return (
context instanceof Classifier
|| context instanceof Operation
//|| context instanceof Collaboration
//|| context instanceof Model
);
}
public void removeBase(Object handle, Object c) {
try {
if (handle instanceof ClassifierRole && c instanceof Classifier) {
((ClassifierRole) handle).getBase().remove(c);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException(
"There must be a ClassifierRole and a Classifier");
}
public void removeConstrainingElement(Object handle, Object constraint) {
try {
if (handle instanceof Collaboration
&& constraint instanceof ModelElement) {
Collaboration collab = (Collaboration) handle;
collab.getConstrainingElement().remove(constraint);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle
+ " or constraint: " + constraint);
}
public void removeMessage(Object handle, Object message) {
try {
if (handle instanceof Interaction && message instanceof Message) {
((Interaction) handle).getMessage().remove(message);
return;
}
if (handle instanceof AssociationRole
&& message instanceof Message) {
((AssociationRole) handle).getMessage().remove(message);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle
+ " or message: " + message);
}
public void removeSuccessor(Object handle, Object mess) {
try {
if (handle instanceof Message && mess instanceof Message) {
((org.omg.uml.UmlPackage) ((Message) handle)
.refOutermostPackage()).getCollaborations()
.getAPredecessorSuccessor().remove((Message) handle,
(Message) mess);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("predecessor: " + handle
+ " or successor: " + mess);
}
public void removePredecessor(Object handle, Object message) {
try {
if (handle instanceof Message && message instanceof Message) {
((Message) handle).getPredecessor().remove(message);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + handle
+ " or message: " + message);
}
public void addConstrainingElement(Object handle, Object constraint) {
if (handle instanceof Collaboration
&& constraint instanceof ModelElement) {
((Collaboration) handle).getConstrainingElement().add(
(ModelElement) constraint);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or constraint: " + constraint);
}
public void addInstance(Object classifierRole, Object instance) {
if (classifierRole instanceof ClassifierRole
&& instance instanceof Instance) {
((ClassifierRole) classifierRole).getConformingInstance().add(
(Instance) instance);
}
throw new IllegalArgumentException("classifierRole: " + classifierRole
+ " or instance: " + instance);
}
public void addMessage(Object handle, Object elem) {
if (handle instanceof Interaction && elem instanceof Message) {
final Message message = (Message) elem;
final Interaction interaction = (Interaction) handle;
final Interaction oldInteraction = message.getInteraction();
if (oldInteraction != null) {
oldInteraction.getMessage().remove(message);
}
interaction.getMessage().add(message);
return;
}
if (handle instanceof AssociationRole && elem instanceof Message) {
((AssociationRole) handle).getMessage().add((Message) elem);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or elem: "
+ elem);
}
public void addSuccessor(Object handle, Object mess) {
if (handle instanceof Message && mess instanceof Message) {
((Message) mess).getPredecessor().add((Message) handle);
return;
}
throw new IllegalArgumentException("predecessor: " + handle
+ " or successor: " + mess);
}
public void addPredecessor(Object handle, Object predecessor) {
if (handle != null && handle instanceof Message && predecessor != null
&& predecessor instanceof Message) {
((Message) handle).getPredecessor().add((Message) predecessor);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or predecessor: " + predecessor);
}
public void setAction(Object handle, Object action) {
if (handle instanceof Message
&& (action == null || action instanceof Action)) {
((Message) handle).setAction((Action) action);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or action: "
+ action);
}
public void setContext(Object handle, Object col) {
if (handle instanceof Interaction
&& (col instanceof Collaboration || col == null)) {
((Interaction) handle).setContext((Collaboration) col);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or col: "
+ col);
}
public void setSuccessors(Object handle, Collection messages) {
if (handle instanceof Message) {
Collection currentMessages =
Model.getFacade().getSuccessors(handle);
if (!currentMessages.isEmpty()) {
Collection successors = new ArrayList(currentMessages);
for (Object msg : successors) {
removeSuccessor(handle, msg);
}
}
for (Object msg : messages) {
addSuccessor(handle, msg);
}
return;
}
throw new IllegalArgumentException("predecessor: " + handle
+ " or messages: " + messages);
}
public void setPredecessors(Object handle, Collection predecessors) {
if (handle instanceof Message) {
CollectionHelper.update(
((Message) handle).getPredecessor(), predecessors);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or predecessors: " + predecessors);
}
public void setRepresentedClassifier(Object handle, Object classifier) {
if (handle instanceof Collaboration
&& ((classifier == null) || classifier instanceof Classifier)) {
((Collaboration) handle).
setRepresentedClassifier((Classifier) classifier);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or classifier: " + classifier);
}
public void setRepresentedOperation(Object handle, Object operation) {
if (handle instanceof Collaboration
&& ((operation == null) || operation instanceof Operation)) {
((Collaboration) handle).
setRepresentedOperation((Operation) operation);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or operation: " + operation);
}
public void setSender(Object handle, Object sender) {
if (handle instanceof Message
&& (sender instanceof ClassifierRole || sender == null)) {
((Message) handle).setSender((ClassifierRole) sender);
return;
}
if (handle instanceof Stimulus && sender instanceof Instance) {
((Stimulus) handle).setSender((Instance) sender);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or sender: "
+ sender);
}
public void removeInteraction(Object collab, Object interaction) {
try {
if (collab instanceof Collaboration
&& interaction instanceof Interaction) {
((Collaboration) collab).getInteraction().remove(interaction);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("collab: " + collab
+ " or interaction: " + interaction);
}
}