/* $Id: ExtensionMechanismsFactoryMDRImpl.java 18760 2010-09-18 05:19:53Z 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:

  *    Tom Morris

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

  *

  * Some portions of this file was previously release 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.Collection;

 import java.util.Iterator;

 import org.argouml.model.CoreHelper;

 import org.argouml.model.ExtensionMechanismsFactory;

 import org.argouml.model.ExtensionMechanismsHelper;

 import org.omg.uml.foundation.core.ModelElement;

 import org.omg.uml.foundation.core.Namespace;

 import org.omg.uml.foundation.core.Stereotype;

 import org.omg.uml.foundation.core.TagDefinition;

 import org.omg.uml.foundation.core.TaggedValue;

 import org.omg.uml.foundation.datatypes.Multiplicity;

 /**

  * Factory to create UML classes for the UML ExtensionMechanisms

  * package.<p>

  * 

  * @since ARGO0.19.5

  * @author Ludovic Maître

  * @author Tom Morris

  * <p>

  * derived from NSUML implementation by:

  * @author Thierry Lach

  */

 class ExtensionMechanismsFactoryMDRImpl extends

         AbstractUmlModelFactoryMDR implements ExtensionMechanismsFactory {

     /**

      * The model implementation.

      */

     private MDRModelImplementation modelImpl;

     /**

      * The extension mechanism helper.

      */

     private ExtensionMechanismsHelper extensionHelper;

     /**

      * Don't allow instantiation.

      * 

      * @param implementation

      *            To get other helpers and factories.

      */

     ExtensionMechanismsFactoryMDRImpl(MDRModelImplementation implementation) {

         modelImpl = implementation;

         extensionHelper = implementation.getExtensionMechanismsHelper();

     }

     /*

      * @see org.argouml.model.ExtensionMechanismsFactory#createTaggedValue()

      */

     public TaggedValue createTaggedValue() {

         TaggedValue tv = modelImpl.getUmlPackage().getCore().getTaggedValue().

                 createTaggedValue();

         super.initialize(tv);

         return tv;

     }

     /**

      * Get an instance of a UML TagDefinition.

      * 

      * @param tagName The name of the TagDefinition to create/retrieve

      * @return an initialized UML TaggedValue instance.

      */

     TagDefinition getTagDefinition(String tagName) {

         if (tagName == null) {

             throw new IllegalArgumentException("Argument may not be null");

         }

         // Look for a TagDefinition matching the given name

         for (Iterator i = modelImpl.getUmlPackage().getCore().getTagDefinition()

                 .refAllOfClass().iterator(); i.hasNext();) {

             TagDefinition td = (TagDefinition) i.next();

             if (tagName.equals(td.getName())) {

                 return td;

             }

         }

         // Create a new TagDefinition if none found

         Object rootModel = modelImpl.getModelManagementFactory().getRootModel();

         TagDefinition td = buildTagDefinition(tagName, null, rootModel);

         super.initialize(td);

         return td;

     }

     /*

      * TODO: MVW: This needs rethinking/rework! I have the following questions:

      * Why does it not search for a stereotype in the namespace using properties

      * and only create a new stereotype if it will actually be used? Ie, why is

      * there not a getStereotype(String name, String baseClass)? (edited by

      * d00mst)  <these comments imported from NSUML implementation - tfm>

      * 

      * @see org.argouml.model.ExtensionMechanismsFactory#buildStereotype(java.lang.Object, java.lang.Object, java.lang.Object)

      */

     public Stereotype buildStereotype(

             Object theModelElementObject,

             Object theName,

             Object theNamespaceObject) {

         if (theModelElementObject == null || theName == null

                 || theNamespaceObject == null) {

             throw new IllegalArgumentException(

                     "one of the arguments is null: modelElement="

                     + theModelElementObject

                     + " name=" + theName

                     + " namespace=" + theNamespaceObject);

         }

         ModelElement me = (ModelElement) theModelElementObject;

         String text = (String) theName;

         Namespace ns = (Namespace) theNamespaceObject;

         Stereotype stereo = buildStereotype(text);

         stereo.getBaseClass().add(modelImpl.getMetaTypes().getName(me));

         // TODO: this doesn't look right - review - tfm

         Stereotype stereo2 = (Stereotype) extensionHelper.getStereotype(ns,

                 stereo);

         if (stereo2 != null) {

             me.getStereotype().add(stereo2);

             modelImpl.getUmlFactory().delete(stereo);

             return stereo2;

         }

         stereo.setNamespace(ns);

         me.getStereotype().add(stereo);

         return stereo;

     }

     public Stereotype buildStereotype(

             Object theModelElementObject,

             String theName,

             Object model,

             Collection models) {

         ModelElement me = (ModelElement) theModelElementObject;

         Stereotype stereo = buildStereotype(theName);

         stereo.getBaseClass().add(modelImpl.getMetaTypes().getName(me));

         Stereotype stereo2 = (Stereotype) extensionHelper.getStereotype(models,

                 stereo);

         if (stereo2 != null) {

             me.getStereotype().add(stereo2);

             modelImpl.getUmlFactory().delete(stereo);

             return stereo2;

         }

         stereo.setNamespace((org.omg.uml.modelmanagement.Model) model);

         if (me != null) {

             me.getStereotype().add(stereo);

         }

         return stereo;

     }

     /*

      * Builds an initialized stereotype with no namespace. A stereotype must

      * have a namespace so this method is unsafe. Use buildStereotype(String,

      * Object).

      * 

      * @param text

      *            is the name of the stereotype

      * @return an initialized stereotype.

      */

     private Stereotype buildStereotype(String text) {

         Stereotype stereotype = modelImpl.getUmlPackage().getCore().

                 getStereotype().createStereotype();

         super.initialize(stereotype);

         stereotype.setName(text);

         return stereotype;

     }

     public Stereotype buildStereotype(String text, Object namespace) {

         if (!(namespace instanceof Namespace)) {

             throw new IllegalArgumentException(

                     "Namespace is wrong type - text:" + text + ",ns:"

                             + namespace);

         }

         Namespace ns = (Namespace) namespace;

         org.omg.uml.UmlPackage umlPkg = ((org.omg.uml.UmlPackage) ns

                 .refOutermostPackage());

         Stereotype stereotype = umlPkg.getCore().getStereotype()

                 .createStereotype();

         super.initialize(stereotype);

         stereotype.setName(text);

         stereotype.setNamespace(ns);

         return stereotype;

     }

     @Deprecated

     public TaggedValue buildTaggedValue(String tag, String value) {

         TaggedValue tv = buildTaggedValue(getTagDefinition(tag));

         tv.getDataValue().add(value);

         return tv;

     }

     private TaggedValue buildTaggedValue(TagDefinition type) {

         TaggedValue tv = createTaggedValue();

         tv.setType(type);

         return tv;

     }

     public TaggedValue buildTaggedValue(Object type, String[] values) {

         if (!(type instanceof TagDefinition)) {

             throw new IllegalArgumentException(

                     "TagDefinition required, received - " + type);

         }

         TaggedValue tv = buildTaggedValue((TagDefinition) type);

         for (String value : values) {

             tv.getDataValue().add(value);

         }

         return tv;

     }

     public void copyTaggedValues(Object source, Object target) {    

         if (!(source instanceof ModelElement)

                 || !(target instanceof ModelElement)) {

             throw new IllegalArgumentException();

         }

         Iterator it = ((ModelElement) source).getTaggedValue().iterator();

         Collection taggedValues = ((ModelElement) target).getTaggedValue();

         // Clear target so that multiple copies have no effect 

         // (other than inefficiency)

         taggedValues.clear();

         while (it.hasNext()) {

             taggedValues.add(copyTaggedValue((TaggedValue) it.next()));

         }

     }

     /**

      * Copy a single TaggedValue and return the copy.

      * 

      * @param source the TaggedValue to copy

      * @return the newly cloned copy

      */

     private Object copyTaggedValue(TaggedValue source) {

         TaggedValue tv = createTaggedValue();

         tv.setType(source.getType());

         tv.getDataValue().addAll(source.getDataValue());

         tv.getReferenceValue().addAll(source.getReferenceValue());

         return tv;

     }

     /**

      * @param elem

      *            the stereotype

      */

     void deleteStereotype(Object elem) {

         if (!(elem instanceof Stereotype)) {

             throw new IllegalArgumentException();

         }

         modelImpl.getUmlHelper().deleteCollection(

                 ((Stereotype) elem).getDefinedTag());

         modelImpl.getUmlHelper().deleteCollection(

                 ((Stereotype) elem).getStereotypeConstraint());

     }

     /**

      * @param elem

      *            the taggedvalue

      */

     void deleteTaggedValue(Object elem) {

         if (!(elem instanceof TaggedValue)) {

             throw new IllegalArgumentException();

         }

     }

     /**

      * Delete a TagDefinition.

      * 

      * @param elem the element to be deleted

      */

     void deleteTagDefinition(Object elem) {

         if (!(elem instanceof TagDefinition)) {

             throw new IllegalArgumentException();

         }

         // Delete all TaggedValues with this type

         TagDefinition td = (TagDefinition) elem;

         modelImpl.getUmlHelper().deleteCollection(

                 ((org.omg.uml.UmlPackage) td.refOutermostPackage()).getCore()

                         .getATypeTypedValue().getTypedValue(td));

     }

     public Object copyStereotype(Object source, Object ns) {

         if (!(source instanceof Stereotype)) {

             throw new IllegalArgumentException("source");

         }

         if (!(ns instanceof Namespace)) {

             throw new IllegalArgumentException("namespace");

         }

         Stereotype st = buildStereotype(null, ns);

         doCopyStereotype((Stereotype) source, st);

         return st;

     }

     /*

      * Used by the copy functions. Do not call this function directly.

      * 

      * @param source

      *            The stereotype to copy from.

      * @param target

      *            The object becoming a copy.

      */

     private void doCopyStereotype(Stereotype source, Stereotype target) {

         ((CoreFactoryMDRImpl) modelImpl.getCoreFactory())

                 .doCopyGeneralizableElement(source, target);

         target.getBaseClass().clear();

         target.getBaseClass().addAll(source.getBaseClass());

         target.setIcon(source.getIcon());

         // TODO: constraints

         // TODO: required tags

     }

     public TagDefinition buildTagDefinition(String name, Object owner, 

             Object namespace) {

         return buildTagDefinition(name, owner, namespace, null); // "Element");

     }

     public TagDefinition buildTagDefinition(String name, Object owner, 

             Object ns, String tagType) {

         if (owner != null) {

             if (!(owner instanceof Stereotype)) {

                 throw new IllegalArgumentException("owner: " + owner);

             }

             if (ns != null) {

                 throw new IllegalArgumentException(

                         "only one of owner & namespace may be specified");

             }

         } else if (!(ns instanceof Namespace)) {

             throw new IllegalArgumentException("namespace: " + ns);

         }

         TagDefinition td = (TagDefinition) createTagDefinition();

         CoreHelper coreHelper = org.argouml.model.Model.getCoreHelper();

         if (owner != null) {

             coreHelper.setOwner(td, owner);

         } else {

             coreHelper.setNamespace(td, ns);

         }

         coreHelper.setName(td, name);

         coreHelper.setMultiplicity(td, 0, 1);

         td.setTagType(tagType);

         return td;

     }

     public Object createTagDefinition() {

         TagDefinition td = modelImpl.getUmlPackage().getCore()

                 .getTagDefinition().createTagDefinition();

         super.initialize(td);

         return td;

     }

     public Object createStereotype() {

         Stereotype st = modelImpl.getUmlPackage().getCore().getStereotype()

             .createStereotype();

         super.initialize(st);

         return st;

     }

     public Object copyTagDefinition(Object anElement, Object aNs) {

         if (!(anElement instanceof TagDefinition)) {

             throw new IllegalArgumentException("source: " + anElement);

         }

         if (!(aNs instanceof Namespace || aNs instanceof Stereotype)) {

             throw new IllegalArgumentException("namespace: " + aNs);

         }

         TagDefinition source = (TagDefinition) anElement;

         TagDefinition td = (TagDefinition) createTagDefinition();

         if (aNs instanceof Namespace) {

             td.setNamespace((Namespace) aNs);

         } else {

             td.setOwner((Stereotype) aNs);

         }

         doCopyTagDefinition(source, td);

         return td;

     }

     /*

      * Used by the copy functions. Do not call this function directly.

      * 

      * @param source

      *            The stereotype to copy from.

      * @param target

      *            The object becoming a copy.

      */

     private void doCopyTagDefinition(TagDefinition source, 

             TagDefinition target) {

         ((CoreFactoryMDRImpl) modelImpl.getCoreFactory())

                 .doCopyModelElement(source, target);

         target.setTagType(source.getTagType());

         String srcMult = org.argouml.model.Model.getFacade().toString(

                 source.getMultiplicity());

         target.setMultiplicity(modelImpl.getDataTypesFactoryInternal()

                 .createMultiplicityInternal(srcMult));

     }    

 }