Coverage Report

 /* $Id: ProjectImpl.java 18921 2010-12-15 18:16:53Z thn $
  *******************************************************************************
  * Copyright (c) 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:
  *    Tom Morris
  *    Bob Tarling
  *    Michiel van der Wulp
  *******************************************************************************
  *
  * Some portions of this file were previously release using the BSD License:
  */
 
 // $Id: ProjectImpl.java 18921 2010-12-15 18:16:53Z thn $
 // Copyright (c) 1996-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.kernel;
 
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
 import java.beans.PropertyVetoException;
 import java.beans.VetoableChangeSupport;
 import java.io.File;
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import org.apache.log4j.Logger;
 import org.argouml.application.api.Argo;
 import org.argouml.application.helpers.ApplicationVersion;
 import org.argouml.configuration.Configuration;
 import org.argouml.i18n.Translator;
 import org.argouml.model.InvalidElementException;
 import org.argouml.model.Model;
 import org.argouml.profile.Profile;
 import org.argouml.profile.ProfileFacade;
 import org.argouml.ui.targetmanager.TargetManager;
 import org.argouml.uml.CommentEdge;
 import org.argouml.uml.ProjectMemberModel;
 import org.argouml.uml.cognitive.ProjectMemberTodoList;
 import org.argouml.uml.diagram.ArgoDiagram;
 import org.argouml.uml.diagram.DiagramFactory;
 import org.argouml.uml.diagram.ProjectMemberDiagram;
 import org.tigris.gef.presentation.Fig;
 
 /**
  * The ProjectImpl is a data structure that represents the designer's
  * current project. It manages the list of diagrams and UML models.
  * <p>
  * NOTE: This was named Project until 0.25.4 when it was replaced by an
  * interface of the same name and renamed to ProjectImpl.
  */
 public class ProjectImpl implements java.io.Serializable, Project {
 
     private static final Logger LOG = Logger.getLogger(ProjectImpl.class);
 
     /**
      * Default name for a project.
      */
     private static final String UNTITLED_FILE =
         Translator.localize("label.projectbrowser-title");
 
     /**
      * The project type
      */
     private int projectType = UML_PROJECT;
 
     /**
      * The UID.
      */
     static final long serialVersionUID = 1399111233978692444L;
 
     /**
      * TODO: should just be the directory to write.
      */
     private URI uri;
 
     /* The preferences with project-scope: */
     private String authorname;
     private String authoremail;
     private String description;
     /* The ArgoUML version with which this project was last saved: */
     private String version;
 
     private ProjectSettings projectSettings;
 
     private final List<String> searchpath = new ArrayList<String>();
 
     // TODO: break into 3 main member types
     // model, diagram and other
     private final List<ProjectMember> members = new MemberList();
 
     private String historyFile;
 
     /**
      * The version number of the persistence format that last
      * saved this project.
      */
     private int persistenceVersion;
 
     /**
      * Instances of the UML model.
      */
     private final List models = new ArrayList();
     
     private Object root;
     private final Collection roots = new HashSet();
 
     /**
      * Instances of the UML diagrams.
      */
     private final List<ArgoDiagram> diagrams = new ArrayList<ArgoDiagram>();
     
     private Object currentNamespace;
     private Map<String, Object> uuidRefs;
     private transient VetoableChangeSupport vetoSupport;
 
     private ProfileConfiguration profileConfiguration;
 
     /**
      * The active diagram, pointer to a diagram in the list with diagrams.
      */
     private ArgoDiagram activeDiagram;
     
     /** The name of the diagram to show by default after loading a project. */
     private String savedDiagramName;
 
     /**
      * Cache for the default model.
      */
     private HashMap<String, Object> defaultModelTypeCache = 
         new HashMap<String, Object>();
 
     private final Collection trashcan = new ArrayList();
 
     // TODO: Change this to use an UndoManager instance per project when
     // GEF has been enhanced.
     private UndoManager undoManager = new DefaultUndoManager(this);
 
     private boolean dirty = false;
     
     /**
      * Constructor.
      *
      * @param theProjectUri Uri to read the project from.
      */
     public ProjectImpl(int type, URI theProjectUri) {
         this(UML_PROJECT);
         /* TODO: Why was this next line in the code so long? */
 //        uri = PersistenceManager.getInstance().fixUriExtension(theProjectUri);
         uri = theProjectUri;
     }
 
     /**
      * Constructor.
      */
     public ProjectImpl() {
         this(UML_PROJECT);
     }
 
     /**
      * Constructor.
      */
     public ProjectImpl(int type) {
         projectType = type;
         setProfileConfiguration(new ProfileConfiguration(this));
 
         projectSettings = new ProjectSettings(this);
 
         Model.getModelManagementFactory().setRootModel(null);
 
         authorname = Configuration.getString(Argo.KEY_USER_FULLNAME);
         authoremail = Configuration.getString(Argo.KEY_USER_EMAIL);
         description = "";
         // this should be moved to a ui action.
         version = ApplicationVersion.getVersion();
 
         historyFile = "";
 
         LOG.info("making empty project with empty model");
         addSearchPath("PROJECT_DIR");
     }
 
 
     public String getName() {
         // TODO: maybe separate name
         if (uri == null) {
             return UNTITLED_FILE;
         }
         return new File(uri).getName();
     }
 
     public int getProjectType() {
         return projectType;
     }
     
     public void setProjectType(int projectType) {
         this.projectType = projectType;
     }
 
     public URI getUri() {
         return uri;
     }
 
 
     public URI getURI() {
         return uri;
     }
 
     /**
      * @param theUri the URI for the project
      */
     public void setUri(URI theUri) {
         if (LOG.isDebugEnabled()) {
             LOG.debug("Setting project URI from \"" + uri
                       + "\" to \"" + theUri + "\".");
         }
         uri = theUri;
     }
 
     public void setFile(final File file) {
         URI theProjectUri = file.toURI();
 
         if (LOG.isDebugEnabled()) {
             LOG.debug("Setting project file name from \""
                       + uri
                       + "\" to \""
                       + theProjectUri
                       + "\".");
         }
 
         uri = theProjectUri;
     }
 
 
     public List<String> getSearchPathList() {
         return Collections.unmodifiableList(searchpath);
     }
 
 
     public void addSearchPath(final String searchPathElement) {
         if (!searchpath.contains(searchPathElement)) {
             searchpath.add(searchPathElement);
         }
     }
 
 
     public List<ProjectMember> getMembers() {
         LOG.info("Getting the members there are " + members.size());
         return members;
     }
 
     /**
      * @param d the diagram
      */
     private void addDiagramMember(ArgoDiagram d) {
         // Check for duplicate name and rename if necessary
         int serial = getDiagramCount();
         while (!isValidDiagramName(d.getName())) {
             try {
                 d.setName(d.getName() + " " + serial);
             } catch (PropertyVetoException e) {
                 serial++;            
             }
         }
         ProjectMember pm = new ProjectMemberDiagram(d, this);
         addDiagram(d);
         // if diagram added successfully, add the member too
         members.add(pm);
     }
 
     /**
      * @param pm the member to be added
      */
     private void addTodoMember(ProjectMemberTodoList pm) {
         // Adding a todo member removes any existing one.
         members.add(pm);
         LOG.info("Added todo member, there are now " + members.size());
     }
 
 
     public void addMember(Object m) {
 
         if (m == null) {
             throw new IllegalArgumentException(
                     "A model member must be supplied");
         } else if (m instanceof ArgoDiagram) {
             LOG.info("Adding diagram member");
             addDiagramMember((ArgoDiagram) m);
         } else if (m instanceof ProjectMemberTodoList) {
             LOG.info("Adding todo member");
             addTodoMember((ProjectMemberTodoList) m);
         } else if (Model.getFacade().isAModel(m)) {
             LOG.info("Adding model member");
             addModelMember(m);
         } else if (Model.getFacade().isAProfile(m)) {
             LOG.info("Adding profile model member");
             addModelMember(m);
         } else {
             throw new IllegalArgumentException(
                     "The member must be a UML model todo member or diagram."
                     + "It is " + m.getClass().getName());
         }
         LOG.info("There are now " + members.size() + " members");
     }
 
     /**
      * @param m the model
      */
     private void addModelMember(final Object m) {
 
         boolean memberFound = false;
         Object currentMember =
             members.get(0);
         if (currentMember instanceof ProjectMemberModel) {
             Object currentModel =
                 ((ProjectMemberModel) currentMember).getModel();
             if (currentModel == m) {
                 memberFound = true;
             }
         }
 
         if (!memberFound) {
             if (!models.contains(m)) {
                 addModel(m);
             }
             // got past the veto, add the member
             ProjectMember pm = new ProjectMemberModel(m, this);
             LOG.info("Adding model member to start of member list");
             members.add(pm);
         } else {
             LOG.info("Attempted to load 2 models");
             throw new IllegalArgumentException(
                     "Attempted to load 2 models");
         }
     }
 
 
     public void addModel(final Object model) {
 
         if (!Model.getFacade().isAModel(model)
              && !Model.getFacade().isAProfile(model)) {
             throw new IllegalArgumentException();
         }
         if (!models.contains(model)) {
             setRoot(model);
         }        
     }
 
     private void addModelInternal(final Object model) {
         models.add(model);
         roots.add(model);
         setCurrentNamespace(model);
         setSaveEnabled(true);
         if (models.size() > 1 || roots.size() > 1) {
             LOG.debug("Multiple roots/models");
         }
     }
 
     /**
      * Removes a project member diagram completely from the project.
      * @param d the ArgoDiagram
      */
     protected void removeProjectMemberDiagram(ArgoDiagram d) {
         if (activeDiagram == d) {
             LOG.debug("Deleting active diagram " + d);
             ArgoDiagram defaultDiagram = null;
             if (diagrams.size() == 1) {
                 // We're deleting the last diagram so lets create a new one
                 // TODO: Once we go MDI we won't need this.
                 LOG.debug("Deleting last diagram - creating new default diag");
                 Object projectRoot = getRoot();
                 if (!Model.getUmlFactory().isRemoved(projectRoot)) {
                     defaultDiagram = DiagramFactory.getInstance()
                             .createDefaultDiagram(projectRoot);
                     addMember(defaultDiagram);
                 }
             } else {
                 // Make the topmost diagram (that is not the one being deleted)
                 // current.
                 defaultDiagram = diagrams.get(0);
                 LOG.debug("Candidate default diagram is " + defaultDiagram);
                 if (defaultDiagram == d) {
                     defaultDiagram = diagrams.get(1);
                     LOG.debug("Switching default diagram to " + defaultDiagram);
                 }
             }
             activeDiagram = defaultDiagram;
             TargetManager.getInstance().setTarget(activeDiagram);
             LOG.debug("New active diagram is " + defaultDiagram);
         }
 
         removeDiagram(d);
         members.remove(d);
         d.remove();
         setSaveEnabled(true);
     }
     
     /**
      * Enables the save action if this project is the current project
      * @param enable true to enable
      */
     private void setSaveEnabled(boolean enable) {
         ProjectManager pm = ProjectManager.getManager();
         if (pm.getCurrentProject() == this) {
             pm.setSaveEnabled(enable);
         }
     }
 
 
     public String getAuthorname() {
         return authorname;
     }
 
 
     public void setAuthorname(final String s) {
         final String oldAuthorName = authorname;
         AbstractCommand command = new AbstractCommand() {
             public Object execute() {
                 authorname = s;
                 return null;
             }
 
             public void undo() {
                 authorname = oldAuthorName;
             }
         };
         undoManager.execute(command);
     }
 
 
     public String getAuthoremail() {
         return authoremail;
     }
 
 
     public void setAuthoremail(final String s) {
         final String oldAuthorEmail = authoremail;
         AbstractCommand command = new AbstractCommand() {
             public Object execute() {
                 authoremail = s;
                 return null;
             }
 
             public void undo() {
                 authoremail = oldAuthorEmail;
             }
         };
         undoManager.execute(command);
     }
 
 
     public String getVersion() {
         return version;
     }
 
 
     public void setVersion(String s) {
         version = s;
     }
 
 
     public String getDescription() {
         return description;
     }
 
 
     public void setDescription(final String s) {
         final String oldDescription = description;
         AbstractCommand command = new AbstractCommand() {
             public Object execute() {
                 description = s;
                 return null;
             }
 
             public void undo() {
                 description = oldDescription;
             }
         };
         undoManager.execute(command);
     }
 
 
     public String getHistoryFile() {
         return historyFile;
     }
 
 
     public void setHistoryFile(final String s) {
         historyFile = s;
     }
 
 
     public List getUserDefinedModelList() {
         return models;
     }
 
 
     public Collection getModels() {
         Set result = new HashSet();
         result.addAll(models);
         for (Profile profile : getProfileConfiguration().getProfiles()) {
             try {
                 result.addAll(profile.getProfilePackages());
             } catch (org.argouml.profile.ProfileException e) {
                 LOG.error("Exception when fetching models from profile "
                         + profile.getDisplayName(), e);
             }
         }
         return Collections.unmodifiableCollection(result);
     }
 
     /**
      * Return the model.<p>
      *
      * If there isn't exactly one model, <code>null</code> is returned.
      *
      * @return the model.
      * @deprecated for 0.25.4 by tfmorris.  Use 
      * {@link #getUserDefinedModelList()} or {@link #getModels()}.
      * @see org.argouml.kernel.Project#getModel()
      */
     @SuppressWarnings("deprecation")
     @Deprecated
     public Object getModel() {
         if (models.size() != 1) {
             return null;
         }
         return models.iterator().next();
     }
 
 
     public Object findType(String s) {
         return findType(s, true);
     }
 
 
     public Object getDefaultAttributeType() {
         if (profileConfiguration.getDefaultTypeStrategy() != null) {
             return profileConfiguration.getDefaultTypeStrategy()
                     .getDefaultAttributeType();
         }
         return null;
     }
 
 
     public Object getDefaultParameterType() {
         if (profileConfiguration.getDefaultTypeStrategy() != null) {
             return profileConfiguration.getDefaultTypeStrategy()
                     .getDefaultParameterType();
         }
         return null;
     }
     
 
     public Object getDefaultReturnType() {
         if (profileConfiguration.getDefaultTypeStrategy() != null) {
             return profileConfiguration.getDefaultTypeStrategy()
                     .getDefaultReturnType();
         }
         return null;
     }
 
 
     public Object findType(String s, boolean defineNew) {
         if (s != null) {
             s = s.trim();
         }
         if (s == null || s.length() == 0) {
             return null;
         }
         Object cls = null;
         for (Object model : models) {
             cls = findTypeInModel(s, model);
             if (cls != null) {
                 return cls;
             }
         }
         cls = findTypeInDefaultModel(s);
 
         if (cls == null && defineNew) {
             LOG.debug("new Type defined!");
             cls =
                 Model.getCoreFactory().buildClass(getCurrentNamespace());
             Model.getCoreHelper().setName(cls, s);
         }
         return cls;
     }
 
 
     public Collection<Fig> findFigsForMember(Object member) {
         Collection<Fig> figs = new ArrayList<Fig>();
         for (ArgoDiagram diagram : diagrams) {
             Fig fig = diagram.getContainingFig(member);
             if (fig != null) {
                 figs.add(fig);
             }
         }
         return figs;
     }
 
 
     public Collection findAllPresentationsFor(Object obj) {
         Collection<Fig> figs = new ArrayList<Fig>();
         for (ArgoDiagram diagram : diagrams) {
             Fig aFig = diagram.presentationFor(obj);
             if (aFig != null) {
                 figs.add(aFig);
             }
         }
         return figs;
     }
 
     public Object findTypeInModel(String typeName, Object namespace) {
         if (typeName == null) {
             throw new IllegalArgumentException("typeName must be non-null");
         }
         if (!Model.getFacade().isANamespace(namespace)) {
             throw new IllegalArgumentException(
                     "Looking for the classifier " + typeName
                     + " in a non-namespace object of " + namespace
                     + ". A namespace was expected.");
             }
 
         Collection allClassifiers =
             Model.getModelManagementHelper()
                 .getAllModelElementsOfKind(namespace,
                         Model.getMetaTypes().getClassifier());
 
         for (Object classifier : allClassifiers) {
             if (typeName.equals(Model.getFacade().getName(classifier))) {
                 return classifier;
             }
         }
 
         return null;
     }
 
 
     @SuppressWarnings("deprecation")
     @Deprecated
     public void setCurrentNamespace(final Object m) {
 
         if (m != null && !Model.getFacade().isANamespace(m)) {
             throw new IllegalArgumentException();
             }
 
         currentNamespace = m;
     }
 
 
     @SuppressWarnings("deprecation")
     @Deprecated
     public Object getCurrentNamespace() {
         return currentNamespace;
     }
 
 
     public List<ArgoDiagram> getDiagramList() {
         return Collections.unmodifiableList(diagrams);
     }
 
 
     public int getDiagramCount() {
         return diagrams.size();
     }
 
 
     public ArgoDiagram getDiagram(String name) {
         for (ArgoDiagram ad : diagrams) {
             if (ad.getName() != null && ad.getName().equals(name)) {
                 return ad;
             }
             if (ad.getItemUID() != null
                     && ad.getItemUID().toString().equals(name)) {
                 return ad;
             }
         }
         return null;
     }
 
 
     public void addDiagram(final ArgoDiagram d) {
         // send indeterminate new value instead of making copy of vector
         d.setProject(this);
         diagrams.add(d);
 
         d.addPropertyChangeListener("name", new NamePCL());
         setSaveEnabled(true);
     }
 
     /**
      * Listener to events from the Diagram class. <p>
      *
      * Purpose: changing the name of a diagram shall set the need save flag.
      *
      * @author Michiel
      */
     private class NamePCL implements PropertyChangeListener {
         public void propertyChange(PropertyChangeEvent evt) {
             setSaveEnabled(true);
         }
     }
 
     /**
      * Removes a diagram from the list with diagrams.
      *
      * Removes (hopefully) the event listeners for this diagram.  Does
      * not remove the diagram from the project members. This should
      * not be called directly. Use moveToTrash if you want to remove a
      * diagram.
      *
      * @param d the ArgoDiagram
      */
     protected void removeDiagram(ArgoDiagram d) {
         diagrams.remove(d);
         /* Remove the dependent
          * modelelements, such as the statemachine
          * for a statechartdiagram:
          */
         Object o = d.getDependentElement();
         if (o != null) {
             moveToTrash(o);
         }
     }
 
     public int getPresentationCountFor(Object me) {
 
         if (!Model.getFacade().isAUMLElement(me)) {
             throw new IllegalArgumentException();
             }
 
         int presentations = 0;
         for (ArgoDiagram d : diagrams) {
             presentations += d.getLayer().presentationCountFor(me);
         }
         return presentations;
     }
 
 
     public Object getInitialTarget() {
         if (savedDiagramName != null) {
             /* Hence, a diagram name was saved in the project 
              * that we are loading. So, we use this name 
              * to retrieve any matching diagram. */
             return getDiagram(savedDiagramName);
         }
         if (diagrams.size() > 0) {
             /* Use the first diagram. */
             return diagrams.get(0);
         }
         if (models.size() > 0) {
             /* If there was no diagram at all, 
              * then use the (first) UML model. */
             return models.iterator().next();
         }
         return null;
     }
 
     public void preSave() {
         for (ArgoDiagram diagram : diagrams) {
             diagram.preSave();
         }
     }
 
     public void postSave() {
         for (ArgoDiagram diagram : diagrams) {
             diagram.postSave();
         }
         setSaveEnabled(true);
     }
 
     public void postLoad() {
         long startTime = System.currentTimeMillis();
         for (ArgoDiagram diagram : diagrams) {
             diagram.postLoad();
         }
         long endTime = System.currentTimeMillis();
         LOG.debug("Diagram post load took " + (endTime - startTime) + " msec.");
         
         // issue 1725: the root is not set, which leads to problems
         // with displaying prop panels
         Object model = getModel();
 
         LOG.info("Setting root model to " + model);
 
         setRoot(model);
 
         setSaveEnabled(true);
         // we don't need this HashMap anymore so free up the memory
         uuidRefs = null;
     }
 
     ////////////////////////////////////////////////////////////////
     // trash related methods
 
     /**
      * Empty the trash can and permanently delete all objects that it contains.
      */
     private void emptyTrashCan() {
         trashcan.clear();
     }
 
     public void moveToTrash(Object obj) {
         if (obj instanceof Collection) {
             Iterator i = ((Collection) obj).iterator();
             while (i.hasNext()) {
                 Object trash = i.next();
                 if (!trashcan.contains(trash)) {
                     trashInternal(trash);
                 }
             }
         } else {
             if (!trashcan.contains(obj)) {
                 trashInternal(obj);
             }
         }
     }
 
     /**
      * Removes some object from the project.
      *
      * @param obj the object to be thrown away
      */
     protected void trashInternal(Object obj) {
         // TODO: This should only be checking for the top level package
         // (if anything at all)
         if (Model.getFacade().isAModel(obj)) {
             return; //Can not delete the model
         }
         if (Model.getFacade().isAProfile(obj)) {
             return; //Can not delete the profile
         }
 
         if (obj != null) {
             trashcan.add(obj);
         }
         if (Model.getFacade().isAUMLElement(obj)) {
 
             Model.getUmlFactory().delete(obj);
 
             // TODO: Presumably this is only relevant if
             // obj is actually a Model or Profile.
             // An added test of isAModel(obj) or isAProfile(obj) would clarify
             // what is going on here.
             if (models.contains(obj)) {
                 models.remove(obj);
             }
         } else if (obj instanceof ArgoDiagram) {
             removeProjectMemberDiagram((ArgoDiagram) obj);
             // Fire an event some anyone who cares about diagrams being
             // removed can listen for it
             ProjectManager.getManager()
                     .firePropertyChanged("remove", obj, null);
         } else if (obj instanceof Fig) {
             ((Fig) obj).deleteFromModel();
             // If we delete a FigEdge
             // or FigNode we actually call this method with the owner not
             // the Fig itself. However, this method 
             // is called by ActionDeleteModelElements
             // for primitive Figs (without owner).
             LOG.info("Request to delete a Fig " + obj.getClass().getName());
         } else if (obj instanceof CommentEdge) {
             // TODO: Why is this a special case? - tfm
             CommentEdge ce = (CommentEdge) obj;
             LOG.info("Removing the link from " + ce.getAnnotatedElement()
                     + " to " + ce.getComment());
             ce.delete();
         }
     }
 
 
     @SuppressWarnings("deprecation")
     @Deprecated
     public boolean isInTrash(Object obj) {
         return trashcan.contains(obj);
     }
 
 
 
     public Object findTypeInDefaultModel(String name) {
         if (defaultModelTypeCache.containsKey(name)) {
             return defaultModelTypeCache.get(name);
         }
         
         Object result = profileConfiguration.findType(name);
         
         defaultModelTypeCache.put(name, result);
         return result;
     }
 
 
     @SuppressWarnings("deprecation")
     @Deprecated
     public final Object getRoot() {
         return root;
     }
 
 
     @SuppressWarnings("deprecation")
     @Deprecated
     public void setRoot(final Object theRoot) {
 
         if (theRoot == null) {
             throw new IllegalArgumentException(
                     "A root model element is required");
         }
         if (!Model.getFacade().isAModel(theRoot)
                 && !Model.getFacade().isAProfile(theRoot)) {
             throw new IllegalArgumentException(
                     "The root model element must be a model - got "
                     + theRoot.getClass().getName());
         }
 
         Object treeRoot = Model.getModelManagementFactory().getRootModel();
         if (treeRoot != null) {
             models.remove(treeRoot);
         }
         root = theRoot;
         // TODO: We don't really want to do the following, but I'm not sure
         // what depends on it - tfm - 20070725
         Model.getModelManagementFactory().setRootModel(theRoot);
         // TODO: End up with multiple models here
         addModelInternal(theRoot);
         roots.clear();
         roots.add(theRoot);
     }
 
 
     public final Collection getRoots() {
         return Collections.unmodifiableCollection(roots);
     }
 
 
     public void setRoots(final Collection elements) {
         boolean modelFound = false;
         for (Object element : elements) {
             if (!Model.getFacade().isAPackage(element)) {
                 LOG.warn("Top level element other than package found - " 
                         + Model.getFacade().getName(element));
             }
             if (Model.getFacade().isAModel(element)
                  || Model.getFacade().isAProfile(element) ) {
                 addModel(element);
                 if (!modelFound) {
                     setRoot(element);
                     modelFound = true;
                 }
             }
         }
         roots.clear();
         roots.addAll(elements);
     }
 
     public void updateRoots() {
         if (Model.getFacade().getUmlVersion().charAt(0) == '1') {
             // not needed in UML 1.x
             return;
         }
         roots.clear();
         for (Object m : models) {
             for (Object e : Model.getModelManagementHelper().getRootElements(m)) {
                 if (!roots.contains(e)) {
                     roots.add(e);
                     checkProfileFor(e, m);
                 }
             }
         }
     }
 
     public boolean isValidDiagramName(String name) {
         boolean rv = true;
         for (ArgoDiagram diagram : diagrams) {
             if (diagram.getName().equals(name)) {
                 rv = false;
                 break;
             }
         }
         return rv;
     }
 
 
     public Map<String, Object> getUUIDRefs() {
         return uuidRefs;
     }
 
     
     public void setSearchPath(final List<String> theSearchpath) {
         searchpath.clear();
         searchpath.addAll(theSearchpath);
     }
 
     public void setUUIDRefs(Map<String, Object> uUIDRefs) {
         uuidRefs = uUIDRefs;
     }
 
     @SuppressWarnings("deprecation")
     @Deprecated
     public ArgoDiagram getActiveDiagram() {
         return activeDiagram;
     }
 
 
 
     @SuppressWarnings("deprecation")
     @Deprecated
     public void setActiveDiagram(final ArgoDiagram theDiagram) {
         activeDiagram = theDiagram;
     }
     
     public void setSavedDiagramName(String diagramName) {
         savedDiagramName = diagramName;
     }
 
     public void remove() {
         for (ArgoDiagram diagram : diagrams) {
             diagram.remove();
         }
 
         members.clear();
         if (!roots.isEmpty()) {
             try {
                 Model.getUmlFactory().deleteExtent(roots.iterator().next());
             } catch (InvalidElementException e) {
                 LOG.warn("Extent deleted a second time");
             }
             roots.clear();
         }
         models.clear();
         diagrams.clear();
         searchpath.clear();
 
         if (uuidRefs != null) {
             uuidRefs.clear();
         }
 
         if (defaultModelTypeCache != null) {
             defaultModelTypeCache.clear();
         }
 
         uuidRefs = null;
         defaultModelTypeCache = null;
 
         uri = null;
         authorname = null;
         authoremail = null;
         description = null;
         version = null;
         historyFile = null;
         currentNamespace = null;
         vetoSupport = null;
         activeDiagram = null;
         savedDiagramName = null;
 
         emptyTrashCan();
     }
 
 
     public int getPersistenceVersion() {
         return persistenceVersion;
     }
 
 
     public void setPersistenceVersion(int pv) {
         persistenceVersion = pv;
     }
 
 
     public String repair() {
         StringBuilder report = new StringBuilder();
         Iterator it = members.iterator();
         while (it.hasNext()) {
             ProjectMember member = (ProjectMember) it.next();
             report.append(member.repair());
         }
         return report.toString();
     }
 
 
     public ProjectSettings getProjectSettings() {
         return projectSettings;
     }
     public UndoManager getUndoManager() {
         return undoManager;
     }
         
     public ProfileConfiguration getProfileConfiguration() {
         return profileConfiguration;
     }
 
     public void setProfileConfiguration(ProfileConfiguration pc) {
         if (this.profileConfiguration != pc) {
             if (this.profileConfiguration != null) {
                 this.members.remove(this.profileConfiguration);
             }
 
             this.profileConfiguration = pc;
 
             // there's just one ProfileConfiguration in a project
             // and there's no other way to add another one
             members.add(pc);
         }
         
         ProfileFacade.applyConfiguration(pc);
     }
 
     public boolean isDirty() {
         // TODO: Placeholder implementation until support for tracking on
         // a per-project basis is implemented
 //        return dirty;
         return ProjectManager.getManager().isSaveActionEnabled();
     }
     
     public void setDirty(boolean isDirty) {
         // TODO: Placeholder implementation until support for tracking on
         // a per-project basis is implemented
         dirty = isDirty;
         ProjectManager.getManager().setSaveEnabled(isDirty);
     }
 
     private void checkProfileFor(Object o, Object m) {
         Profile profile = null;
         if (Model.getFacade().isAAppliedProfileElement(o)) {
             Object pkg = Model.getFacade().getNamespace(o);
             if (pkg != null) {
                 String name = Model.getFacade().getName(pkg);
                 profile = ProfileFacade.getManager()
                         .lookForRegisteredProfile(name);
             }
         }
         if (profile != null) {
             getProfileConfiguration().addProfile(profile, m);
         }
     }
 }