Author: bleny Date: 2010-09-28 16:52:28 +0200 (Tue, 28 Sep 2010) New Revision: 359 Url: http://nuiton.org/repositories/revision/wikitty/359 Log: add meta-extension support in transformers, add meta stereotype in model, some modifications in Wikitty contract Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Wikitty.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyCopyOnWrite.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyImpl.java trunk/wikitty-api/src/main/xmi/wikitty.zargo trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyAbstractGenerator.java trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyHelperGenerator.java Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Wikitty.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Wikitty.java 2010-09-28 14:43:15 UTC (rev 358) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Wikitty.java 2010-09-28 14:52:28 UTC (rev 359) @@ -128,6 +128,12 @@ void clearField(String ext, String fieldName); + void addToField(String fqFieldName, Object value); + + void removeFromField(String fqFieldName, Object value); + + void clearField(String fqFieldName); + Set<String> fieldNames(); Object getFqField(String fqFieldName); Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyCopyOnWrite.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyCopyOnWrite.java 2010-09-28 14:43:15 UTC (rev 358) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyCopyOnWrite.java 2010-09-28 14:52:28 UTC (rev 359) @@ -221,6 +221,24 @@ target.clearField(ext, fieldName); } + @Override + public void addToField(String fqFieldName, Object value) { + substituteTargetWithCopy(); + target.addToField(fqFieldName, value); + } + + @Override + public void removeFromField(String fqFieldName, Object value) { + substituteTargetWithCopy(); + target.removeFromField(fqFieldName, value); + } + + @Override + public void clearField(String fqFieldName) { + substituteTargetWithCopy(); + target.clearField(fqFieldName); + } + public Set<String> fieldNames() { return target.fieldNames(); } Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyImpl.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyImpl.java 2010-09-28 14:43:15 UTC (rev 358) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyImpl.java 2010-09-28 14:52:28 UTC (rev 359) @@ -703,6 +703,24 @@ } @Override + public void addToField(String fqFieldName, Object value) { + // TODO 20100928 bleny + throw new UnsupportedOperationException(); + } + + @Override + public void removeFromField(String fqFieldName, Object value) { + // TODO 20100928 bleny + throw new UnsupportedOperationException(); + } + + @Override + public void clearField(String fqFieldName) { + // TODO 20100928 bleny + throw new UnsupportedOperationException(); + } + + @Override public boolean equals(Object obj) { boolean result = false; if (obj instanceof Wikitty) { Modified: trunk/wikitty-api/src/main/xmi/wikitty.zargo =================================================================== (Binary files differ) Modified: trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyAbstractGenerator.java =================================================================== --- trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyAbstractGenerator.java 2010-09-28 14:43:15 UTC (rev 358) +++ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyAbstractGenerator.java 2010-09-28 14:52:28 UTC (rev 359) @@ -41,7 +41,9 @@ */ protected Pattern p = Pattern.compile("\\{(([^|}])*)(?:\\|([^}]*))?\\}"); - /** map "Client.name" to "getName()" or any getter to read this attribute */ + /** map "Client.name" to "getName()" or any getter to read this attribute + * those getter names are stored while generating in order to be found + * later when generating toString() */ protected Map<String, String> attributeToGetterName = new HashMap<String, String>(); @Override @@ -51,50 +53,53 @@ @Override public void transformFromModel(ObjectModel model) { - - List<ObjectModelClass> modelBusinessEntities = new ArrayList<ObjectModelClass>(); + // contains boths businessEntities and metaExtensions + // elements may have one of the two sterotypes or both + // but elements with none of them aren't in this list + List<ObjectModelClass> modelBoth = new ArrayList<ObjectModelClass>(); + // fill modelBusinessEntities with entities found in model for (ObjectModelClass clazz : model.getClasses()) { - if (WikittyTransformerUtil.isBusinessEntity(clazz)) { - modelBusinessEntities.add(clazz); + if (WikittyTransformerUtil.isBusinessEntity(clazz) || + WikittyTransformerUtil.isMetaExtension(clazz)) { + modelBoth.add(clazz); } } - for (ObjectModelClass businessEntity : modelBusinessEntities) { - ObjectModelClass abstractClass = createAbstractClass(WikittyTransformerUtil.businessEntityToAbstractName(businessEntity), - businessEntity.getPackageName()); - processedClasses.put(businessEntity, abstractClass); + for (ObjectModelClass clazz : modelBoth) { + ObjectModelClass abstractClass = createAbstractClass( + WikittyTransformerUtil.businessEntityToAbstractName(clazz), + clazz.getPackageName()); + processedClasses.put(clazz, abstractClass); setSuperClass(abstractClass, "BusinessEntityWikitty"); - addInterface(abstractClass, businessEntity.getQualifiedName()); + addInterface(abstractClass, clazz.getQualifiedName()); } - - for (ObjectModelClass businessEntity : modelBusinessEntities) { - addOperations(businessEntity, processedClasses.get(businessEntity)); + + for (ObjectModelClass clazz : modelBoth) { + if (WikittyTransformerUtil.isMetaExtension(clazz)) { + addMetaExtensionOperations(clazz, processedClasses.get(clazz)); + } else if (WikittyTransformerUtil.isBusinessEntity(clazz)) { + addOperations(clazz, processedClasses.get(clazz)); + } } // at this time, all operations in generated abstracts are just the operations // like get/set etc. we will copy all operations of a given class to all children // that's why constructors and others operations are not yet added - for (ObjectModelClass businessEntity : modelBusinessEntities) { - addInheritedOperations(businessEntity, processedClasses.get(businessEntity)); + for (ObjectModelClass clazz : modelBoth) { + if (WikittyTransformerUtil.isBusinessEntity(clazz)) { + addInheritedOperations(clazz, processedClasses.get(clazz)); + } } - for (ObjectModelClass businessEntity : modelBusinessEntities) { - ObjectModelClass abstractClassForThisEntity = processedClasses.get(businessEntity); + for (ObjectModelClass clazz : modelBoth) { + ObjectModelClass abstractClassForThisEntity = processedClasses.get(clazz); addImports(abstractClassForThisEntity); addConstructors(abstractClassForThisEntity); - addConstants(businessEntity, abstractClassForThisEntity); - addToString(businessEntity, abstractClassForThisEntity); + addConstants(clazz, abstractClassForThisEntity); + addToString(clazz, abstractClassForThisEntity); } - - // for all classes of model, check if steroptyped with "meta" - for (ObjectModelClass clazz : model.getClasses()) { - if (WikittyTransformerUtil.isMetaExtension(clazz)) { - // if so, add operations - addMetaExtensionOperations(clazz, processedClasses.get(clazz)); - } - } processedClasses.clear(); } @@ -258,9 +263,6 @@ String extensionVariableName = WikittyTransformerUtil.classToExtensionVariableName(businessEntity, true); String helperClassName = WikittyTransformerUtil.businessEntityToHelperName(businessEntity); - boolean isMetaExtension = WikittyTransformerUtil.isMetaExtension(businessEntity); - - // generating operations with bodies to realize contract for (ObjectModelAttribute attribute : businessEntity.getAttributes()) { if (attribute.isNavigable()) { @@ -287,53 +289,24 @@ getterName = "get" + StringUtils.capitalize(attributeName); ObjectModelOperation getter = addOperation(abstractClass, getterName, attributeTypeSimpleNameInSet); addAnnotation(abstractClass, getter, "Override"); - String getterBody; - if (isMetaExtension) { - getterBody = "" + String getterBody = "" /*{ - <%=attributeTypeSimpleNameInSet%> result; - if (extensionForMetaExtension == null) { - result = <%=helperClassName%>.<%=getterName%>(getWikitty()); - } else { - result = <%=helperClassName%>.<%=getterName%>(extensionForMetaExtension, getWikitty()); - } - return result; -}*/; - } else { - getterBody = "" -/*{ <%=attributeTypeSimpleNameInSet%> result = <%=helperClassName%>.<%=getterName%>(getWikitty()); return result; -}*/; - } +}*/; setOperationBody(getter, getterBody); String addName = "add" + StringUtils.capitalize(attributeName); ObjectModelOperation adder = addOperation(abstractClass, addName, "void"); addAnnotation(abstractClass, adder, "Override"); addParameter(adder, "String", "element"); - String adderBody; - if (isMetaExtension) { - adderBody = "" + String adderBody = "" /*{ - if (extensionForMetaExtension == null) { - <%=helperClassName%>.<%=addName%>(getWikitty(), element); - getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, null, <%= getter.getName() %>()); - } else { - <%=helperClassName%>.<%=addName%>(extensionForMetaExtension, getWikitty(), element); - String fieldName = <%=helperClassName%>.getMetaFieldName(extensionForMetaExtension, "<%=attributeName%>"); - getPropertyChangeSupport().firePropertyChange(fieldName, null, <%= getter.getName() %>()); - } -}*/; - } else { - adderBody = "" -/*{ <%=helperClassName%>.<%=addName%>(getWikitty(), element); getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, null, <%= getter.getName() %>()); }*/; - } setOperationBody(adder, adderBody); - + String removeName = "remove" + StringUtils.capitalize(attributeName); ObjectModelOperation remover = addOperation(abstractClass, removeName, "void"); addAnnotation(abstractClass, remover, "Override"); @@ -344,7 +317,7 @@ getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, null, <%=getter.getName()%>()); }*/; setOperationBody(remover, removerBody); - + String clearName = "clear" + StringUtils.capitalize(attributeName); ObjectModelOperation clear = addOperation(abstractClass, clearName, "void"); addAnnotation(abstractClass, clear, "Override"); @@ -354,8 +327,7 @@ getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, null, <%=getter.getName()%>()); }*/; setOperationBody(clear, clearBody); - - + } else { String getFieldMethodName = WikittyTransformerUtil.generateGetFieldAsCall(attribute); @@ -478,6 +450,8 @@ protected void addMetaExtensionOperations(ObjectModelClass metaExtension, ObjectModelClass abstractClassForThisMetaExtension) { + String helperClassName = WikittyTransformerUtil.businessEntityToHelperName(metaExtension); + ObjectModelAttribute extension = addAttribute(abstractClassForThisMetaExtension, "extensionForMetaExtension", WikittyTransformerUtil.WIKITTY_EXTENSION_CLASS_FQN); setDocumentation(extension, "the metaExtension operations target this extension, may be null"); @@ -487,11 +461,138 @@ setDocumentation(addMetaExtension, String.format( "add %s meta-extension on given extension to this entity", metaExtension.getName())); - String helperName = WikittyTransformerUtil.businessEntityToHelperName(metaExtension); setOperationBody(addMetaExtension, "" /*{ extensionForMetaExtension = extension; - <%=helperName%>.addMetaExtension(extension, getWikitty()); + <%=helperClassName%>.addMetaExtension(extension, getWikitty()); }*/); + + // generating operations with bodies to realize contract + for (ObjectModelAttribute attribute : metaExtension.getAttributes()) { + if (attribute.isNavigable()) { + // needed below, in templates + String fieldVariableName = WikittyTransformerUtil.attributeToFielVariableName(attribute, true); + String attributeType = WikittyTransformerUtil.generateResultType(attribute, false); + + String attributeName = attribute.getName(); + if (attribute.hasTagValue(WikittyTransformerUtil.TAG_ALTERNATIVE_NAME)) { + // there is a conflict, purifier transformer give as the right name to use + attributeName = attribute.getTagValue(WikittyTransformerUtil.TAG_ALTERNATIVE_NAME); + } + + String getterName = null; + + if (WikittyTransformerUtil.isAttributeCollection(attribute)) { + // attributed is a collection, we will generate operations get, add, remove and clear + + String attributeTypeSimpleNameInSet = WikittyTransformerUtil.generateResultType(attribute, true); + String getFieldMethodName = WikittyTransformerUtil.generateGetFieldAsCall(attribute); + + // now, for this attribute, we will generate add, remove and clear methods + // adding operations to contract + getterName = "get" + StringUtils.capitalize(attributeName); + ObjectModelOperation getter = addOperation(abstractClassForThisMetaExtension, getterName, attributeTypeSimpleNameInSet); + addAnnotation(abstractClassForThisMetaExtension, getter, "Override"); + String getterBody = "" +/*{ + <%=attributeTypeSimpleNameInSet%> result; + if (extensionForMetaExtension == null) { + result = <%=helperClassName%>.<%=getterName%>(getWikitty()); + } else { + result = <%=helperClassName%>.<%=getterName%>(extensionForMetaExtension, getWikitty()); + } + return result; +}*/; + setOperationBody(getter, getterBody); + + String addName = "add" + StringUtils.capitalize(attributeName); + ObjectModelOperation adder = addOperation(abstractClassForThisMetaExtension, addName, "void"); + addAnnotation(abstractClassForThisMetaExtension, adder, "Override"); + addParameter(adder, "String", "element"); + String adderBody = "" +/*{ + if (extensionForMetaExtension == null) { + <%=helperClassName%>.<%=addName%>(getWikitty(), element); + getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, null, <%=getter.getName()%>()); + } else { + <%=helperClassName%>.<%=addName%>(extensionForMetaExtension, getWikitty(), element); + String fieldName = <%=helperClassName%>.getMetaFieldName(extensionForMetaExtension, "<%=attributeName%>"); + getPropertyChangeSupport().firePropertyChange(fieldName, null, <%=getter.getName()%>()); + } +}*/; + setOperationBody(adder, adderBody); + + String removeName = "remove" + StringUtils.capitalize(attributeName); + ObjectModelOperation remover = addOperation(abstractClassForThisMetaExtension, removeName, "void"); + addAnnotation(abstractClassForThisMetaExtension, remover, "Override"); + addParameter(remover, "String", "element"); + String removerBody = "" +/*{ + if (extensionForMetaExtension == null) { + <%=helperClassName%>.<%=removeName%>(getWikitty(), element); + getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, null, <%=getter.getName()%>()); + } else { + <%=helperClassName%>.<%=removeName%>(extensionForMetaExtension, getWikitty(), element); + String fieldName = <%=helperClassName%>.getMetaFieldName(extensionForMetaExtension, "<%=attributeName%>"); + getPropertyChangeSupport().firePropertyChange(fieldName, null, <%=getter.getName()%>()); + } +}*/; + setOperationBody(remover, removerBody); + + String clearName = "clear" + StringUtils.capitalize(attributeName); + ObjectModelOperation clear = addOperation(abstractClassForThisMetaExtension, clearName, "void"); + addAnnotation(abstractClassForThisMetaExtension, clear, "Override"); + String clearBody = "" +/*{ + if (extensionForMetaExtension == null) { + <%=helperClassName%>.<%=clearName%>(getWikitty()); + getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, null, <%=getter.getName()%>()); + } else { + <%=helperClassName%>.<%=clearName%>(extensionForMetaExtension, getWikitty()); + String fieldName = <%=helperClassName%>.getMetaFieldName(extensionForMetaExtension, "<%=attributeName%>"); + getPropertyChangeSupport().firePropertyChange(fieldName, null, <%=getter.getName()%>()); + } +}*/; + setOperationBody(clear, clearBody); + + + } else { + String getFieldMethodName = WikittyTransformerUtil.generateGetFieldAsCall(attribute); + + // adding getter and setter to contract + getterName = "get" + StringUtils.capitalize(attributeName); + ObjectModelOperation getter = addOperation(abstractClassForThisMetaExtension, getterName, attributeType); + addAnnotation(abstractClassForThisMetaExtension, getter, "Override"); + setOperationBody(getter, "" +/*{ + <%=attributeType%> value; + if (extensionForMetaExtension == null) { + value = <%=helperClassName%>.<%=getterName%>(getWikitty()); + } else { + value = <%=helperClassName%>.<%=getterName%>(extensionForMetaExtension, getWikitty()); + } + return value; +}*/); + + String setterName = "set" + StringUtils.capitalize(attributeName); + ObjectModelOperation setter = addOperation(abstractClassForThisMetaExtension, setterName, attributeType); + addAnnotation(abstractClassForThisMetaExtension, setter, "Override"); + addParameter(setter, attributeType, attributeName); + setOperationBody(setter, "" +/*{ + <%=attributeType%> oldValue; + if (extensionForMetaExtension == null) { + oldValue = <%=helperClassName%>.<%=setterName%>(getWikitty(), <%=attributeName%>); + getPropertyChangeSupport().firePropertyChange(<%=fieldVariableName%>, oldValue, <%=getter.getName()%>()); + } else { + oldValue = <%=helperClassName%>.<%=setterName%>(extensionForMetaExtension, getWikitty(), <%=attributeName%>); + String fieldName = <%=helperClassName%>.getMetaFieldName(extensionForMetaExtension, "<%=attributeName%>"); + getPropertyChangeSupport().firePropertyChange(fieldName, oldValue, <%=getter.getName()%>()); + } + return oldValue; +}*/); + } + } + } } } Modified: trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyHelperGenerator.java =================================================================== --- trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyHelperGenerator.java 2010-09-28 14:43:15 UTC (rev 358) +++ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyHelperGenerator.java 2010-09-28 14:52:28 UTC (rev 359) @@ -263,6 +263,106 @@ - // now, adding all + // now, adding all + + // generating operations with bodies + for (ObjectModelAttribute attribute : metaExtension.getAttributes()) { + if (attribute.isNavigable()) { + // needed below, in templates + String fieldVariableName = WikittyTransformerUtil.attributeToFielVariableName(attribute, true); + String attributeType = WikittyTransformerUtil.generateResultType(attribute, false); + + String attributeName = attribute.getName(); + if (attribute.hasTagValue(WikittyTransformerUtil.TAG_ALTERNATIVE_NAME)) { + // there is a conflict, purifier transformer give as the right name to use + attributeName = attribute.getTagValue(WikittyTransformerUtil.TAG_ALTERNATIVE_NAME); + } + + if (WikittyTransformerUtil.isAttributeCollection(attribute)) { + // attributed is a collection, we will generate operations get, add, remove and clear + + String attributeTypeSimpleNameInSet = WikittyTransformerUtil.generateResultType(attribute, true); + String getFieldMethodName = WikittyTransformerUtil.generateGetFieldAsCall(attribute); + + // now, for this attribute, we will generate add, remove and clear methods + // adding operations to contract + String getterName = "get" + StringUtils.capitalize(attributeName); + ObjectModelOperation getter = addOperation(helper, getterName, attributeTypeSimpleNameInSet, ObjectModelModifier.STATIC); + addParameter(getter, WikittyTransformerUtil.WIKITTY_EXTENSION_CLASS_FQN, "extension"); + addParameter(getter, WikittyTransformerUtil.WIKITTY_CLASS_FQN, "wikitty"); + String getterBody = "" +/*{ + String fieldName = getMetaFieldName(extension, "<%=attributeName%>"); + <%=attributeTypeSimpleNameInSet%> result = (<%=attributeTypeSimpleNameInSet%>) wikitty.getFqField(fieldName); + return result; +}*/; + setOperationBody(getter, getterBody); + + String addName = "add" + StringUtils.capitalize(attributeName); + ObjectModelOperation adder = addOperation(helper, addName, "void", ObjectModelModifier.STATIC); + addParameter(adder, WikittyTransformerUtil.WIKITTY_EXTENSION_CLASS_FQN, "extension"); + addParameter(adder, WikittyTransformerUtil.WIKITTY_CLASS_FQN, "wikitty"); + addParameter(adder, attributeType, "element"); + String adderBody = "" +/*{ + String fieldName = getMetaFieldName(extension, "<%=attributeName%>"); + wikitty.addToField(fieldName, element); +}*/; + setOperationBody(adder, adderBody); + + String removeName = "remove" + StringUtils.capitalize(attributeName); + ObjectModelOperation remover = addOperation(helper, removeName, "void", ObjectModelModifier.STATIC); + addParameter(remover, WikittyTransformerUtil.WIKITTY_EXTENSION_CLASS_FQN, "extension"); + addParameter(remover, WikittyTransformerUtil.WIKITTY_CLASS_FQN, "wikitty"); + addParameter(remover, attributeType, "element"); + String removerBody = "" +/*{ + String fieldName = getMetaFieldName(extension, "<%=attributeName%>"); + wikitty.removeFromField(fieldName, element); +}*/; + setOperationBody(remover, removerBody); + + String clearName = "clear" + StringUtils.capitalize(attributeName); + ObjectModelOperation clear = addOperation(helper, clearName, "void", ObjectModelModifier.STATIC); + addParameter(clear, WikittyTransformerUtil.WIKITTY_EXTENSION_CLASS_FQN, "extension"); + addParameter(clear, WikittyTransformerUtil.WIKITTY_CLASS_FQN, "wikitty"); + String clearBody = "" +/*{ + String fieldName = getMetaFieldName(extension, "<%=attributeName%>"); + wikitty.clearField(fieldName); +}*/; + setOperationBody(clear, clearBody); + + + } else { + String getFieldMethodName = WikittyTransformerUtil.generateGetFieldAsCall(attribute); + + // adding getter and setter to contract + String getterName = "get" + StringUtils.capitalize(attributeName); + ObjectModelOperation getter = addOperation(helper, getterName, attributeType, ObjectModelModifier.STATIC); + addParameter(getter, WikittyTransformerUtil.WIKITTY_EXTENSION_CLASS_FQN, "extension"); + addParameter(getter, WikittyTransformerUtil.WIKITTY_CLASS_FQN, "wikitty"); + setOperationBody(getter, "" +/*{ + String fieldName = getMetaFieldName(extension, "<%=attributeName%>"); + <%=attributeType%> value = (<%=attributeType%>) wikitty.getFqField(fieldName); + return value; +}*/); + + String setterName = "set" + StringUtils.capitalize(attributeName); + ObjectModelOperation setter = addOperation(helper, setterName, attributeType, ObjectModelModifier.STATIC); + addParameter(setter, WikittyTransformerUtil.WIKITTY_EXTENSION_CLASS_FQN, "extension"); + addParameter(setter, WikittyTransformerUtil.WIKITTY_CLASS_FQN, "wikitty"); + addParameter(setter, attributeType, attributeName); + setOperationBody(setter, "" +/*{ + <%=attributeType%> oldValue = <%=getter.getName()%>(extension, wikitty); + String fieldName = getMetaFieldName(extension, "<%=attributeName%>"); + wikitty.setFqField(fieldName, <%=attributeName%>); + return oldValue; +}*/); + } + } + } } }