org.nuiton.eugene.models.object.ObjectModelBuilder Maven / Gradle / Ivy
/*
* #%L
* EUGene :: EUGene
*
* $Id: ObjectModelBuilder.java 1014 2010-11-28 20:13:58Z tchemit $
* $HeadURL: http://svn.nuiton.org/svn/eugene/tags/eugene-2.3.3/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelBuilder.java $
* %%
* Copyright (C) 2004 - 2010 CodeLutin
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Lesser Public License for more details.
*
* You should have received a copy of the GNU General Lesser Public
* License along with this program. If not, see
* .
* #L%
*/
package org.nuiton.eugene.models.object;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.nuiton.eugene.models.object.xml.ObjectModeImplAssociationClassParticipant;
import org.nuiton.eugene.models.object.xml.ObjectModelAssociationClassImpl;
import org.nuiton.eugene.models.object.xml.ObjectModelAttributeImpl;
import org.nuiton.eugene.models.object.xml.ObjectModelClassImpl;
import org.nuiton.eugene.models.object.xml.ObjectModelClassifierImpl;
import org.nuiton.eugene.models.object.xml.ObjectModelElementImpl;
import org.nuiton.eugene.models.object.xml.ObjectModelEnumerationImpl;
import org.nuiton.eugene.models.object.xml.ObjectModelImpl;
import org.nuiton.eugene.models.object.xml.ObjectModelImplRef;
import org.nuiton.eugene.models.object.xml.ObjectModelImplSuperClassRef;
import org.nuiton.eugene.models.object.xml.ObjectModelImplTagValue;
import org.nuiton.eugene.models.object.xml.ObjectModelInterfaceImpl;
import org.nuiton.eugene.models.object.xml.ObjectModelOperationImpl;
import org.nuiton.eugene.models.object.xml.ObjectModelParameterImpl;
/**
* Builder to fill an empty ObjectModel. The object model name is important if
* you want to use the model in generators.
*
* Created: 3 nov. 2009
*
* @author fdesbois
* @version $Id: ObjectModelBuilder.java 1014 2010-11-28 20:13:58Z tchemit $
*/
public class ObjectModelBuilder {
private static final Log log = LogFactory.getLog(ObjectModelBuilder.class);
protected ObjectModelImpl model;
/**
* Constructor. Must have a name for the new model created.
*
* @param name model name
*/
public ObjectModelBuilder(String name) {
model = new ObjectModelImpl();
model.setName(name);
}
/**
* Get the building model
*
* @return the ObjectModel which is currently built
*/
public ObjectModel getModel() {
return model;
}
/**
* Add a tagValue to the model.
*
* @param name tagValue name
* @param value tagValue value
*/
public void addTagValue(String name, String value) {
ObjectModelImplTagValue tagValue = new ObjectModelImplTagValue();
tagValue.setName(name);
tagValue.setValue(value);
model.addTagValue(tagValue);
}
/**
* Add a tagValue to an element
*
* @param element where the tag value will be added
* @param name tagValue name
* @param value tagValue value
*/
public void addTagValue(ObjectModelElement element,
String name,
String value) {
ObjectModelElementImpl impl = (ObjectModelElementImpl) element;
ObjectModelImplTagValue tagValue = new ObjectModelImplTagValue();
tagValue.setName(name);
tagValue.setValue(value);
impl.addTagValue(tagValue);
}
/**
* Create a new class in the model.
* Modifiers allowed : ABSTRACT, STATIC.
*
* @param name class name
* @param packageName class package
* @param modifiers class modifiers
* @return the new ObjectModelClass added to the model
*/
public ObjectModelClass createClass(String name,
String packageName,
ObjectModelModifier... modifiers) {
ObjectModelClassImpl result = new ObjectModelClassImpl();
return createClass(result, name, packageName, modifiers);
}
protected ObjectModelClass createClass(ObjectModelClassImpl clazz,
String name,
String packageName,
ObjectModelModifier... modifiers)
throws IllegalArgumentException {
clazz.setName(name);
clazz.setPackage(packageName);
setClassModifiers(clazz, modifiers);
model.addClass(clazz);
return clazz;
}
/**
* Set modifiers to a class. Only STATIC and ABSTRACT are actually supported.
*
* @param clazz ObjectModelClassImpl where modifiers will be set
* @param modifiers Array of ObjectModelModifier to set
* @throws IllegalArgumentException for unsupported modifier
*/
protected void setClassModifiers(ObjectModelClassImpl clazz,
ObjectModelModifier... modifiers)
throws IllegalArgumentException {
for (ObjectModelModifier modifier : modifiers) {
switch (modifier) {
case ABSTRACT:
clazz.setAbstract(true);
break;
case STATIC:
clazz.setStatic(true);
break;
default:
throw new IllegalArgumentException(
"Unsupported modifier type '" + modifier.name() + "'");
}
}
}
/**
* Create a new interface in the model.
*
* @param name interface name
* @param packageName interface package
* @return the new ObjectModelInterface added to the model
*/
public ObjectModelInterface createInterface(String name,
String packageName) {
ObjectModelInterfaceImpl result = new ObjectModelInterfaceImpl();
result.setName(name);
result.setPackage(packageName);
model.addInterface(result);
return result;
}
/**
* Create a new interface in the model.
*
* @param name interface name
* @param packageName interface package
* @return the new ObjectModelInterface added to the model
*/
public ObjectModelEnumeration createEnumeration(String name,
String packageName) {
ObjectModelEnumerationImpl result = new ObjectModelEnumerationImpl();
result.setName(name);
result.setPackage(packageName);
model.addEnumeration(result);
return result;
}
/**
* Add an attribute to a classifier (interface, class, enum) without default value.
* Default visibility is set to PUBLIC.
*
* @param classifier where the attribute will be added
* @param name attribute name
* @param type attribute type (full qualified name)
* @return the new ObjectModelAttribute added
*/
public ObjectModelAttribute addAttribute(ObjectModelClassifier classifier,
String name,
String type) {
return addAttribute(classifier, name, type, "");
}
/**
* Add an attribute to a classifier (interface, class, enum).
* Modifiers allowed : STATIC, FINAL, PUBLIC, PRIVATE, PROTECTED, PACKAGE, ORDERED, UNIQUE.
* The last visibility set will be keeped.
*
* @param classifier where the attribute will be added
* @param name attribute name
* @param type attribute type (full qualified name)
* @param value default value for the attribute
* @param modifiers attribute modifiers
* @return the new ObjectModelAttribute added
* @throws IllegalArgumentException illegal Modifier
* @see ObjectModelModifier#isVisibility()
*/
public ObjectModelAttribute addAttribute(ObjectModelClassifier classifier,
String name,
String type,
String value,
ObjectModelModifier... modifiers)
throws IllegalArgumentException {
ObjectModelAttributeImpl attribute = new ObjectModelAttributeImpl();
attribute.setName(name);
attribute.setType(type);
attribute.setDefaultValue(value);
for (ObjectModelModifier modifier : modifiers) {
if (modifier.isVisibility()) {
attribute.setVisibility(modifier.toString());
} else {
switch (modifier) {
case STATIC:
attribute.setStatic(true);
break;
case FINAL:
attribute.setFinal(true);
break;
case ORDERED:
attribute.setOrdering(modifier.toString());
break;
case UNIQUE:
attribute.setUnique(true);
break;
default:
throw new IllegalArgumentException(
"Unsupported modifier type '" + modifier.name() + "'");
}
}
}
ObjectModelClassifierImpl classifierImpl = (ObjectModelClassifierImpl) classifier;
classifierImpl.addAttribute(attribute);
return attribute;
}
/**
* Add an association A to B. Create only attribute association for classifierA.
* MODIFIERS allowed : PUBLIC, PRIVATE, PACKAGE, PROTECTED, AGGREGATE, COMPOSITE, ORDERED, UNIQUE
* STATIC, NAVIGABLE.
* You have to use method {@link #addReverseAssociation(ObjectModelAttribute, String, int, int, ObjectModelModifier...)}
* to create attribute association for classifierB.
*
* @param classifierA classifier from
* @param classifierB classifier to
* @param roleName role of A in association
* @param minMultiplicity minimum multiplicity of A in association
* @param maxMultiplicity maximum multiplicity of A in association
* @param modifiers for the association
* @return the attribute corresponding to the association for classifierA
* @throws IllegalArgumentException illegal modifier
*/
public ObjectModelAttribute addAssociation(ObjectModelClassifier classifierA,
ObjectModelClassifier classifierB,
String roleName,
int minMultiplicity,
int maxMultiplicity,
ObjectModelModifier... modifiers)
throws IllegalArgumentException {
ObjectModelAttributeImpl attribute = new ObjectModelAttributeImpl();
attribute.setName(roleName);
attribute.setMinMultiplicity(minMultiplicity);
attribute.setMaxMultiplicity(maxMultiplicity);
attribute.setType(classifierB.getQualifiedName());
for (ObjectModelModifier modifier : modifiers) {
if (modifier.isVisibility()) {
attribute.setVisibility(modifier.toString());
} else if (modifier.isAssociationType()) {
attribute.setAssociationType(modifier.toString());
} else {
switch (modifier) {
case ORDERED:
attribute.setOrdering(modifier.toString());
break;
case UNIQUE:
attribute.setUnique(true);
break;
case STATIC:
attribute.setStatic(true);
break;
case NAVIGABLE:
attribute.setNavigable(true);
break;
default:
throw new IllegalArgumentException(
"Unsupported modifier type '" + modifier.name() + "'");
}
}
}
ObjectModelClassifierImpl impl = (ObjectModelClassifierImpl) classifierA;
impl.addAttribute(attribute);
return attribute;
}
/**
* Create reverse association from an other association.
* MODIFIERS allowed : PUBLIC, PRIVATE, PACKAGE, PROTECTED, AGGREGATE, COMPOSITE, ORDERED, UNIQUE
* STATIC, NAVIGABLE.
*
* @param attrAssociation other association A to B
* @param roleName role of B in association
* @param minMultiplicity minimum multiplicity of B in association
* @param maxMultiplicity maximum multiplicity of B in association
* @param modifiers for the association
* @return the attribute corresponding to the association for classifierB
* @see #addAssociation(ObjectModelClassifier, ObjectModelClassifier, String, int, int, ObjectModelModifier...)
*/
public ObjectModelAttribute addReverseAssociation(ObjectModelAttribute attrAssociation,
String roleName,
int minMultiplicity,
int maxMultiplicity,
ObjectModelModifier... modifiers) {
ObjectModelAttributeImpl associationA = (ObjectModelAttributeImpl) attrAssociation;
// Add reverse parameters
associationA.setReverseAttributeName(roleName);
associationA.setReverseMaxMultiplicity(maxMultiplicity);
ObjectModelClassifierImpl classifierA =
(ObjectModelClassifierImpl) associationA.getDeclaringElement();
String typeB = associationA.getType();
// Get classifierB from model
ObjectModelClassifierImpl classifierB = (ObjectModelClassifierImpl) model.getClassifier(typeB);
// Create reverse association
ObjectModelAttributeImpl associationB =
(ObjectModelAttributeImpl) addAssociation(classifierB,
classifierA,
roleName,
minMultiplicity,
maxMultiplicity,
modifiers);
associationB.setReverseAttributeName(associationA.getName());
associationB.setReverseMaxMultiplicity(associationA.getMaxMultiplicity());
return associationB;
}
/**
* Create association class. The two extremities of the association must be existing before creating
* the association class.
* Modifiers allowed : ABSTRACT, STATIC.
*
* @param name association class name
* @param packageName association package name
* @param attrAssociationA attribute association for classifierA involved in association class
* @param attrAssociationB attribute association for classifierB involved in association class
* @param modifiers for the association class
* @return the new association class created with participants A and B
*/
public ObjectModelAssociationClass createAssociationClass(String name,
String packageName,
ObjectModelAttribute attrAssociationA,
ObjectModelAttribute attrAssociationB,
ObjectModelModifier... modifiers) {
ObjectModelAssociationClassImpl associationClass = new ObjectModelAssociationClassImpl();
createClass(associationClass, name, packageName, modifiers);
// Add associationClass in attrAssociationA
ObjectModelAttributeImpl attrA =
(ObjectModelAttributeImpl) attrAssociationA;
attrA.setAssociationClassName(associationClass.getQualifiedName());
// Add associationClass in attrAssociationB
ObjectModelAttributeImpl attrB =
(ObjectModelAttributeImpl) attrAssociationB;
attrB.setAssociationClassName(associationClass.getQualifiedName());
// Create participantA
ObjectModeImplAssociationClassParticipant participantA =
new ObjectModeImplAssociationClassParticipant();
participantA.setAttribute(attrA.getName());
ObjectModelClassifier classifierA =
(ObjectModelClassifier) attrA.getDeclaringElement();
participantA.setName(classifierA.getQualifiedName());
associationClass.addParticipant(participantA);
// Create participantB
ObjectModeImplAssociationClassParticipant participantB =
new ObjectModeImplAssociationClassParticipant();
participantB.setAttribute(attrB.getName());
ObjectModelClassifier classifierB =
(ObjectModelClassifier) attrB.getDeclaringElement();
participantB.setName(classifierB.getQualifiedName());
associationClass.addParticipant(participantB);
return associationClass;
}
/**
* Add an operation to a classifier.
* Modifiers allowed : STATIC, ABSTRACT, PUBLIC, PRIVATE, PROTECTED, PACKAGE.
* The last visibility set will be keeped.
*
* @param classifier where the operation will be added
* @param name operation name
* @param returnType operation type (full qualified name)
* @param modifiers operation modifiers
* @return the new ObjectModelOperation added
* @throws IllegalArgumentException illegal Modifier
*/
public ObjectModelOperation addOperation(ObjectModelClassifier classifier,
String name,
String returnType,
ObjectModelModifier... modifiers)
throws IllegalArgumentException {
ObjectModelOperationImpl result = new ObjectModelOperationImpl();
result.setName(name);
if (returnType != null) {
ObjectModelParameterImpl returnParameter =
new ObjectModelParameterImpl();
returnParameter.setType(returnType);
result.setReturnParameter(returnParameter);
}
for (ObjectModelModifier modifier : modifiers) {
if (modifier.isVisibility()) {
result.setVisibility(modifier.toString());
} else {
switch (modifier) {
case STATIC:
result.setStatic(true);
break;
case ABSTRACT:
result.setAbstract(true);
break;
default:
throw new IllegalArgumentException("Unsupported modifier type '" + modifier.name() + "'");
}
}
}
((ObjectModelClassifierImpl) classifier).addOperation(result);
return result;
}
/**
* Add an operation to a classifier.
* Modifiers allowed : STATIC, ABSTRACT, PUBLIC, PRIVATE, PROTECTED, PACKAGE.
* The last visibility set will be keeped.
*
* @param classifier where the operation will be added
* @param operation operation to add
* @return the added operation (says the given parameter)
* @since 2.1.2
*/
public ObjectModelOperation addOperation(ObjectModelClassifier classifier,
ObjectModelOperation operation) {
((ObjectModelClassifierImpl) classifier).addOperation(
(ObjectModelOperationImpl) operation);
return operation;
}
/**
* Set the body code for an Operation.
*
* @param operation where the code will be added
* @param body code to add to the operation
*/
public void setOperationBody(ObjectModelOperation operation, String body) {
ObjectModelOperationImpl operationImpl =
(ObjectModelOperationImpl) operation;
operationImpl.setBodyCode(body);
}
/**
* Add an interface to a classifier. The interface may not exist in model.
*
* @param classifier where the interface will be added
* @param interfaceQualifiedName interface qualified name
*/
public void addInterface(ObjectModelClassifier classifier,
String interfaceQualifiedName) {
ObjectModelClassifierImpl impl = (ObjectModelClassifierImpl) classifier;
ObjectModelImplRef interfacez = new ObjectModelImplRef();
interfacez.setName(interfaceQualifiedName);
impl.addInterface(interfacez);
}
/**
* Add a superclass to an other class. The superclass may not exist in model.
*
* @param clazz where the superclass will be added
* @param superclassQualifiedName superclass qualified name
*/
public void addSuperclass(ObjectModelClass clazz,
String superclassQualifiedName) {
ObjectModelClassImpl impl = (ObjectModelClassImpl) clazz;
ObjectModelImplSuperClassRef superclass =
new ObjectModelImplSuperClassRef();
superclass.setName(superclassQualifiedName);
impl.addSuperclass(superclass);
}
/**
* Add a superclass to an other class. The superclass may not exist in model.
*
* @param clazz where the superclass will be added
* @param type type of inner classifier to create
* @param name superclass qualified name
* @param modifiers modifiers of the inner classifier
* @return the new instanciated inner classifier
* @throws IllegalArgumentException if given {@code type} is not a concrete classifier type
*/
public ObjectModelClassifier addInnerClassifier(ObjectModelClass clazz,
ObjectModelType type,
String name,
ObjectModelModifier... modifiers)
throws IllegalArgumentException {
ObjectModelClassImpl impl = (ObjectModelClassImpl) clazz;
ObjectModelClassifierImpl inner;
switch (type) {
case OBJECT_MODEL_ENUMERATION:
inner = new ObjectModelEnumerationImpl();
break;
case OBJECT_MODEL_CLASS:
inner = new ObjectModelClassImpl();
setClassModifiers((ObjectModelClassImpl) inner, modifiers);
break;
case OBJECT_MODEL_INTERFACE:
inner = new ObjectModelInterfaceImpl();
break;
default:
throw new IllegalArgumentException("can not add a none classifier type " + type);
}
inner.setName(name);
inner.setPackage(clazz.getPackageName() + "." + clazz.getName());
inner.postInit();
impl.addInnerClassifier(inner);
inner.setObjectModelImpl(impl.getModel());
if (log.isDebugEnabled()) {
log.debug("Add inner classifier for " + clazz.getQualifiedName() +
" : " + inner.getQualifiedName());
}
return inner;
}
/**
* Add a parameter to an operation.
*
* @param operation where the parameter will be added
* @param type paremeter type (full qualified name)
* @param name parameter name
* @return the new ObjectModelParameter added
*/
public ObjectModelParameter addParameter(ObjectModelOperation operation,
String type,
String name) {
ObjectModelOperationImpl impl = (ObjectModelOperationImpl) operation;
ObjectModelParameterImpl param = new ObjectModelParameterImpl();
param.setType(type);
param.setName(name);
impl.addParameter(param);
return param;
}
/**
* Add an exception to an operation.
*
* @param operation where the exception will be added
* @param exception name of the exception (full qualified name)
*/
public void addException(ObjectModelOperation operation, String exception) {
ObjectModelOperationImpl impl = (ObjectModelOperationImpl) operation;
ObjectModelParameterImpl param = new ObjectModelParameterImpl();
param.setType(exception);
impl.addExceptionParameter(param);
}
/**
* Set the documentation of an element in the model.
*
* @param element where the documentation will be setted
* @param documentation String documentation for the element
*/
public void setDocumentation(ObjectModelElement element,
String documentation) {
ObjectModelElementImpl impl = (ObjectModelElementImpl) element;
impl.setDocumentation(documentation);
}
/**
* Add a stereotype to an element.
*
* @param element where the stereotype will be added
* @param stereotype name
*/
public void addStereotype(ObjectModelElement element, String stereotype) {
ObjectModelElementImpl impl = (ObjectModelElementImpl) element;
ObjectModelImplRef ref = new ObjectModelImplRef();
ref.setName(stereotype);
impl.addStereotype(ref);
}
public void addLiteral(ObjectModelEnumeration enumz, String name) {
ObjectModelEnumerationImpl impl = (ObjectModelEnumerationImpl) enumz;
ObjectModelImplRef ref = new ObjectModelImplRef();
ref.setName(name);
impl.addLiteral(ref);
}
/**
* Add a comment to an element.
*
* @param element where the comment will be added
* @param comment comment to add
* @since 2.1.2
*/
public void addComment(ObjectModelElement element, String comment) {
ObjectModelElementImpl impl = (ObjectModelElementImpl) element;
impl.addComment(comment);
}
/**
* Set the min multiplicity of an attribute in the model.
*
* @param attribute where the multiplicity will be setted
* @param multiplicity String description for the element
*/
public void setMinMultiplicity(ObjectModelAttribute attribute,
int multiplicity) {
ObjectModelAttributeImpl impl = (ObjectModelAttributeImpl) attribute;
impl.setMinMultiplicity(multiplicity);
}
/**
* Set the max multiplicity of an attribute in the model.
*
* @param attribute where the multiplicity will be setted
* @param multiplicity String description for the element
*/
public void setMaxMultiplicity(ObjectModelAttribute attribute,
int multiplicity) {
ObjectModelAttributeImpl impl = (ObjectModelAttributeImpl) attribute;
impl.setMaxMultiplicity(multiplicity);
}
/**
* Set the navigable flag of an attribute in the model.
*
* @param attribute where the navigable flag will be setted
* @param navigable navigable flag value to set
* @since 2.3
*/
public void setNavigable(ObjectModelAttribute attribute,
boolean navigable) {
ObjectModelAttributeImpl impl = (ObjectModelAttributeImpl) attribute;
impl.setNavigable(navigable);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy