Author: bleny Date: 2010-11-05 12:01:43 +0100 (Fri, 05 Nov 2010) New Revision: 467 Url: http://nuiton.org/repositories/revision/wikitty/467 Log: fixes operations inheritence on multiple level of dependency in entities, spreading needed imports. removed useless implements in Abstract, since interface should already extends interface Modified: trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyAbstractGenerator.java trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyContractGenerator.java 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-11-05 08:08:27 UTC (rev 466) +++ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyAbstractGenerator.java 2010-11-05 11:01:43 UTC (rev 467) @@ -24,15 +24,7 @@ */ package org.nuiton.wikitty.generator; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Random; -import java.util.regex.Matcher; -import java.util.regex.Pattern; import org.apache.commons.lang.StringEscapeUtils; - import org.apache.commons.lang.StringUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; @@ -44,6 +36,14 @@ import org.nuiton.eugene.models.object.ObjectModelModifier; import org.nuiton.eugene.models.object.ObjectModelOperation; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Random; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + /*{generator option: writeString = }*/ /*{generator option: parentheses = false}*/ /*{generator option: writeString = +}*/ @@ -75,6 +75,16 @@ return new WikittyPurifierTransformer(); } + protected List<ObjectModelClass> entitiesWithInheritedOperations = + new ArrayList<ObjectModelClass>(); + + /** an entity with a dependency must add the imports defined as values + * in the map. By filling and reading this map, imports while spread across + * the levels of dependencies + */ + protected Map<ObjectModelClass, List<String>> requiredDependencyImports = + new HashMap<ObjectModelClass, List<String>>(); + @Override public void transformFromModel(ObjectModel model) { @@ -386,31 +396,76 @@ } } + /** Add inherited operations to the abstract generated from an entity. + * Method browse superClasses to copy methods and their bodies. The method + * deal with imports, cause bodies call the Helper of the classe where + * the attribute was declared. + * + * If A inherit from B and B inherit from and A, B, C not in the same package + * we B need to import CHelper and A need to import BHelper. But, since A + * has C attributes too, it needs CHelper too. So when we will process B, + * we will save needed imports, A will get them thus import CHelper. + */ protected void addInheritedOperations(ObjectModelClass businessEntity, ObjectModelClass abstractClass) { - // now, add to this abstract all operation due to inheritence from - // other business entities - for (ObjectModelClass superClass : businessEntity.getSuperclasses()) { + if ( ! entitiesWithInheritedOperations.contains(businessEntity)) { - // if super class is not in the same package, import it Helper - if (! businessEntity.getPackageName().equals(superClass.getPackageName())) { - addImport(abstractClass, superClass.getPackageName() + "." + - WikittyTransformerUtil.businessEntityToHelperName(superClass)); - } - - if (WikittyTransformerUtil.isBusinessEntity(superClass)) { - addInterface(abstractClass, WikittyTransformerUtil.businessEntityToContractName(superClass)); // extends - // getting the signatures and bodies of those operations - for (ObjectModelOperation operation : processedClasses.get(superClass).getOperations()) { - - ObjectModelOperation operationClone = cloneOperationSignature(operation, abstractClass, true); - setOperationBody(operationClone, operation.getBodyCode()); - - // XXX 20100816 bleny should be a call to cloneOperation(operation, abstractClass, true); + // now, add to this abstract all operation due to inheritence from + // other business entities + + for (ObjectModelClass superClass : businessEntity.getSuperclasses()) { + // this list will contains all imports we do due to inheritence + List<String> imports = requiredDependencyImports.get(businessEntity); + if (imports == null) { + imports = new ArrayList<String>(); + requiredDependencyImports.put(businessEntity, imports); } - } else { - addInterface(abstractClass, superClass.getQualifiedName()); // extends + + // process superclasses first, so we will get inherited operations from superclass + addInheritedOperations(superClass, processedClasses.get(superClass)); + + // if super class is not in the same package, import its Helper + if ( ! businessEntity.getPackageName().equals(superClass.getPackageName())) { + String helperToImport = superClass.getPackageName() + "." + + WikittyTransformerUtil.businessEntityToHelperName(superClass); + + addImport(abstractClass, helperToImport); + + // add the last import to the map, so sub-classes will be + // able to know what imports they need + imports.add(helperToImport); + } + + // we may need to some imports for the bodies of the inherited operations + // let's get the imports done by superClass and copy them + List<String> importsNeeded = requiredDependencyImports.get(superClass); + if (log.isDebugEnabled()) { + log.debug(businessEntity + " needs imports " + importsNeeded); + } + if (importsNeeded != null) { + for (String importNeeded : importsNeeded) { + // superclass needed this import, so wo import too + addImport(abstractClass, importNeeded); + + // subclasses will need it too, so add it + imports.add(importNeeded); + } + } + + if (WikittyTransformerUtil.isBusinessEntity(superClass)) { + + // getting the signatures and bodies of those operations + for (ObjectModelOperation operation : processedClasses.get(superClass).getOperations()) { + + ObjectModelOperation operationClone = cloneOperationSignature(operation, abstractClass, true); + setOperationBody(operationClone, operation.getBodyCode()); + + // XXX 20100816 bleny should be a call to cloneOperation(operation, abstractClass, true); + } + } } + + entitiesWithInheritedOperations.add(businessEntity); } } Modified: trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyContractGenerator.java =================================================================== --- trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyContractGenerator.java 2010-11-05 08:08:27 UTC (rev 466) +++ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyContractGenerator.java 2010-11-05 11:01:43 UTC (rev 467) @@ -248,7 +248,7 @@ // other business entities Collection<ObjectModelClass> superClasses = businessEntity.getSuperclasses(); for (ObjectModelClass superClass : superClasses) { - addInterface(contract, superClass.getQualifiedName()); // extends ? + addInterface(contract, superClass.getQualifiedName()); if (WikittyTransformerUtil.isBusinessEntity(superClass)) { // superclass must have been processed first to have its operations set if ( ! processedEntities.contains(superClass)) {