/* $Id: CommonBehaviorHelperMDRImpl.java 18759 2010-09-17 17:42:28Z tfmorris $
*****************************************************************************
* 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:
* tfmorris
* mvw
*****************************************************************************
*
* Some portions of this file were previously released using the BSD License:
*/
// Copyright (c) 1996-2007 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.Iterator;
import java.util.List;
import javax.jmi.reflect.InvalidObjectException;
import org.argouml.model.CommonBehaviorHelper;
import org.argouml.model.InvalidElementException;
import org.argouml.model.Model;
import org.omg.uml.behavioralelements.collaborations.ClassifierRole;
import org.omg.uml.behavioralelements.collaborations.Message;
import org.omg.uml.behavioralelements.commonbehavior.Action;
import org.omg.uml.behavioralelements.commonbehavior.ActionSequence;
import org.omg.uml.behavioralelements.commonbehavior.Argument;
import org.omg.uml.behavioralelements.commonbehavior.AttributeLink;
import org.omg.uml.behavioralelements.commonbehavior.CallAction;
import org.omg.uml.behavioralelements.commonbehavior.ComponentInstance;
import org.omg.uml.behavioralelements.commonbehavior.CreateAction;
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.SendAction;
import org.omg.uml.behavioralelements.commonbehavior.Signal;
import org.omg.uml.behavioralelements.commonbehavior.Stimulus;
import org.omg.uml.behavioralelements.statemachines.CallEvent;
import org.omg.uml.behavioralelements.statemachines.Guard;
import org.omg.uml.behavioralelements.statemachines.SignalEvent;
import org.omg.uml.behavioralelements.statemachines.StateVertex;
import org.omg.uml.behavioralelements.statemachines.Transition;
import org.omg.uml.foundation.core.BehavioralFeature;
import org.omg.uml.foundation.core.Classifier;
import org.omg.uml.foundation.core.Operation;
import org.omg.uml.foundation.core.TaggedValue;
import org.omg.uml.foundation.datatypes.ActionExpression;
import org.omg.uml.foundation.datatypes.Expression;
import org.omg.uml.foundation.datatypes.IterationExpression;
import org.omg.uml.foundation.datatypes.ObjectSetExpression;
/**
* The CommonBehaviorHelper for the MDR ModelImplementation.
* <p>
* @since ARGO0.19.5
* @author Ludovic Maître
* @author Tom Morris
*
*/
class CommonBehaviorHelperMDRImpl implements CommonBehaviorHelper {
private MDRModelImplementation modelImpl;
/**
* Default constructor
*
* @param implementation
* The model implementation
*/
public CommonBehaviorHelperMDRImpl(MDRModelImplementation implementation) {
this.modelImpl = implementation;
}
public Object getSource(Object link) {
try {
if (link instanceof Link) {
return modelImpl.getCoreHelper().getSource(link);
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("Argument is not a link");
}
public Object getDestination(Object link) {
try {
if (link instanceof Link) {
return modelImpl.getCoreHelper().getDestination(link);
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("Argument is not a link");
}
public void removeActualArgument(Object handle, Object argument) {
try {
if (handle instanceof Action && argument instanceof Argument) {
((Action) handle).getActualArgument().remove(argument);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("Unrecognized object " + handle
+ " or " + argument);
}
public void setActualArguments(Object action, List arguments) {
try {
if (action instanceof Action) {
((Action) action).getActualArgument().clear();
((Action) action).getActualArgument().addAll(arguments);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("Unrecognized object " + action
+ " or " + arguments);
}
public void removeClassifier(Object handle, Object classifier) {
try {
if (handle instanceof Instance
&& classifier instanceof Classifier) {
((Instance) handle).getClassifier().remove(classifier);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("Unrecognized object " + handle
+ " or " + classifier);
}
public void removeContext(Object handle, Object context) {
try {
if (handle instanceof Signal
&& context instanceof BehavioralFeature) {
((org.omg.uml.UmlPackage) ((Signal) handle)
.refOutermostPackage()).getCommonBehavior()
.getAContextRaisedSignal().remove(
(BehavioralFeature) context, (Signal) handle);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("Unrecognized object " + handle
+ " or " + context);
}
public void removeReception(Object handle, Object reception) {
try {
if (handle instanceof Signal && reception instanceof Reception) {
// TODO: Doing this violates the minimal cardinality of 1
// if we allow it we at least need a critic to warn about it
((Reception) reception).setSignal(null);
return;
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("Unrecognized object " + handle
+ " or " + reception);
}
public void addActualArgument(Object handle, Object argument) {
if (handle instanceof Action && argument instanceof Argument) {
((Action) handle).getActualArgument().add((Argument) argument);
return;
}
throw new IllegalArgumentException("Unrecognized object " + handle
+ " or " + argument);
}
public void addActualArgument(Object handle, int position,
Object argument) {
if (handle instanceof Action && argument instanceof Argument) {
try {
((Action) handle).getActualArgument().add(position,
(Argument) argument);
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
} else {
throw new IllegalArgumentException();
}
}
public void addClassifier(Object handle, Object classifier) {
if (handle instanceof Instance && classifier instanceof Classifier) {
((Instance) handle).getClassifier().add((Classifier) classifier);
return;
}
throw new IllegalArgumentException("Unrecognized object " + handle
+ " or " + classifier);
}
/**
* Add a context to a Signal.
*
* @param handle The signal
* @param behavorialFeature The behavorialFeature
*/
private void addContext(Object handle, Object behavorialFeature) {
if (handle instanceof Signal
&& behavorialFeature instanceof BehavioralFeature) {
((org.omg.uml.UmlPackage) ((Signal) handle).refOutermostPackage())
.getCommonBehavior().getAContextRaisedSignal().add(
(BehavioralFeature) behavorialFeature,
(Signal) handle);
return;
}
}
/**
* Add a Reception to a Signal.
*
* @param handle The signal
* @param rec The Reception
*/
private void addReception(Object handle, Object rec) {
if (handle instanceof Signal
&& rec instanceof Reception) {
((Reception) rec).setSignal((Signal) handle);
return;
}
}
public void addStimulus(Object handle, Object stimulus) {
if (handle != null && stimulus != null
&& stimulus instanceof Stimulus) {
if (handle instanceof Action) {
((Stimulus) stimulus).setDispatchAction((Action) handle);
return;
}
if (handle instanceof Link) {
((Stimulus) stimulus).setCommunicationLink((Link) handle);
return;
}
}
throw new IllegalArgumentException("handle: " + handle
+ " or stimulus: " + stimulus);
}
public void setAsynchronous(Object handle, boolean value) {
if (handle instanceof Action) {
((Action) handle).setAsynchronous(value);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setOperation(Object handle, Object operation) {
if (handle instanceof CallAction
&& (operation == null || operation instanceof Operation)) {
((CallAction) handle).setOperation((Operation) operation);
return;
}
if (handle instanceof CallEvent
&& (operation == null || operation instanceof Operation)) {
((CallEvent) handle).setOperation((Operation) operation);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or operation: " + operation);
}
public void setClassifiers(Object handle, Collection classifiers) {
if (handle instanceof Instance) {
((Instance) handle).getClassifier().retainAll(classifiers);
((Instance) handle).getClassifier().addAll(classifiers);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setCommunicationLink(Object handle, Object c) {
if (handle instanceof Stimulus && c instanceof Link) {
((Stimulus) handle).setCommunicationLink((Link) c);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or c: " + c);
}
public void setComponentInstance(Object handle, Object c) {
if (handle instanceof Instance
&& (c == null || c instanceof ComponentInstance)) {
((Instance) handle).setComponentInstance((ComponentInstance) c);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or c: " + c);
}
public void setContexts(Object handle, Collection c) {
if (handle instanceof Signal) {
Collection actualContexts = Model.getFacade().getContexts(handle);
if (!actualContexts.isEmpty()) {
Collection contexts = new ArrayList(actualContexts);
for (Object context : contexts) {
removeContext(handle, context);
}
}
for (Object context : c) {
addContext(handle, context);
}
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setDispatchAction(Object handle, Object value) {
if (handle instanceof Stimulus
&& (value == null || value instanceof Action)) {
((Stimulus) handle).setDispatchAction((Action) value);
return;
}
throw new IllegalArgumentException("handle: " + handle + " or value: "
+ value);
}
public void setInstance(Object handle, Object inst) {
if (inst == null || inst instanceof Instance) {
if (handle instanceof LinkEnd) {
((LinkEnd) handle).setInstance((Instance) inst);
return;
}
if (handle instanceof AttributeLink) {
((AttributeLink) handle).setInstance((Instance) inst);
return;
}
}
throw new IllegalArgumentException("handle: " + handle + " or inst: "
+ inst);
}
/*
* @see org.argouml.model.CommonBehaviorHelper#setNodeInstance(java.lang.Object,
* java.lang.Object)
*/
public void setNodeInstance(Object handle, Object nodeInstance) {
if (handle instanceof ComponentInstance
&& nodeInstance instanceof NodeInstance) {
((ComponentInstance) handle).
setNodeInstance((NodeInstance) nodeInstance);
return;
} else if (handle instanceof ComponentInstance
&& nodeInstance == null) {
// TODO: Check if this is ok (this is literally adapted from NSUML)
((ComponentInstance) handle).setNodeInstance(null);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or nodeInstance: " + nodeInstance);
}
/*
* @see org.argouml.model.CommonBehaviorHelper#setReceiver(java.lang.Object,
* java.lang.Object)
*/
public void setReceiver(Object handle, Object receiver) {
if (handle instanceof Message
&& (receiver instanceof ClassifierRole || receiver == null)) {
((Message) handle).setReceiver((ClassifierRole) receiver);
return;
}
if (handle instanceof Stimulus && receiver instanceof Instance) {
((Stimulus) handle).setReceiver((Instance) receiver);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or receiver: " + receiver);
}
public void setReception(Object handle, Collection c) {
if (handle instanceof Signal) {
Collection actualReceptions =
Model.getFacade().getReceptions(handle);
if (!actualReceptions.isEmpty()) {
Collection receptions = new ArrayList(actualReceptions);
for (Object reception : receptions) {
removeReception(handle, reception);
}
}
for (Object reception : c) {
addReception(handle, reception);
}
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setRecurrence(Object handle, Object expr) {
Action action = (Action) handle;
IterationExpression oldExpr = action.getRecurrence();
IterationExpression newExpr = (IterationExpression) expr;
if (!equal(oldExpr, newExpr)) {
action.setRecurrence(newExpr);
if (oldExpr != null) {
Model.getUmlFactory().delete(oldExpr);
}
}
}
private boolean equal(Expression expr1, Expression expr2) {
if (expr1 == null) {
if (expr2 == null) {
return true;
} else {
return false;
}
} else {
return expr1.equals(expr2);
}
}
public void setScript(Object handle, Object expr) {
if (handle instanceof Action
&& (expr == null || expr instanceof ActionExpression)) {
Action a = (Action) handle;
ActionExpression oldae =a.getScript();
ActionExpression newae = (ActionExpression) expr;
if (equal(oldae,newae)) {
return;
}
a.setScript(newae);
if (oldae != null) {
/* Throw away the old actionExpression (see issue 6145): */
modelImpl.getUmlFactory().delete(oldae);
}
return;
}
throw new IllegalArgumentException("handle: " + handle + " or expr: "
+ expr);
}
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 setSignal(Object handle, Object signal) {
if (signal == null || signal instanceof Signal) {
if (handle instanceof SendAction) {
((SendAction) handle).setSignal((Signal) signal);
return;
}
if (handle instanceof Reception) {
((Reception) handle).setSignal((Signal) signal);
return;
}
if (handle instanceof SignalEvent) {
((SignalEvent) handle).setSignal((Signal) signal);
return;
}
}
throw new IllegalArgumentException("handle: " + handle + " or signal: "
+ signal);
}
public void setSpecification(Object handle, String specification) {
if (handle instanceof Reception) {
((Reception) handle).setSpecification(specification);
return;
}
throw new IllegalArgumentException("handle: " + handle);
}
public void setTarget(Object handle, Object element) {
if (handle instanceof Action
&& element instanceof ObjectSetExpression) {
Action action = (Action) handle;
ObjectSetExpression oldExpr = action.getTarget();
ObjectSetExpression newExpr = (ObjectSetExpression) element;
if (!equal(oldExpr, newExpr)) {
action.setTarget(newExpr);
if (oldExpr != null) {
Model.getUmlFactory().delete(oldExpr);
}
}
return;
}
if (handle instanceof Transition &&
(element == null || element instanceof StateVertex)) {
((Transition) handle).setTarget((StateVertex) element);
return;
}
throw new IllegalArgumentException("handle: " + handle
+ " or element: " + element);
}
public void setTransition(Object handle, Object trans) {
if (trans instanceof Transition) {
if (handle instanceof Guard) {
((Guard) handle).setTransition((Transition) trans);
return;
}
if (handle instanceof Action) {
((Transition) trans).setEffect((Action) handle);
return;
}
}
throw new IllegalArgumentException("handle: " + handle + " or trans: "
+ trans);
}
public void setValue(Object handle, Object value) {
if (handle instanceof Argument) {
((Argument) handle).setValue((Expression) value);
Argument argument = (Argument) handle;
Expression oldExpr = argument.getValue();
Expression newExpr = (Expression) value;
if (!equal(oldExpr, newExpr)) {
argument.setValue(newExpr);
if (oldExpr != null) {
Model.getUmlFactory().delete(oldExpr);
}
}
return;
}
if (handle instanceof AttributeLink) {
((AttributeLink) handle).setValue((Instance) value);
return;
}
if (handle instanceof TaggedValue && value instanceof String) {
modelImpl.getExtensionMechanismsHelper().setDataValues(handle,
new String[] {(String) value});
return;
}
throw new IllegalArgumentException("handle: " + handle + ", value:"
+ value);
}
public Classifier getInstantiation(Object createaction) {
try {
if (createaction instanceof CreateAction) {
return ((CreateAction) createaction).getInstantiation();
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
throw new IllegalArgumentException("handle: " + createaction);
}
public void setInstantiation(Object createaction, Object instantiation) {
if (createaction instanceof CreateAction) {
if (instantiation instanceof Classifier) {
((CreateAction) createaction).setInstantiation(
(Classifier) instantiation);
return;
}
if (instantiation == null)
((CreateAction) createaction).setInstantiation(null);
return;
}
throw new IllegalArgumentException("handle: " + createaction
+ ", value:" + instantiation);
}
public Object getActionOwner(Object action) {
if (!(action instanceof Action)) {
throw new IllegalArgumentException();
}
try {
if (Model.getFacade().getStimuli(action) != null) {
Iterator iter = Model.getFacade().getStimuli(action).iterator();
if (iter.hasNext()) {
return iter.next();
}
}
if (Model.getFacade().getMessages(action) != null) {
Iterator iter =
Model.getFacade().getMessages(action).iterator();
if (iter.hasNext()) {
return iter.next();
}
}
if (Model.getFacade().getTransition(action) != null) {
return Model.getFacade().getTransition(action);
}
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
return null;
}
public void addAction(Object handle, Object action) {
if (!(handle instanceof ActionSequence)
|| !(action instanceof Action)) {
throw new IllegalArgumentException();
}
try {
((ActionSequence) handle).getAction().add((Action) action);
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
public void addAction(Object handle, int position, Object action) {
if (!(handle instanceof ActionSequence)
|| !(action instanceof Action)) {
throw new IllegalArgumentException();
}
try {
((ActionSequence) handle).getAction()
.add(position, (Action) action);
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
public void removeAction(Object handle, Object action) {
if (!(handle instanceof ActionSequence)
|| !(action instanceof Action)) {
throw new IllegalArgumentException();
}
try {
((ActionSequence) handle).getAction().remove(action);
} catch (InvalidObjectException e) {
throw new InvalidElementException(e);
}
}
}