/* $Id: DataTypesFactoryMDRImpl.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.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;
import org.apache.log4j.Logger;
import org.argouml.model.DataTypesFactory;
import org.omg.uml.foundation.datatypes.ActionExpression;
import org.omg.uml.foundation.datatypes.ArgListsExpression;
import org.omg.uml.foundation.datatypes.BooleanExpression;
import org.omg.uml.foundation.datatypes.Expression;
import org.omg.uml.foundation.datatypes.IterationExpression;
import org.omg.uml.foundation.datatypes.MappingExpression;
import org.omg.uml.foundation.datatypes.Multiplicity;
import org.omg.uml.foundation.datatypes.MultiplicityRange;
import org.omg.uml.foundation.datatypes.ObjectSetExpression;
import org.omg.uml.foundation.datatypes.ProcedureExpression;
import org.omg.uml.foundation.datatypes.TimeExpression;
import org.omg.uml.foundation.datatypes.TypeExpression;
/**
* Factory to create UML classes for the UML DataTypes package.
* <p>
* @since ARGO0.19.5
* @author Ludovic Maître
* @author Tom Morris
* derived from NSUML implementation by:
* @author Thierry Lach
*/
class DataTypesFactoryMDRImpl extends AbstractUmlModelFactoryMDR
implements DataTypesFactory {
private static final Logger LOG =
Logger.getLogger(DataTypesFactoryMDRImpl.class);
/**
* The model implementation.
*/
private MDRModelImplementation modelImpl;
/**
* Constructor.
*
* @param implementation
* To get other helpers and factories.
*/
DataTypesFactoryMDRImpl(MDRModelImplementation implementation) {
this.modelImpl = implementation;
}
public ActionExpression createActionExpression(String language, String body) {
ActionExpression myActionExpression = modelImpl.getUmlPackage()
.getDataTypes().getActionExpression()
.createActionExpression(language, body);
super.initialize(myActionExpression);
return myActionExpression;
}
public ArgListsExpression createArgListsExpression(String language, String body) {
ArgListsExpression myArgListsExpression = modelImpl.getUmlPackage()
.getDataTypes().getArgListsExpression()
.createArgListsExpression(language, body);
super.initialize(myArgListsExpression);
return myArgListsExpression;
}
public BooleanExpression createBooleanExpression(String language, String body) {
BooleanExpression myBooleanExpression = modelImpl.getUmlPackage()
.getDataTypes().getBooleanExpression()
.createBooleanExpression(language, body);
super.initialize(myBooleanExpression);
return myBooleanExpression;
}
public Expression createExpression(String language, String body) {
Expression myExpression = modelImpl.getUmlPackage().getDataTypes()
.getExpression().createExpression(language, body);
super.initialize(myExpression);
return myExpression;
}
public IterationExpression createIterationExpression(String language, String body) {
IterationExpression myIterationExpression = modelImpl.getUmlPackage()
.getDataTypes().getIterationExpression()
.createIterationExpression(language, body);
super.initialize(myIterationExpression);
return myIterationExpression;
}
public MappingExpression createMappingExpression(String language, String body) {
MappingExpression myMappingExpression = modelImpl.getUmlPackage()
.getDataTypes().getMappingExpression().createMappingExpression(
language, body);
super.initialize(myMappingExpression);
return myMappingExpression;
}
public ObjectSetExpression createObjectSetExpression(String language, String body) {
ObjectSetExpression myObjectSetExpression = modelImpl.getUmlPackage()
.getDataTypes().getObjectSetExpression()
.createObjectSetExpression(language, body);
super.initialize(myObjectSetExpression);
return myObjectSetExpression;
}
public ProcedureExpression createProcedureExpression(String language, String body) {
ProcedureExpression myProcedureExpression = modelImpl.getUmlPackage()
.getDataTypes().getProcedureExpression()
.createProcedureExpression(language, body);
super.initialize(myProcedureExpression);
return myProcedureExpression;
}
public TimeExpression createTimeExpression(String language, String body) {
TimeExpression myTimeExpression = modelImpl.getUmlPackage()
.getDataTypes().getTimeExpression()
.createTimeExpression(language, body);
super.initialize(myTimeExpression);
return myTimeExpression;
}
public TypeExpression createTypeExpression(String language, String body) {
TypeExpression myTypeExpression = modelImpl.getUmlPackage()
.getDataTypes().getTypeExpression()
.createTypeExpression(language, body);
super.initialize(myTypeExpression);
return myTypeExpression;
}
@Deprecated
public Multiplicity createMultiplicity(int lower, int upper) {
return createMultiplicityInternal(lower, upper);
}
Multiplicity createMultiplicityInternal(int lower, int upper) {
Multiplicity multiplicity = modelImpl.getUmlPackage().getDataTypes()
.getMultiplicity().createMultiplicity();
if (LOG.isDebugEnabled()) {
LOG.debug("Multiplicity created for range " + lower + ".." + upper);
}
multiplicity.getRange().add(createMultiplicityRange(lower, upper));
super.initialize(multiplicity);
return multiplicity;
}
/*
* TODO: As currently implemented, this expects a list of
* MultiplicityRanges. Is this an interface change from the NSUML
* implementation? I suspect it used to accept a list of Integers. - tfm
*
* @see org.argouml.model.DataTypesFactory#createMultiplicity(java.util.List)
*/
@Deprecated
public Multiplicity createMultiplicity(final List range) {
return createMultiplicityInternal(range);
}
Multiplicity createMultiplicityInternal(final List<MultiplicityRange> range) {
Multiplicity multiplicity = modelImpl.getUmlPackage().getDataTypes()
.getMultiplicity().createMultiplicity();
if (LOG.isDebugEnabled()) {
LOG.debug("Multiplicity created for list " + range);
}
multiplicity.getRange().addAll(range);
super.initialize(multiplicity);
return multiplicity;
}
@Deprecated
public Multiplicity createMultiplicity(final String str) {
return createMultiplicityInternal(str);
}
Multiplicity createMultiplicityInternal(final String str) {
List<MultiplicityRange> ranges =
Collections.unmodifiableList(parseRanges(str));
return createMultiplicity(ranges);
}
private List<MultiplicityRange> parseRanges(String str) {
List<MultiplicityRange> rc = new ArrayList<MultiplicityRange>();
// Return 1..1 multiplicity for empty string
if ("".equals(str)) {
rc.add(createMultiplicityRange("1..1"));
return rc;
}
StringTokenizer stk = new StringTokenizer(str, ",");
while (stk.hasMoreTokens()) {
rc.add(createMultiplicityRange(stk.nextToken()));
}
if (rc.size() > 1) {
LOG.debug("UML 2.x does not support multiple multiplicity ranges. "
+ str);
}
return rc;
}
@Deprecated
public MultiplicityRange createMultiplicityRange(String str) {
StringTokenizer stk = new StringTokenizer(str, ". ");
if (!stk.hasMoreTokens()) {
throw new IllegalArgumentException("empty multiplicity range");
}
int lower = stringToBound(stk.nextToken());
int upper = 0;
if (!stk.hasMoreTokens()) {
upper = lower;
// Convert "*" to "0..*" instead of "*..*"
if (lower == -1) {
lower = 0;
}
} else {
upper = stringToBound(stk.nextToken());
if (stk.hasMoreTokens()) {
throw new IllegalArgumentException(
"illegal range specification");
}
}
return createMultiplicityRange(lower, upper);
}
@Deprecated
public MultiplicityRange createMultiplicityRange(final int lower,
final int upper) {
MultiplicityRange range =
modelImpl.getUmlPackage().getDataTypes().getMultiplicityRange()
.createMultiplicityRange(lower, upper);
return range;
}
/**
* Convert an integer to a string using MultiplicityRange notation.
*
* @param i integer to convert
* @return String version of integer or "*" for unlimited (-1)
*/
static String boundToString(int i) {
if (i == -1) {
return "*";
} else {
return "" + i;
}
}
/**
* Convert a MultiplicityRange bound string to an integer.
*
* @param b String containing a single MultiplicityRange bound
* @return integer representation
*/
private static int stringToBound(String b) {
try {
if (b.equals("n") || b.equals("*")) {
return -1;
} else {
return Integer.parseInt(b);
}
} catch (Exception ex) {
throw new IllegalArgumentException("illegal range bound : "
+ (b == null ? "null" : b));
}
}
}