/* $Id: UmlHelperMDRImpl.java 17765 2010-01-11 21:20:14Z linus $
*****************************************************************************
* 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-2006 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.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.argouml.model.Model;
import org.argouml.model.UmlHelper;
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.Link;
import org.omg.uml.behavioralelements.commonbehavior.LinkEnd;
import org.omg.uml.behavioralelements.statemachines.Event;
import org.omg.uml.behavioralelements.statemachines.Transition;
import org.omg.uml.behavioralelements.usecases.Extend;
import org.omg.uml.behavioralelements.usecases.ExtensionPoint;
import org.omg.uml.behavioralelements.usecases.UseCase;
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.Classifier;
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.Operation;
import org.omg.uml.foundation.core.Parameter;
import org.omg.uml.foundation.core.Relationship;
import org.omg.uml.foundation.core.UmlAssociation;
/**
* Helper class for UML metamodel.
*
* @since ARGO0.11.2
* @author Thierry Lach
*/
class UmlHelperMDRImpl implements UmlHelper {
/**
* The model implementation.
*/
private MDRModelImplementation modelImpl;
/**
* Don't allow instantiation.
*
* @param implementation
* To get other helpers and factories.
*/
UmlHelperMDRImpl(MDRModelImplementation implementation) {
modelImpl = implementation;
}
public void addListenersToModel(Object model) {
// Nothing to do - we get all events automatically
}
/*
* @see org.argouml.model.UmlHelper#deleteCollection(java.util.Collection)
*/
public void deleteCollection(Collection col) {
Iterator it = col.iterator();
while (it.hasNext()) {
modelImpl.getUmlFactory().delete(it.next());
}
}
/*
* @see org.argouml.model.UmlHelper#getSource(java.lang.Object)
*/
public Object getSource(Object relationship) {
if (relationship instanceof Message) {
Message message = (Message) relationship;
return message.getSender();
}
if (relationship instanceof Relationship) {
// handles all children of relationship including extend and
// include which are not members of core
return modelImpl.getCoreHelper().getSource(relationship);
}
if (relationship instanceof Transition) {
return modelImpl.getStateMachinesHelper().getSource(relationship);
}
if (relationship instanceof AssociationEnd) {
return modelImpl.getCoreHelper().getSource(relationship);
}
throw new IllegalArgumentException();
}
/*
* @see org.argouml.model.UmlHelper#getDestination(java.lang.Object)
*/
public Object getDestination(Object relationship) {
if (relationship instanceof Message) {
Message message = (Message) relationship;
return message.getSender();
}
if (relationship instanceof Relationship) {
// handles all children of relationship including extend and
// include which are not members of core
return modelImpl.getCoreHelper().getDestination(relationship);
}
if (relationship instanceof Transition) {
return modelImpl.getStateMachinesHelper().
getDestination(relationship);
}
if (relationship instanceof AssociationEnd) {
return modelImpl.getCoreHelper().getDestination(relationship);
}
throw new IllegalArgumentException();
}
/*
* @see org.argouml.model.UmlHelper#move(java.lang.Object, org.argouml.model.UmlHelper.Direction)
*/
public void move(Object parent, Object element, Direction direction) {
if (element instanceof Argument) {
final Argument arg = (Argument) element;
final Action action = arg.getAction();
final List<Argument> f = action.getActualArgument();
final int oldIndex = f.indexOf(arg);
final int newIndex = newPosition(oldIndex, f.size(), direction);
f.remove(arg);
f.add(newIndex, arg);
} else if (element instanceof Action) {
final Action act = (Action) element;
final ActionSequence actionSequence = act.getActionSequence();
final List<Action> f = actionSequence.getAction();
final int oldIndex = f.indexOf(act);
final int newIndex = newPosition(oldIndex, f.size(), direction);
f.remove(actionSequence);
f.add(newIndex, actionSequence);
} else if (element instanceof AssociationEnd) {
final AssociationEnd assEnd = (AssociationEnd) element;
final UmlAssociation assoc = assEnd.getAssociation();
final List<AssociationEnd> f = assoc.getConnection();
final int oldIndex = f.indexOf(assEnd);
final int newIndex = newPosition(oldIndex, f.size(), direction);
f.remove(assEnd);
f.add(newIndex, assEnd);
} else if (element instanceof Attribute && parent instanceof AssociationEnd) {
final Attribute attr = (Attribute) element;
final AssociationEnd assocEnd = attr.getAssociationEnd();
final List<Attribute> f = assocEnd.getQualifier();
final int oldIndex = f.indexOf(assocEnd);
final int newIndex = newPosition(oldIndex, f.size(), direction);
f.remove(attr);
f.add(newIndex, attr);
} else if (element instanceof Feature) {
final Feature att = (Feature) element;
final Classifier cls = att.getOwner();
final List f = Model.getFacade().getFeatures(cls);
final int oldIndex = f.indexOf(att);
final int newIndex = newPosition(oldIndex, f.size(), direction);
Model.getCoreHelper().removeFeature(cls, att);
Model.getCoreHelper().addFeature(cls, newIndex, att);
} else if (element instanceof Parameter && parent instanceof Event) {
final Parameter param = (Parameter) element;
final Event event = (Event) parent;
final List<Parameter> f = event.getParameter();
final int oldIndex = f.indexOf(param);
final int newIndex = newPosition(oldIndex, f.size(), direction);
f.remove(param);
f.add(newIndex, param);
} else if (element instanceof Parameter) {
final Parameter param = (Parameter) element;
final BehavioralFeature bf = param.getBehavioralFeature();
final List<Parameter> f = bf.getParameter();
final int oldIndex = f.indexOf(param);
final int newIndex = newPosition(oldIndex, f.size(), direction);
f.remove(param);
f.add(newIndex, param);
} else if (element instanceof EnumerationLiteral) {
final EnumerationLiteral lit = (EnumerationLiteral) element;
final Enumeration enumeration = lit.getEnumeration();
final List<EnumerationLiteral> f = enumeration.getLiteral();
final int oldIndex = f.indexOf(lit);
final int newIndex = newPosition(oldIndex, f.size(), direction);
f.remove(lit);
f.add(newIndex, lit);
} else if (element instanceof ExtensionPoint && parent instanceof Extend) {
final ExtensionPoint ep = (ExtensionPoint) element;
final Extend extend = (Extend) parent;
final List<ExtensionPoint> f = extend.getExtensionPoint();
final int oldIndex = f.indexOf(ep);
final int newIndex = newPosition(oldIndex, f.size(), direction);
f.remove(ep);
f.add(newIndex, ep);
} else if (element instanceof LinkEnd) {
final LinkEnd le = (LinkEnd) element;
final Link link = le.getLink();
final List f = new ArrayList(Model.getFacade().getConnections(link));
final int oldIndex = f.indexOf(le);
final int newIndex = newPosition(oldIndex, f.size(), direction);
f.remove(le);
f.add(newIndex, le);
Model.getCoreHelper().setConnections(link, f);
} else if (element instanceof ExtensionPoint && parent instanceof UseCase) {
final ExtensionPoint ep = (ExtensionPoint) element;
final UseCase extend = ep.getUseCase();
final List f = new ArrayList(Model.getFacade().getExtensionPoints(extend));
final int oldIndex = f.indexOf(ep);
final int newIndex = newPosition(oldIndex, f.size(), direction);
f.remove(ep);
f.add(newIndex, ep);
Model.getUseCasesHelper().setExtensionPoints(ep, f);
}
}
/*
* @see org.argouml.model.UmlHelper#move(java.lang.Object, org.argouml.model.UmlHelper.Direction)
*/
public boolean isMovable(Object metaType) {
final Class<?>[] movableMetaType = new Class<?> [] {
Action.class,
Argument.class,
AssociationEnd.class,
Attribute.class,
EnumerationLiteral.class,
Extend.class,
ExtensionPoint.class,
Feature.class,
LinkEnd.class,
Operation.class,
Parameter.class};
return Arrays.asList(movableMetaType).contains(metaType);
}
private int newPosition(int index, int size, Direction direction) {
final int posn;
if (direction == Direction.DOWN) {
posn = index + 1;
} else if (direction == Direction.UP) {
posn = index - 1;
} else if (direction == Direction.TOP) {
posn = 0;
} else if (direction == Direction.BOTTOM) {
posn = size - 1;
} else {
posn = 0;
}
return posn;
}
}