Author: fdesbois Date: 2009-11-05 16:10:25 +0100 (Thu, 05 Nov 2009) New Revision: 694 Modified: branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelModifier.java branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelVisibility.java branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModeImplAssociationClassParticipant.java branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelAttributeImpl.java branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelBuilder.java branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelParameterImpl.java branches/eugene-2.0/eugene/src/test/java/org/nuiton/eugene/models/object/xml/ObjectModelBuilderTest.java Log: Evol #115 : - Add methods to manage tagValues, associations and stereotypes in ObjectModelBuilder Modified: branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelModifier.java =================================================================== --- branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelModifier.java 2009-11-05 10:34:15 UTC (rev 693) +++ branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelModifier.java 2009-11-05 15:10:25 UTC (rev 694) @@ -34,8 +34,10 @@ */ public enum ObjectModelModifier { - STATIC, FINAL, ABSTRACT, PUBLIC, PROTECTED, PRIVATE, PACKAGE; + STATIC, FINAL, ABSTRACT, PUBLIC, PROTECTED, PRIVATE, PACKAGE, + AGGREGATE, COMPOSITE, UNIQUE, ORDERED, NAVIGABLE; + public boolean isVisibility() { return this == PUBLIC || this == PROTECTED || @@ -43,6 +45,11 @@ this == PACKAGE; } + public boolean isAssociationType() { + return this == AGGREGATE || + this == COMPOSITE; + } + @Override public String toString() { switch (this) { @@ -53,6 +60,9 @@ case PRIVATE: return "private"; case PROTECTED: return "protected"; case PACKAGE: return ""; + case ORDERED: return "ordered"; + case AGGREGATE: return "aggregate"; + case COMPOSITE: return "composite"; } return ""; } Modified: branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelVisibility.java =================================================================== --- branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelVisibility.java 2009-11-05 10:34:15 UTC (rev 693) +++ branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/ObjectModelVisibility.java 2009-11-05 15:10:25 UTC (rev 694) @@ -29,6 +29,7 @@ * * @author fdesbois */ +@Deprecated public enum ObjectModelVisibility { PUBLIC, PROTECTED, PRIVATE, PACKAGE } Modified: branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModeImplAssociationClassParticipant.java =================================================================== --- branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModeImplAssociationClassParticipant.java 2009-11-05 10:34:15 UTC (rev 693) +++ branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModeImplAssociationClassParticipant.java 2009-11-05 15:10:25 UTC (rev 694) @@ -33,8 +33,10 @@ public class ObjectModeImplAssociationClassParticipant extends ObjectModelImplRef { + // class protected ObjectModelAssociationClassImpl associationClass = null; + // role protected String attributeName = null; public ObjectModeImplAssociationClassParticipant() { Modified: branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelAttributeImpl.java =================================================================== --- branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelAttributeImpl.java 2009-11-05 10:34:15 UTC (rev 693) +++ branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelAttributeImpl.java 2009-11-05 15:10:25 UTC (rev 694) @@ -231,6 +231,7 @@ /* * @see org.nuiton.eugene.models.object.ObjectModelAttribute#isOrdered() */ + @Override public boolean isOrdered() { return isIndexed() || super.isOrdered(); } @@ -238,6 +239,8 @@ /* * @see org.nuiton.eugene.models.object.ObjectModelAttribute#isIndexed() */ + @Deprecated + @Override public boolean isIndexed() { return hasStereotype("indexed"); } Modified: branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelBuilder.java =================================================================== --- branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelBuilder.java 2009-11-05 10:34:15 UTC (rev 693) +++ branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelBuilder.java 2009-11-05 15:10:25 UTC (rev 694) @@ -22,6 +22,7 @@ package org.nuiton.eugene.models.object.xml; import org.nuiton.eugene.models.object.ObjectModel; +import org.nuiton.eugene.models.object.ObjectModelAssociationClass; import org.nuiton.eugene.models.object.ObjectModelAttribute; import org.nuiton.eugene.models.object.ObjectModelClass; import org.nuiton.eugene.models.object.ObjectModelClassifier; @@ -67,6 +68,33 @@ } /** + * 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 @@ -76,16 +104,25 @@ */ public ObjectModelClass createClass(String name, String packageName, ObjectModelModifier... modifiers) { ObjectModelClassImpl result = new ObjectModelClassImpl(); - result.setName(name); - result.setPackage(packageName); + return createClass(result, name, packageName, modifiers); + } + + protected ObjectModelClass createClass(ObjectModelClassImpl clazz, + String name, String packageName, ObjectModelModifier... modifiers) { + clazz.setName(name); + clazz.setPackage(packageName); for (ObjectModelModifier modifier : modifiers) { switch (modifier) { - case ABSTRACT: result.setAbstract(true); break; - case STATIC: result.setStatic(true); + case ABSTRACT: + clazz.setAbstract(true); break; + case STATIC: + clazz.setStatic(true); break; + default: + throw new IllegalArgumentException("Unsupported modifier type '" + modifier.name() + "'"); } } - model.addClass(result); - return result; + model.addClass(clazz); + return clazz; } /** @@ -116,7 +153,7 @@ /** * Add an attribute to a classifier (interface, class, enum). - * Modifiers allowed : STATIC, FINAL, PUBLIC, PRIVATE, PROTECTED, PACKAGE. + * 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 @@ -138,8 +175,16 @@ attribute.setVisibility(modifier.toString()); } else { switch (modifier) { - case STATIC: attribute.setStatic(true); break; - case FINAL: attribute.setFinal(true); + 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() + "'"); } } } @@ -150,6 +195,145 @@ } /** + * 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(org.nuiton.eugene.models.object.ObjectModelAttribute, + * java.lang.String, int, int, org.nuiton.eugene.models.object.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 + */ + public ObjectModelAttribute addAssociation(ObjectModelClassifier classifierA, ObjectModelClassifier classifierB, String roleName, + int minMultiplicity, int maxMultiplicity, ObjectModelModifier... modifiers) { + + 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(org.nuiton.eugene.models.object.ObjectModelClassifier, org.nuiton.eugene.models.object.ObjectModelClassifier, + * java.lang.String, int, int, org.nuiton.eugene.models.object.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. @@ -175,8 +359,12 @@ result.setVisibility(modifier.toString()); } else { switch (modifier) { - case STATIC: result.setStatic(true); break; - case ABSTRACT: result.setAbstract(true); + case STATIC: + result.setStatic(true); break; + case ABSTRACT: + result.setAbstract(true); break; + default: + throw new IllegalArgumentException("Unsupported modifier type '" + modifier.name() + "'"); } } } @@ -261,4 +449,16 @@ 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); + } + } Modified: branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelParameterImpl.java =================================================================== --- branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelParameterImpl.java 2009-11-05 10:34:15 UTC (rev 693) +++ branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelParameterImpl.java 2009-11-05 15:10:25 UTC (rev 694) @@ -95,8 +95,7 @@ */ @Override public boolean isOrdered() { - return "ordered".equals(ordering) - || getTagValue("order-by") != null; + return "ordered".equals(ordering); } @Override Modified: branches/eugene-2.0/eugene/src/test/java/org/nuiton/eugene/models/object/xml/ObjectModelBuilderTest.java =================================================================== --- branches/eugene-2.0/eugene/src/test/java/org/nuiton/eugene/models/object/xml/ObjectModelBuilderTest.java 2009-11-05 10:34:15 UTC (rev 693) +++ branches/eugene-2.0/eugene/src/test/java/org/nuiton/eugene/models/object/xml/ObjectModelBuilderTest.java 2009-11-05 15:10:25 UTC (rev 694) @@ -29,10 +29,13 @@ import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; +import org.nuiton.eugene.models.object.ObjectModel; import static org.junit.Assert.*; +import org.nuiton.eugene.models.object.ObjectModelAssociationClass; import org.nuiton.eugene.models.object.ObjectModelAttribute; import org.nuiton.eugene.models.object.ObjectModelClass; import org.nuiton.eugene.models.object.ObjectModelClassifier; +import org.nuiton.eugene.models.object.ObjectModelElement; import org.nuiton.eugene.models.object.ObjectModelModifier; import org.nuiton.eugene.models.object.ObjectModelOperation; import org.nuiton.eugene.models.object.ObjectModelParameter; @@ -85,6 +88,34 @@ } /** + * Test of addTagValue method, of class ObjectModelBuilder. + * Prerequisite : none. + * - Add a tag value to the model + * - Add a tag value to an element + */ + @Test + public void testAddTagValue() { + System.out.println("addTagValue"); + + ObjectModelBuilder builder = new ObjectModelBuilder("TestModel"); + + builder.addTagValue("fr.ifremer.isisfish.types.Month", + "fr.ifremer.isisfish.types.hibernate.MonthType"); + + // model.tagvalue.fr.ifremer.isisfish.types.Month=fr.ifremer.isisfish.types.hibernate.MonthType + ObjectModel model = builder.getModel(); + assertEquals("fr.ifremer.isisfish.types.hibernate.MonthType", + model.getTagValue("fr.ifremer.isisfish.types.Month")); + + // fr.isisfish.entities.Population.attribute.name.tagvalue.pk=topiaId + ObjectModelClass clazz = builder.createClass("Population", "fr.isisfish.entities"); + ObjectModelAttribute attr = builder.addAttribute(clazz, "name", "java.lang.String"); + builder.addTagValue(attr, "pk", "topiaId"); + + assertEquals("topiaId", attr.getTagValue("pk")); + } + + /** * Test of createClass method, of class ObjectModelBuilder. * Prerequisite : none. * - Create a class with name and packageName. Qualified name of the class = name + packageName. @@ -304,4 +335,109 @@ System.out.println("setDocumentation"); } + /** + * Test of addAssociation method, of class ObjectModelBuilder. + * Prerequisite : two existing classifier in model. + * - Add an ordered navigable composite association 1..1 from Poll to Vote + */ + @Test + public void testAddAssociation() { + System.out.println("addAssociation"); + + ObjectModelBuilder builder = new ObjectModelBuilder("TestModel"); + + ObjectModelClass classA = builder.createClass("Poll", "org.chorem.pollen.business.persistence"); + + ObjectModelClass classB = builder.createClass("Vote", "org.chorem.pollen.business.persistence"); + + ObjectModelAttribute assoc = builder.addAssociation(classA, classB, "poll", 1, 1, + ObjectModelModifier.COMPOSITE, ObjectModelModifier.NAVIGABLE, ObjectModelModifier.ORDERED); + + assertNotNull(assoc); + assertTrue(assoc.isNavigable()); + assertTrue(assoc.isComposite()); + assertTrue(assoc.isOrdered()); + assertEquals("poll", assoc.getName()); + assertEquals(1, assoc.getMinMultiplicity()); + assertEquals(1, assoc.getMaxMultiplicity()); + assertEquals("org.chorem.pollen.business.persistence.Vote", assoc.getType()); + + } + + /** + * Test of addReverseAssociation method, of class ObjectModelBuilder. + * Prerequisite : two existing classifier in model and attribute association existing for one of the + * classifier. + * - Add a non navigable association 0..* from Vote to Poll + */ + @Test + public void testAddReverseAssociation() { + System.out.println("addReverseAssociation"); + + ObjectModelBuilder builder = new ObjectModelBuilder("TestModel"); + + ObjectModelClass classA = builder.createClass("Poll", "org.chorem.pollen.business.persistence"); + + ObjectModelClass classB = builder.createClass("Vote", "org.chorem.pollen.business.persistence"); + + ObjectModelAttribute assocA = builder.addAssociation(classA, classB, "poll", 1, 1, + ObjectModelModifier.COMPOSITE, ObjectModelModifier.NAVIGABLE, ObjectModelModifier.ORDERED); + + ObjectModelAttribute assocB = builder.addReverseAssociation(assocA, "vote", 0, -1); + + assertEquals(assocA, assocB.getReverseAttribute()); + assertEquals(assocB, assocA.getReverseAttribute()); + } + + /** + * Test of createAssociationClass method, of class ObjectModelBuilder. + * Prerequisite : two existing classifier in model and attribute association existing for both of the + * classifiers. + * - Add an association class VoteToChoice between Vote and Choice classes + */ + @Test + public void testCreateAssociationClass() { + System.out.println("createAssociationClass"); + + ObjectModelBuilder builder = new ObjectModelBuilder("TestModel"); + + ObjectModelClass classA = builder.createClass("Vote", "org.chorem.pollen.business.persistence"); + + ObjectModelClass classB = builder.createClass("Choice", "org.chorem.pollen.business.persistence"); + + ObjectModelAttribute assocA = builder.addAssociation(classA, classB, "vote", 0, -1, + ObjectModelModifier.NAVIGABLE, ObjectModelModifier.ORDERED); + + ObjectModelAttribute assocB = builder.addReverseAssociation(assocA, "choice", 1, -1, + ObjectModelModifier.NAVIGABLE, ObjectModelModifier.ORDERED); + + ObjectModelAssociationClass assocClass = builder.createAssociationClass("VoteToChoice", + "org.chorem.pollen.business.persistence", assocA, assocB); + + List<ObjectModelClassifier> classifiers = assocClass.getParticipantsClassifiers(); + + assertEquals(2, classifiers.size()); + assertTrue(classifiers.contains(classA)); + assertTrue(classifiers.contains(classB)); + } + + /** + * Test of addStereotype method, of class ObjectModelBuilder. + */ + @Test + public void testAddStereotype() { + System.out.println("addStereotype"); + + ObjectModelBuilder builder = new ObjectModelBuilder("TestModel"); + + ObjectModelClass classA = builder.createClass("Vote", "org.chorem.pollen.business.persistence"); + + assertEquals(0, classA.getStereotypes().size()); + + builder.addStereotype(classA, "entity"); + + assertEquals(1, classA.getStereotypes().size()); + + } + } \ No newline at end of file