/* $Id: MDRModelImplementation.java 18760 2010-09-18 05:19:53Z tfmorris $

  *****************************************************************************

  * Copyright (c) 2005,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

  *****************************************************************************

  *

  * Some portions of this file was previously release using the BSD License:

  */

 // Copyright (c) 2005-2008 The Regents of the University of California. All

 // Rights Reserved. Permission to use, copy, modify, and distribute this

 // software and its documentation without fee, and without a written

 // agreement is hereby granted, provided that the above copyright notice

 // and this paragraph appear in all copies. This software program and

 // documentation are copyrighted by The Regents of the University of

 // California. The software program and documentation are supplied "AS

 // IS", without any accompanying services from The Regents. The Regents

 // does not warrant that the operation of the program will be

 // uninterrupted or error-free. The end-user understands that the program

 // was developed for research purposes and is advised not to rely

 // exclusively on the program for any reason. IN NO EVENT SHALL THE

 // UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,

 // SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,

 // ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF

 // THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF

 // SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY

 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE

 // PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF

 // CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,

 // UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 package org.argouml.model.mdr;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.net.URL;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import javax.jmi.model.ModelPackage;

 import javax.jmi.model.MofPackage;

 import javax.jmi.reflect.InvalidObjectException;

 import javax.jmi.reflect.RefObject;

 import javax.jmi.reflect.RefPackage;

 import javax.jmi.xmi.MalformedXMIException;

 import org.apache.log4j.Logger;

 import org.argouml.model.ActivityGraphsFactory;

 import org.argouml.model.ActivityGraphsHelper;

 import org.argouml.model.AggregationKind;

 import org.argouml.model.ChangeableKind;

 import org.argouml.model.CollaborationsFactory;

 import org.argouml.model.CollaborationsHelper;

 import org.argouml.model.CommonBehaviorFactory;

 import org.argouml.model.CommonBehaviorHelper;

 import org.argouml.model.ConcurrencyKind;

 import org.argouml.model.CoreFactory;

 import org.argouml.model.CoreHelper;

 import org.argouml.model.DataTypesFactory;

 import org.argouml.model.DataTypesHelper;

 import org.argouml.model.DiagramInterchangeModel;

 import org.argouml.model.DirectionKind;

 import org.argouml.model.ExtensionMechanismsFactory;

 import org.argouml.model.ExtensionMechanismsHelper;

 import org.argouml.model.Facade;

 import org.argouml.model.MetaTypes;

 import org.argouml.model.ModelEventPump;

 import org.argouml.model.ModelImplementation;

 import org.argouml.model.ModelManagementFactory;

 import org.argouml.model.ModelManagementHelper;

 import org.argouml.model.OrderingKind;

 import org.argouml.model.PseudostateKind;

 import org.argouml.model.ScopeKind;

 import org.argouml.model.StateMachinesFactory;

 import org.argouml.model.StateMachinesHelper;

 import org.argouml.model.UUIDManager;

 import org.argouml.model.UmlException;

 import org.argouml.model.UmlFactory;

 import org.argouml.model.UmlHelper;

 import org.argouml.model.UseCasesFactory;

 import org.argouml.model.UseCasesHelper;

 import org.argouml.model.VisibilityKind;

 import org.argouml.model.XmiReader;

 import org.argouml.model.XmiWriter;

 import org.netbeans.api.mdr.CreationFailedException;

 import org.netbeans.api.mdr.MDRManager;

 import org.netbeans.api.mdr.MDRepository;

 import org.netbeans.api.xmi.XMIReader;

 import org.netbeans.api.xmi.XMIReaderFactory;

 import org.omg.uml.UmlPackage;

 /**

  * The handle to find all helper and factories.

  */

 public class MDRModelImplementation implements ModelImplementation {

     /**

      * Logger.

      */

     private static final Logger LOG =

         Logger.getLogger(MDRModelImplementation.class);

     private Facade theFacade;

     private ModelEventPumpMDRImpl theModelEventPump;

     private CopyHelper theCopyHelper;

     private ActivityGraphsHelper theActivityGraphsHelper;

     private CoreHelper theCoreHelper;

     private MetaTypes theMetaTypes = new MetaTypesMDRImpl();

     private ModelManagementFactory theModelManagementFactory;

     private ModelManagementHelper theModelManagementHelper;

     private StateMachinesHelper theStateMachinesHelper;

     private UmlFactory theUmlFactory;

     private UmlHelper theUmlHelper;

     private UseCasesFactory theUseCasesFactory;

     private UseCasesHelper theUseCasesHelper;

     private ActivityGraphsFactory theActivityGraphsFactory;

     private CollaborationsFactory theCollaborationsFactory;

     private CollaborationsHelper theCollaborationsHelper;

     private CommonBehaviorFactory theCommonBehaviorFactory;

     private CommonBehaviorHelper theCommonBehaviorHelper;

     private DataTypesFactoryMDRImpl theDataTypesFactory;

     private DataTypesHelper theDataTypesHelper;

     private ExtensionMechanismsFactory theExtensionMechanismsFactory;

     private ExtensionMechanismsHelper theExtensionMechanismsHelper;

     private StateMachinesFactory theStateMachinesFactory;

     private CoreFactory theCoreFactory;

     private KindsMDRImpl theKindsObject;

     private MDRepository repository;

     /**

      * Package containing user UML model.

      */

     private UmlPackage umlPackage;

     /**

      * MOF Package containing UML metamodel (M2).

      */

     private MofPackage mofPackage;

     /**

      * Top level MOF extent.

      */

     private ModelPackage mofExtent;

     /**

      * Map of model elements to xmi.ids used to keep xmi.ids stable

      * across read/write cycles.

      */

     private Map<String, XmiReference> objectToId = 

         Collections.synchronizedMap(new HashMap<String, XmiReference>());

     /**

      * Set of known public IDs of models that could be used to resolve URLs 

      * from model element IDs.

      */

     private Map<String, String> public2SystemIds = 

         Collections.synchronizedMap(new HashMap<String, String>());

     /**

      * Index of objects keyed by system ID, then xmi.id within that file

      */

     private Map<String, Map<String, Object>> idToObject = 

         Collections.synchronizedMap(new HashMap<String, Map<String, Object>>());

     private List<String> searchDirs = new ArrayList<String>();

     /**

      * Set of extents and their read-only status. 

      */

     private Map<UmlPackage, Extent> extents = 

         new HashMap<UmlPackage, Extent>(10, (float) .5);

     private class Extent {

         int refCount = 0;

         boolean readOnly = false;

         String name;

         Extent(String name, boolean readOnly) {

             this.name = name;

             this.readOnly = readOnly;

         }

         int getRefCount() {

             return refCount;

         }

         synchronized int decrementCount() {

             return refCount--;

         }

         synchronized int incrementCount() {

             return refCount++;

         }

     }

     /**

      * @return Returns the root UML Factory package for user model.

      * @deprecated for 0.26. Use RefObject.refOutermostPackage instead if at all

      *             possible. In some cases (like an unqualified createClass()),

      *             additional infrastructure work is required in the ArgoUML app

      *             before this will be possible.

      */

     public UmlPackage getUmlPackage() {

         synchronized (extents) {

             if (umlPackage == null) {

                 LOG.debug("umlPackage is null - no current extent");

             }

             return umlPackage;

         }

     }

     RefPackage createExtent(String name, boolean readOnly) {

         try {

             synchronized (extents) {

                 UmlPackage extent = (UmlPackage) getRepository().createExtent(

                         name, getMofPackage());

                 extents.put(extent, new Extent(name,readOnly));

                 if (!readOnly) {

                     // TODO: This will need to change when we support multiple

                     // user models.

                     // Delete the old extent first

                     if (umlPackage != null) {

                         try {

                             deleteExtentUnchecked(umlPackage);

                         } catch (InvalidObjectException e) {

                             LOG.debug("User model extent already deleted");

                         }

                     }

                     umlPackage = extent;

                 }

                 if (LOG.isDebugEnabled()) {

                     LOG.debug("Created new " + (readOnly ? "readonly " : "")

                             + "extent " + umlPackage);

                     LOG.debug("All registered extents = "

                             + Arrays.toString(repository.getExtentNames()));

                 }

                 return extent;

             }

         } catch (CreationFailedException e) {

             LOG.error("Extent creation failed for " + name);

             return null;

         }

     }

     /**

      * Delete all extents except those for the UML metamodel and the 

      * meta-meta model (ie MOF).

      */

     private void cleanExtents() {

         String[] names = repository.getExtentNames();

         for (String n : names) {

             if (!MOF_EXTENT_NAME.equals(n) && !"MOF".equals(n)) {

                 RefPackage extent = repository.getExtent(n);

                 extent.refDelete();

                 LOG.debug("Deleting extent " + n);

             }

         }

     }

     void deleteExtent(UmlPackage extent) {

         synchronized (extents) {

             if (umlPackage.equals(extent)) {

                 // Make sure we always have a default extent.

                 // The old extent will get deleted as part of creating the

                 // new extent.

                 createDefaultExtent();

             } else {

                 deleteExtentUnchecked(extent);

             }

         }

     }

     private void deleteExtentUnchecked(UmlPackage extent) {

         synchronized (extents) {

             Extent e = extents.get(extent);

             if (e == null) {

                 LOG.warn("No listing for extent " + extent);

                 extent.refDelete();

             } else {

                 if (e.decrementCount() == 0) {

                     String name = extents.remove(extent).name;

                     if (public2SystemIds.remove(name) == null) {

                         if (!"model extent".equals(name)) {

                             LOG.warn("No system id found for extent "

                                     + (name == null ? "" : name) + " : "

                                     + extent);

                         }

                     }

                     if (idToObject.remove(name) == null) {

                         if (!"model extent".equals(name)) {

                             LOG.warn("No ID map found for extent "

                                     + (name == null ? "" : name) + " : "

                                     + extent);

                         }

                     }

                     // TODO: Need to clean up objectToId

                     // (can we do it based on modelelement delete

                     // notifications?)

                     extent.refDelete();

                 }

             }

         }

     }

     Collection<UmlPackage> getExtents() {

         return Collections.unmodifiableSet(extents.keySet());

     }

     public UmlPackage getExtent(String name) {

         return (UmlPackage) repository.getExtent(name);

     }

     boolean isReadOnly(Object extent) {

         synchronized (extents) {

             Extent result = extents.get(extent);

             if (result == null) {

 //                LOG.warn("Unable to find extent " + extent);

                 return false;

             } 

             return result.readOnly;

         }

     }

     /**

      * @return MOF Package containing UML metamodel (M2).

      */

     public MofPackage getMofPackage() {

         return mofPackage;

     }

     /**

      * @return Top level MOF extent.

      */

     ModelPackage getModelPackage() {

         return mofExtent;

     }

     /**

      * @return The MDRepository.

      */

     MDRepository getRepository() {

         return repository;

     }

     static final String MOF_EXTENT_NAME = "MOF Extent";

     static final String MODEL_EXTENT_NAME = "model extent";

     /**

      * UML 1.4 metamodel definition in XMI format.

      */

     static final String METAMODEL_URL = "mof/01-02-15_Diff.xml";

     /**

      * Constructor intended for use by decorators which need to override some of

      * the bootstrapping logic. Decorators must call

      * {@link #initializeFactories} on the new model after loading the default

      * extent.

      * 

      * @param r the underlying repository implementation

      * @throws UmlException on any fatal error. Actual cause will be inclused as

      *             a nested exception

      */

     public MDRModelImplementation(MDRepository r) throws UmlException {

         repository = r;

         initializeM2();

     }

     /**

      * Constructor.

      *

      * @throws UmlException if construction fails.  Some possible nested 

      * exceptions include:

      * <ul>

      * <el>CreationFailedException - If the creation of the Extent fail</el>

      * <el>MalformedXMIException If the metamodel XMI is badly formed</el>

      * <el>IOException If there is a problem opening a file</el>

      * </ul>

      */

     public MDRModelImplementation() throws UmlException {

         this(getDefaultRepository());

         cleanExtents();

         createDefaultExtent();

         if (umlPackage == null) {

             throw new UmlException("Could not create UML extent");

         }

         LOG.debug("MDR Init - created UML extent");

         initializeFactories(umlPackage);

     }

     private static MDRepository getDefaultRepository() {

         LOG.debug("Starting MDR system initialization");

         String storageImplementation =

             System.getProperty(

                 "org.netbeans.mdr.storagemodel.StorageFactoryClassName",

                 "org.netbeans.mdr.persistence.memoryimpl.StorageFactoryImpl");

         System.setProperty(

                 "org.netbeans.mdr.storagemodel.StorageFactoryClassName",

                 storageImplementation);

         /*

          * Set the storage id for our repository so that MofIds will be unique

          * (they are composed as "storageId":"serialNumber"). NOTE: The storage

          * manager only looks for a few property names such as the

          * StorageFactoryClassName. Everything else needs to be prefixed with

          * "MDRStorageProperty." which gets deleted from the property name

          * before it and its associated value are copied to an *internal*

          * property table separate from the system property table.

          */

         System.setProperty(

                 "MDRStorageProperty.org.netbeans.mdr.persistence.memoryimpl.id",

                 UUIDManager.getInstance().getNewUUID());

         // Connect to the repository

         MDRepository defaultRepository = 

             MDRManager.getDefault().getDefaultRepository();

         LOG.debug("MDR Init - got default repository");

         return defaultRepository;

     }

     private void initializeM2() throws UmlException {

         mofExtent = (ModelPackage) repository.getExtent(MOF_EXTENT_NAME);

         LOG.debug("MDR Init - tried to get MOF extent");

         // Create an extent and read in our metamodel (M2 model)

         if (mofExtent == null) {

             try {

                 mofExtent = 

                     (ModelPackage) repository.createExtent(MOF_EXTENT_NAME);

             } catch (CreationFailedException e) {

                 throw new UmlException(e);

             }

             LOG.debug("MDR Init - created MOF extent");

             XMIReader reader = XMIReaderFactory.getDefault().createXMIReader();

             LOG.debug("MDR Init - created XMI reader");

             String metafacade =

                 System.getProperty("argouml.model.mdr.facade", METAMODEL_URL);

             URL resource = getClass().getResource(metafacade);

             try {

                 reader.read(resource.toString(), mofExtent);

             } catch (IOException e) {

                 throw new UmlException(e);

             } catch (MalformedXMIException e) {

                 throw new UmlException(e);

             }

             LOG.debug("MDR Init - read UML metamodel");

         }

         mofPackage = null;

         for (MofPackage pkg : (Collection<MofPackage>) mofExtent

                 .getMofPackage().refAllOfClass()) {

             if ("UML".equals(pkg.getName())) {

                 mofPackage = pkg;

                 break;

             }

         }

     }

     /**

      * Initialize factories and other sub-objects.  The default constructor

      * takes care of this automatically, but decorating implementations

      * using the non-default constructor need to call it after they

      * have loaded the default extent.

      *

      * @param up default UmlPackage instance which has been created or loaded

      */

     public void initializeFactories(UmlPackage up) {

         umlPackage = up;

         // Create and start event pump first so it's available for all others

         theModelEventPump = new ModelEventPumpMDRImpl(this, repository);

         theModelEventPump.startPumpingEvents();

         LOG.debug("MDR Init - event pump started");

         // DataTypes is next so it's available for Kinds, ModelManagement,

         // & Extensions

         theDataTypesFactory = new DataTypesFactoryMDRImpl(this);

         theDataTypesHelper = new DataTypesHelperMDRImpl(this);

         theKindsObject = new KindsMDRImpl(this);

         theModelManagementFactory = new ModelManagementFactoryMDRImpl(this);

         theExtensionMechanismsHelper =

             new ExtensionMechanismsHelperMDRImpl(this);

         theExtensionMechanismsFactory =

             new ExtensionMechanismsFactoryMDRImpl(this);

         LOG.debug("MDR Init - initialized package Extension mechanism");

         // Initialize remaining factories and helpers

         // (but defer heavyweight ones until needed)

         theCopyHelper = new CopyHelper(this);

         theActivityGraphsHelper = new ActivityGraphsHelperMDRImpl();

         theCoreHelper = 

             new UndoCoreHelperDecorator(new CoreHelperMDRImpl(this));

         LOG.debug("MDR Init - initialized package Core helper");

         theModelManagementHelper = new ModelManagementHelperMDRImpl(this);

         theStateMachinesHelper = new StateMachinesHelperMDRImpl(this);

         LOG.debug("MDR Init - initialized package StateMachines");

         theUseCasesFactory = new UseCasesFactoryMDRImpl(this);

         theUseCasesHelper = new UseCasesHelperMDRImpl(this);

         LOG.debug("MDR Init - initialized package Use Cases");

         theActivityGraphsFactory = new ActivityGraphsFactoryMDRImpl(this);

         LOG.debug("MDR Init - initialized package Collaborations");

         theCommonBehaviorFactory = new CommonBehaviorFactoryMDRImpl(this);

         theCommonBehaviorHelper = new CommonBehaviorHelperMDRImpl(this);

         LOG.debug("MDR Init - initialized package CommonBehavior");

         theStateMachinesFactory = new StateMachinesFactoryMDRImpl(this);

         theCoreFactory = new CoreFactoryMDRImpl(this);

         LOG.debug("MDR Init - all packages initialized");

     }

     RefPackage createDefaultExtent() {

         // Create a default extent for the user UML model. This will get

         // replaced if a new model is read in from an XMI file.

         synchronized (extents) {

             umlPackage = (UmlPackage) repository.getExtent(MODEL_EXTENT_NAME);

             if (umlPackage != null) {

                 // NOTE: If we switch to a persistent repository like the b-tree

                 // repository we'll want to keep the old extent(s) around

                 try {

                     UmlPackage oldPackage = umlPackage;

                     umlPackage = null;

                     deleteExtentUnchecked(oldPackage);

                     LOG.debug("MDR Init - UML extent existed - "

                             + "deleted it and all UML data");

                 } catch (InvalidObjectException e) {

                     LOG.debug("Got error deleting old default user extent");

                 }

             }

             umlPackage = (UmlPackage) createExtent(MODEL_EXTENT_NAME, false);

             LOG.debug("Created default extent");

             return umlPackage;

         }

     }

     /**

      * Shutdown repository in a graceful fashion

      * (currently unused).

      */

     public void shutdown() {

         theModelEventPump.flushModelEvents();

         theModelEventPump.stopPumpingEvents();

         MDRManager.getDefault().shutdownAll();

     }

     /*

      * @see org.argouml.model.ModelImplementation#getDiagramInterchangeModel()

      */

     public DiagramInterchangeModel getDiagramInterchangeModel() {

         return null;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getFacade()

      */

     public Facade getFacade() {

         if (theFacade == null) {

             theFacade = new FacadeMDRImpl(this);

         }

         return theFacade;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getModelEventPump()

      */

     public ModelEventPump getModelEventPump() {

         return theModelEventPump;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getActivityGraphsFactory()

      */

     public ActivityGraphsFactory getActivityGraphsFactory() {

         return theActivityGraphsFactory;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getActivityGraphsHelper()

      */

     public ActivityGraphsHelper getActivityGraphsHelper() {

         return theActivityGraphsHelper;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getCollaborationsFactory()

      */

     public CollaborationsFactory getCollaborationsFactory() {

         if (theCollaborationsFactory == null) {

             theCollaborationsFactory =

                 new CollaborationsFactoryMDRImpl(this);

         }

         return theCollaborationsFactory;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getCollaborationsHelper()

      */

     public CollaborationsHelper getCollaborationsHelper() {

         if (theCollaborationsHelper == null) {

             theCollaborationsHelper =

                 new CollaborationsHelperMDRImpl(this);

         }

         return theCollaborationsHelper;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getCommonBehaviorFactory()

      */

     public CommonBehaviorFactory getCommonBehaviorFactory() {

         return theCommonBehaviorFactory;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getCommonBehaviorHelper()

      */

     public CommonBehaviorHelper getCommonBehaviorHelper() {

         return theCommonBehaviorHelper;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getCopyHelper()

      */

     public org.argouml.model.CopyHelper getCopyHelper() {

         return theCopyHelper;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getCoreFactory()

      */

     public CoreFactory getCoreFactory() {

         return theCoreFactory;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getCoreHelper()

      */

     public CoreHelper getCoreHelper() {

         return theCoreHelper;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getDataTypesFactory()

      */

     public DataTypesFactory getDataTypesFactory() {

         return theDataTypesFactory;

     }

     DataTypesFactoryMDRImpl getDataTypesFactoryInternal() {

         return theDataTypesFactory;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getDataTypesHelper()

      */

     public DataTypesHelper getDataTypesHelper() {

         return theDataTypesHelper;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getExtensionMechanismsFactory()

      */

     public ExtensionMechanismsFactory getExtensionMechanismsFactory() {

         return theExtensionMechanismsFactory;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getExtensionMechanismsHelper()

      */

     public ExtensionMechanismsHelper getExtensionMechanismsHelper() {

         return theExtensionMechanismsHelper;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getModelManagementFactory()

      */

     public ModelManagementFactory getModelManagementFactory() {

         return theModelManagementFactory;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getModelManagementHelper()

      */

     public ModelManagementHelper getModelManagementHelper() {

         return theModelManagementHelper;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getStateMachinesFactory()

      */

     public StateMachinesFactory getStateMachinesFactory() {

         return theStateMachinesFactory;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getStateMachinesHelper()

      */

     public StateMachinesHelper getStateMachinesHelper() {

         return theStateMachinesHelper;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getUmlFactory()

      */

     public UmlFactory getUmlFactory() {

         if (theUmlFactory == null) {

             theUmlFactory = new UmlFactoryMDRImpl(this);

         }

         return theUmlFactory;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getUmlHelper()

      */

     public UmlHelper getUmlHelper() {

         if (theUmlHelper == null) {

             theUmlHelper = new UmlHelperMDRImpl(this);

         }

         return theUmlHelper;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getUseCasesFactory()

      */

     public UseCasesFactory getUseCasesFactory() {

         return theUseCasesFactory;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getUseCasesHelper()

      */

     public UseCasesHelper getUseCasesHelper() {

         return theUseCasesHelper;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getMetaTypes()

      */

     public MetaTypes getMetaTypes() {

         return theMetaTypes;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getChangeableKind()

      */

     public ChangeableKind getChangeableKind() {

         return theKindsObject;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getAggregationKind()

      */

     public AggregationKind getAggregationKind() {

         return theKindsObject;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getPseudostateKind()

      */

     public PseudostateKind getPseudostateKind() {

         return theKindsObject;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getScopeKind()

      */

     public ScopeKind getScopeKind() {

         return theKindsObject;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getConcurrencyKind()

      */

     public ConcurrencyKind getConcurrencyKind() {

         return theKindsObject;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getDirectionKind()

      */

     public DirectionKind getDirectionKind() {

         return theKindsObject;

     }

     /*

      * @see org.argouml.model.ModelImplementation#getOrderingKind()

      */

     public OrderingKind getOrderingKind() {

         return theKindsObject;

     }

     public VisibilityKind getVisibilityKind() {

         return theKindsObject;

     }

     public XmiReader getXmiReader() throws UmlException {

         XmiReader reader = new XmiReaderImpl(this);

         return reader;

     }

     public XmiWriter getXmiWriter(Object model, OutputStream stream,

             String version) throws UmlException {

         return new XmiWriterMDRImpl(this, model, stream, version);

     }

     /**

      * Return map of MOF ID to XmiReference (system id + xmi.id).

      *

      * @return the map

      */

     Map<String, XmiReference> getObjectToId() {

         return objectToId;

     }

     /**

      * Return map of maps keyed first by system id, then xmi.id with object as

      * value.

      * 

      * @return the map

      */

     Map<String, Map<String, Object>> getIdToObject() {

         return idToObject;

     }

     /**

      * Remove an element from indexes mapping it back to its original xmi.id.

      * 

      * @param mofId MOF ID of element to be removed from indexes

      * @return false if no index entries were removed

      */

     boolean removeElement(String mofId) {

         XmiReference xref = objectToId.remove(mofId);

         if (xref != null) {

             Map<String,Object> m = idToObject.get(xref.getSystemId());

             if (m != null) {

                 Object o = m.remove(xref.getXmiId());

                 if (o != null) {

                     if (!mofId.equals(((RefObject) o).refMofId())) {

                         LOG.error("Internal index inconsistency for mof ID " 

                                 + mofId + " (got " + ((RefObject) o).refMofId());

                     }

                     return true;

                 }

             }

         }

         // Elements created after file load won't have index entries

         LOG.debug("Failed to remove index entries for mof ID " + mofId);

         return false;

     }

     /**

      * Return map of MOF ID to XmiReference (system id + xmi.id).

      *

      * @return the map

      */

     Map<String, String> getPublic2SystemIds() {

         return public2SystemIds;

     }

     void addSearchPath(String path) {

         searchDirs.add(path);

     }

     void removeSearchPath(String path) {

         searchDirs.remove(path);

     }

     List<String> getSearchPath() {

         return searchDirs;

     }

 }