Changeset 7998


Ignore:
Timestamp:
01/12/11 16:48:52 (8 years ago)
Author:
mnagni
Message:
 
Location:
mauRepo/xmi2sqlalchemy/trunk
Files:
15 added
4 deleted
27 edited
2 copied

Legend:

Unmodified
Added
Removed
  • mauRepo/xmi2sqlalchemy/trunk/pom.xml

    r7974 r7998  
    1414                <artifactId>core</artifactId> 
    1515                <version>1.2.0</version> 
     16        </dependency> 
     17        <dependency> 
     18                <groupId>org.apache.velocity</groupId> 
     19                <artifactId>velocity-tools</artifactId> 
     20                <version>2.0</version> 
    1621        </dependency> 
    1722  </dependencies> 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/ModelXMI11Factory.java

    r7974 r7998  
    100100         */ 
    101101        @Override 
    102         public UMLDataType createUMLDataType(Element el, String modelId){ 
    103                 return new UMLDataTypeImpl(el, modelId); 
     102        public UMLDataType createUMLDataType(Element el, String modelId, UMLModel umlModel){ 
     103                return new UMLDataTypeImpl(el, modelId, umlModel); 
    104104        } 
    105105         
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/ModelXMIFactory.java

    r7974 r7998  
    6060        public abstract UMLClassifierRole createUMLClassifierRole(Element el, String modelId); 
    6161 
    62         public abstract UMLDataType createUMLDataType(Element el, String modelId); 
     62        public abstract UMLDataType createUMLDataType(Element el, String modelId, UMLModel umlModel); 
    6363 
    6464        public abstract UMLCollaboration createUMLCollaboration(Element el, String modelId); 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/NmParser.java

    r7996 r7998  
    116116         
    117117        private UMLModel processXMI() throws NewmoonException { 
    118                 Document doc = parseXmlFile(); 
    119                 //helper = new NmParserHelper(this.inputXML);            
     118                Document doc = parseXmlFile();           
    120119                processXMI(doc.getDocumentElement()); 
    121120                 
    122121                DepenciesParser dp = new DepenciesParser(mainUmlModel); 
    123122                dp.startProcess();                       
    124                         /* 
    125                         if (mainUmlModel.getUmlPackages().size() == 1) { 
    126                                 synchronized (mainUmlModel.getUmlPackages().get(0).getKeyNames()) { 
    127                                         mainUmlModel.getUmlPackages().get(0).getKeyNames().add(keyName);         
    128                                 } 
    129                         } 
    130                         */ 
    131123                return mainUmlModel; 
    132124        } 
     
    157149                if (node == null) 
    158150                        return;          
    159                 //validateNode(node, "XMI.header", UML_NS); 
    160151                node = helper.getFirstSiblingNoTextNode(node.getFirstChild());           
    161152                while (node != null) { 
     
    171162                if (node == null) 
    172163                        return;          
    173                 //validateNode(node, "XMI.header", UML_NS); 
    174164                node = helper.getFirstSiblingNoTextNode(node.getFirstChild());           
    175165                while (node != null) { 
     
    201191                } 
    202192                 
    203                 //else is a now model 
    204                 //boolean response = appendToArchive(model);             
     193                //else is a now model            
    205194                node = helper.getFirstSiblingNoTextNode(node.getFirstChild());           
    206195                while (node != null) {                   
     
    210199                        }                        
    211200                        node = helper.getFirstSiblingNoTextNode(node.getNextSibling()); 
    212                 } 
    213                 //processAssociations(); 
    214                 //processGeneralizations();              
     201                }        
    215202                return model; 
    216203        }        
     
    305292        private UMLDataType processDataType(Node node, UMLModel umlModel) { 
    306293                //Process the DataType element 
    307                 UMLDataType umlDT = modelFactory.createUMLDataType((Element)node, getMainModelId()); 
     294                UMLDataType umlDT = modelFactory.createUMLDataType((Element)node, getMainModelId(), umlModel); 
    308295                umlModel.getUmlDataType().add(umlDT); 
    309296                return umlDT; 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/UMLElementsArchive.java

    r7996 r7998  
    4545import java.util.concurrent.Future; 
    4646 
    47 import ndg.services.newmoon.velocity.python.GenerateModule; 
     47import ndg.services.newmoon.velocity.python.support.ClassModel; 
    4848import ndg.services.newmoon.xmiModel.EAStub; 
    4949import ndg.services.newmoon.xmiModel.UMLAssociation; 
     
    5151import ndg.services.newmoon.xmiModel.UMLAttribute; 
    5252import ndg.services.newmoon.xmiModel.UMLClass; 
     53import ndg.services.newmoon.xmiModel.UMLClassDataType; 
    5354import ndg.services.newmoon.xmiModel.UMLDataType; 
    5455import ndg.services.newmoon.xmiModel.UMLDependency; 
     
    9192        private final Map<String, UMLModel> modelIdToModel = Collections.synchronizedMap(new HashMap<String, UMLModel>()); 
    9293        private final Map<EAStub, UMLModel> stubToModel = Collections.synchronizedMap(new HashMap<EAStub, UMLModel>()); 
    93         private final Map<UML_ID, EAStub> dependencyToStub = new HashMap<UML_ID, EAStub>(); 
    9494        private final Map<String, UMLClass> classFromNameAndModelID = Collections 
    9595                        .synchronizedMap(new HashMap<String, UMLClass>()); 
     
    100100        private final List<EAStub> eaStubList = new ArrayList<EAStub>(); 
    101101        private final List<UMLClass> umlClassList = new ArrayList<UMLClass>(); 
    102     private final List<UMLModel> umlModelList = new ArrayList<UMLModel>();       
     102    private final List<UMLModel> umlModelList = new ArrayList<UMLModel>(); 
     103     
     104    private final Set<ClassModel> modelClasses = new HashSet<ClassModel>(); 
    103105         
    104106         
     
    218220        } 
    219221 
    220         public UMLClass getUMLClassDefinition(UML_ID umlID) {            
     222        public UMLClassDataType getType(UML_ID umlID) {  
     223                UML_ID validatedUmlId = getUMLIDByUML_ID(umlID); 
     224                if (validatedUmlId instanceof UMLDataType) 
     225                        return (UMLDataType)validatedUmlId; 
     226                else  
     227                        return getUMLClassByOwner(validatedUmlId); 
     228        } 
     229         
     230        public UMLClass getTypeDefinition(UML_ID umlID) {                
    221231                UML_ID validatedUmlId = getUMLIDByUML_ID(umlID); 
    222232                return getUMLClassByOwner(validatedUmlId); 
     
    271281                 
    272282                for(UMLGeneralization generalization : generalizations) { 
    273                         CollectionUtils.addIgnoreNull(supertypes, getUMLClassDefinition(generalization.getSupertype())); 
     283                        CollectionUtils.addIgnoreNull(supertypes, getType(generalization.getSupertype())); 
    274284                } 
    275285                return supertypes; 
     
    364374                } 
    365375                 
    366                 if (umlClass != null) { 
    367                         classFromNameAndModelID.put(elementName + "_" + modelId, umlClass);                      
    368                 } 
    369                 return umlClass; 
     376                return umlClass != null ? 
     377                        classFromNameAndModelID.put(elementName + "_" + modelId, umlClass) : umlClass; 
    370378        } 
    371379 
     
    462470        } 
    463471 
    464         public UML_ID getElementImplementation(UMLDataType dataType) { 
    465                 return getElementByName(GenerateModule.extractEmbeddedType(dataType.getName()), UMLClass.class); 
    466         } 
    467  
     472        /* 
    468473        public UML_ID getElementImplementation(UMLStereotype stereotype) { 
    469474                if (stereotype.getName().equalsIgnoreCase("enumeration")) { 
     
    478483                return null; 
    479484        } 
     485        */ 
    480486 
    481487        public UMLClass getUMLClassByName(String className) { 
     
    599605                        if (!(object instanceof UMLGeneralization)) 
    600606                                return false; 
    601                         return umlClass.getId().equals(((UMLGeneralization) object).getSubtype().getId()); 
     607                        UMLGeneralization umlGeneralization = ((UMLGeneralization) object); 
     608                        return umlClass.getId().equals(umlGeneralization.getSubtype().getId()); 
    602609                } 
    603610        }        
     
    680687        } 
    681688 
     689        /* 
    682690        public void evaluateMulteplicity(Set<UMLClass> classes) throws InterruptedException { 
    683691                for (UMLClass clazz : classes) { 
     
    686694                waitParserToComplete(); 
    687695        } 
     696        */ 
    688697 
    689698        public synchronized void synchPackageElement(String pkgName, boolean found) { 
     
    811820        } 
    812821 
    813         private class CheckMulteplicity implements Callable<Object> { 
    814                 private final Set<UMLAttribute> attributes; 
    815  
    816                 /** 
    817                  * @param attributes 
    818                  */ 
    819                 public CheckMulteplicity(Set<UMLAttribute> attributes) { 
    820                         super(); 
    821                         this.attributes = attributes; 
    822                 } 
    823  
    824                 /* 
    825                  * (non-Javadoc) 
    826                  *  
    827                  * @see java.util.concurrent.Callable#call() 
    828                  */ 
    829                 @Override 
    830                 public Object call() throws Exception { 
    831                         for (UMLAttribute attribute : attributes) { 
    832                                 // should throws an Exception 
    833                                 if (attribute.getClassifier() == null) 
    834                                         continue; 
    835                                  
    836                                 UML_Element umlElement = getUMLClassDefinition(attribute.getClassifier()); 
    837                                 if (umlElement == null) { 
    838                                         // logger.warn("Cannot find the element associated with " + 
    839                                         // attribute.getClassifier()); 
    840                                         continue; 
    841                                 } 
    842  
    843                                 String elementName = umlElement.getName(); 
    844                                 boolean molt = false; 
    845                                 if (umlElement instanceof UMLDataType) { 
    846                                         elementName = GenerateModule.extractEmbeddedType(umlElement.getName()); 
    847                                         molt = GenerateModule.hasMolteplicity((UMLDataType) umlElement); 
    848                                 } else { 
    849                                         molt = hasMolteplicity(attribute); 
    850                                 } 
    851                                 multeplicity.put(elementName, molt); 
    852                         } 
    853                         return null; 
    854                 } 
    855         } 
    856  
    857822        public Properties loadProperties(PropertyMap propertiesFile) { 
    858823                Properties props = new Properties(); 
     
    877842                return index > -1 ? valueTagged.getUmlTaggedValues().get(index).getValue() : null; 
    878843        } 
     844         
     845        /** 
     846         * Verifies if the given valueTagged element has been defined as <code>Set<code>. This is done checking 
     847         * if the element owns a TaggedValue named {@link Dictionary#TYPE} whose value is formatted like 
     848         * <code>Set<One_Class_Name></code>. 
     849         * This kind of structure is usually found in classes attribute's whose stereotype is Union 
     850         * @param valueTagged the UMLValueTagged element  
     851         **/ 
     852        public boolean isSetType(UMLValueTagged valueTagged) { 
     853                String value = getTaggedValue(valueTagged, Dictionary.TYPE); 
     854                if (value == null) 
     855                        return false; 
     856                return (value.startsWith("Set<") || value.startsWith("Set&lt;")); 
     857        } 
     858         
     859        public Set<ClassModel> getClassModel() { 
     860                return modelClasses; 
     861        } 
     862         
     863        public ClassModel getClassModelByUMLClass(UMLClassDataType umlClass) { 
     864                ClassModel cm = null; 
     865                Iterator<ClassModel> iter = getClassModel().iterator(); 
     866                while (iter.hasNext()) { 
     867                        cm = iter.next(); 
     868                        if (cm.getAssociatedClass().equals(umlClass)) 
     869                                return cm; 
     870                } 
     871                return null; 
     872        } 
     873 
    879874} 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/GenerateClasses.java

    r7974 r7998  
    3030 
    3131import java.io.File; 
     32import java.io.FileWriter; 
    3233import java.io.IOException; 
    33 import java.util.ArrayList; 
     34import java.io.Writer; 
    3435import java.util.Arrays; 
    35 import java.util.HashMap; 
     36import java.util.Collection; 
    3637import java.util.HashSet; 
    3738import java.util.Iterator; 
    3839import java.util.List; 
    39 import java.util.Map; 
    4040import java.util.Set; 
    4141 
     
    4444import ndg.services.newmoon.velocity.python.support.ASCodeList; 
    4545import ndg.services.newmoon.velocity.python.support.ASEnumeration; 
     46import ndg.services.newmoon.velocity.python.support.ASUnion; 
    4647import ndg.services.newmoon.velocity.python.support.AttributeModel; 
     48import ndg.services.newmoon.velocity.python.support.ClassModel; 
     49import ndg.services.newmoon.velocity.python.support.ExportModel; 
     50import ndg.services.newmoon.velocity.python.support.ClassModel.STEREOTYPE; 
    4751import ndg.services.newmoon.velocity.python.support.SimpleKeyValue; 
    4852import ndg.services.newmoon.xmiModel.UMLAttribute; 
     
    6064 *  
    6165 */ 
    62 public class GenerateClasses extends GenerateFromTemplate<UMLClass>{ 
    63  
     66public class GenerateClasses extends GenerateFromTemplate<ClassModel> { 
     67 
     68        /** 
     69         * Some element name can have a format like  
     70         * <ul> 
     71         * <li>Set&lt;GF_FeatureType&gt;</li> 
     72         * <li>Sequence&lt;MD_Dimension&gt;</li> 
     73         * <li>&lt;undefined&gt;</li> 
     74         * </ul> 
     75         *  
     76         * In this cases the element is described as a <code>Set</code> 
     77         * or a <code>Sequence</code> or <code>undefined</code> and the type  
     78         * is the one between the brackets 
     79         **/ 
     80        public enum EmbeddedType {NONE, SET, SEQUENCE, DICTIONARY, TRANSFINITE_SET} 
     81         
    6482        private enum CONTEXT { 
    65                 umlClass, asCodeList, asEnumeration, asUnion, asDataType, imports, generalization, attributes 
     83                classModel 
    6684        }; 
    6785 
     
    7593 
    7694        private final static String templateFile = "velocity/python/pythonClass.vm"; 
    77          
    78         private final List<UMLClass> classes; 
    79         private final File classesDir; 
    80         private List<AttributeModel> ams = new ArrayList<AttributeModel>(); 
    8195 
    8296        private final Logger logger = LoggerFactory.getLogger(GenerateClasses.class); 
    8397 
    84         private final List<String> pythonReservedWords = Arrays.asList("False", "None", "True", "and", 
    85                         "as", "assert", "break", "class", "continue", 
    86                         "def", "del", "elif", "else", "except", "finally", "for", "from", "global", 
    87                         "if", "import", "in", "is", "lambda", "nonlocal", "not", "or", "pass", 
    88                         "raise", "return", "try", "while", "with", "yield"); 
     98        private final List<String> pythonReservedWords = Arrays.asList("False", "None", "True", "and", "as", "assert", 
     99                        "break", "class", "continue", "def", "del", "elif", "else", "except", "finally", "for", "from", "global", 
     100                        "if", "import", "in", "is", "lambda", "nonlocal", "not", "or", "pass", "raise", "return", "try", "while", 
     101                        "with", "yield"); 
    89102         
    90103        /** 
    91104         * @param packageBase 
    92105         */ 
    93         public GenerateClasses(List<UMLClass> classes, File classesDir, GenerateModuleHelper helper) { 
    94                 super(helper); 
    95                 this.classes = classes; 
    96                 this.classesDir = classesDir; 
    97         } 
    98  
    99         public void execute() throws IOException, NewmoonException { 
    100                 if (classes == null || classes.size() == 0) 
    101                         return; 
    102  
    103                 for (UMLClass umlClass : classes) { 
    104                         try { 
    105                                 execute(new File(classesDir, umlClass.getName().toLowerCase() + ".py"), umlClass);       
    106                         } catch (RuntimeException e) { 
    107                                 e.printStackTrace(); 
    108                         } catch (Throwable e) { 
    109                                 e.printStackTrace(); 
    110                         } 
     106        public GenerateClasses(List<UMLClass> umlClasses) { 
     107                super(umlClasses); 
     108        } 
     109 
     110        protected void writeAll() throws IOException { 
     111                Iterator<ClassModel> iter = getModels().iterator(); 
     112                while (iter.hasNext()) { 
     113                        ClassModel cm = iter.next();                     
     114 
     115                        if (skipIt(cm)) 
     116                                continue; 
    111117                         
    112                 } 
    113         }        
    114          
    115         /* (non-Javadoc) 
    116          * @see ndg.services.newmoon.velocity.python.GenerateFromTemplate#getTemplateFile() 
     118                        getVcontext().put(CONTEXT.classModel.name(), cm);        
     119                        File fl = new File(getHelper().generatePythonPackage(cm.getAssociatedClass().getUmlPackage()), cm.getAssociatedClass().getName().toLowerCase() + ".py"); 
     120                        Writer sqlTablesWriter = new FileWriter(fl, true); 
     121                        sqlTablesWriter.append(NmVelocity.getInstance().fillTemplate(getVcontext(), templateFile));              
     122                        sqlTablesWriter.close();                         
     123                } 
     124        } 
     125 
     126        /* 
     127         * (non-Javadoc) 
     128         *  
     129         * @see 
     130         * ndg.services.newmoon.velocity.python.GenerateFromTemplate#collectData 
     131         * (java.lang.Object) 
    117132         */ 
    118133        @Override 
    119         protected String getTemplateFile() {             
    120                 return templateFile; 
    121         }        
    122          
     134        protected void collectData(ClassModel cm) throws NewmoonException, IOException { 
     135                UMLStereotype stereotype = getStereotype(cm.getAssociatedClass()); 
     136                processStereotype(cm, stereotype); 
     137                collectGeneralization(cm, stereotype); 
     138                collectAttributes(cm); 
     139        } 
     140 
     141        protected AttributeModel defineSimpleAttribute(UML_ID type, UMLValueTagged valueTagged, ExportModel attributeOwner) 
     142                        throws NewmoonException, IOException { 
     143                return extractSimpleAttribute(type, valueTagged, attributeOwner); 
     144        } 
     145 
     146        private boolean skipIt(ClassModel cm) { 
     147                return cm.getAssociatedClass().getClass().equals(ASEnumeration.class)  
     148                                || cm.getAssociatedClass().getClass().equals(ASCodeList.class) 
     149                                || cm.getAssociatedClass().getClass().equals(ASUnion.class); 
     150        } 
     151 
    123152        /* (non-Javadoc) 
    124          * @see ndg.services.newmoon.velocity.python.GenerateFromTemplate#collectData(java.lang.Object) 
     153         * @see ndg.services.newmoon.velocity.python.GenerateFromTemplate#createExternalModel(ndg.services.newmoon.xmiModel.UMLClass) 
    125154         */ 
    126155        @Override 
    127         protected void collectData(UMLClass data) throws NewmoonException, IOException{ 
    128                 getVcontext().put(CONTEXT.umlClass.name(), data);                
    129                 UMLStereotype stereotype = collectStereotypes(data); 
    130                 collectGeneralization(data, stereotype); 
    131                 collectAttributes(data); 
    132  
    133                 // finally add all the module imports 
    134                 getVcontext().put(CONTEXT.imports.name(), getImportCollector().getImportMap());          
    135         } 
    136  
    137         protected void defineSimpleAttribute(UML_ID type, UMLValueTagged valueTagged, UMLClass attributeOwner) throws NewmoonException, IOException { 
    138                 ams.add(extractSimpleAttribute(type, valueTagged, attributeOwner)); 
    139         }        
    140          
    141         /** 
    142          * Removes '(', ')', and if the first character is a number substitutes it with 'a' 
     156        protected ClassModel createExternalModel(UMLClass umlClass) { 
     157                return new ClassModel(umlClass); 
     158        } 
     159 
     160        /** 
     161         * Removes '(', ')', and if the first character is a number substitutes it 
     162         * with 'a' 
    143163         * */ 
    144         private String adaptName(String name){ 
     164        private String adaptName(String name) { 
    145165                if (pythonReservedWords.contains(name)) 
    146166                        return "a_" + name; 
    147                  
    148                 return name.replaceAll("[()]", "") 
    149                                 .replaceFirst("\\A\\d", "a");            
    150         } 
    151          
     167 
     168                return name.replaceAll("[()]", "").replaceFirst("\\A\\d", "a"); 
     169        } 
     170 
    152171        private UMLStereotype getStereotype(UMLClass umlClass) { 
    153                 Set<UMLStereotype> stereotypes = getHelper().getImplementations(umlClass.getUmlStereotypes()); 
    154                   
    155                 //For now I assume a single stereotype 
     172                Set<UMLStereotype> stereotypes = getImplementations(umlClass.getUmlStereotypes()); 
     173 
     174                // For now I assume a single stereotype 
    156175                if (CollectionUtils.isEmpty(stereotypes)) 
    157176                        return null; 
    158                  
    159                 return (UMLStereotype)CollectionUtils.get(stereotypes.iterator(), 0);            
    160         } 
    161          
    162         private SS getStereotypeType(UMLStereotype stereotype) { 
     177 
     178                return (UMLStereotype) CollectionUtils.get(stereotypes.iterator(), 0); 
     179        } 
     180 
     181        private STEREOTYPE getStereotypeType(UMLStereotype stereotype) { 
     182                if (stereotype == null) 
     183                        return null; 
     184 
     185                if (stereotype.getName().equalsIgnoreCase(STEREOTYPE.Enumeration.name())) 
     186                        return STEREOTYPE.Enumeration; 
     187 
     188                if (stereotype.getName().equalsIgnoreCase(STEREOTYPE.CodeList.name())) 
     189                        return STEREOTYPE.CodeList; 
     190 
     191                if (stereotype.getName().equalsIgnoreCase(STEREOTYPE.DataType.name())) 
     192                        return STEREOTYPE.DataType; 
     193 
     194                if (stereotype.getName().equalsIgnoreCase(STEREOTYPE.Union.name())) 
     195                        return STEREOTYPE.Union; 
     196 
     197                return STEREOTYPE.None; 
     198        } 
     199 
     200        private UMLClass getStereotypeDummy(STEREOTYPE stereotype) { 
    163201                if (stereotype == null) 
    164202                        return null; 
    165203                 
    166                 if (stereotype.getName().equalsIgnoreCase(SS.Enumeration.name()))  
    167                         return SS.Enumeration; 
    168                  
    169                 if (stereotype.getName().equalsIgnoreCase(SS.CodeList.name()))  
    170                         return SS.CodeList; 
    171                  
    172                 if (stereotype.getName().equalsIgnoreCase(SS.DataType.name())) 
    173                         return SS.DataType; 
    174                          
    175                 if (stereotype.getName().equalsIgnoreCase(SS.Union.name())) 
    176                         return SS.Union; 
    177  
    178                 return null; 
    179         } 
    180          
    181         private UMLClass getStereotypeDummy(SS stereotype) { 
    182204                switch (stereotype) { 
    183205                case Enumeration: 
     
    185207                case CodeList: 
    186208                        return new ASCodeList(); 
     209                case Union: 
     210                        return new ASUnion();                    
    187211                default: 
    188212                        break; 
     
    191215                return null; 
    192216        } 
    193          
    194         private UMLStereotype collectStereotypes(UMLClass umlClass) { 
    195                 UMLStereotype stereotype = getStereotype(umlClass); 
     217 
     218        private void processStereotype(ClassModel cm, UMLStereotype stereotype) throws NewmoonException, IOException { 
     219                if (stereotype == null) 
     220                        return; 
     221 
     222                UMLClass umlClass = cm.getAssociatedClass(); 
     223 
     224                cm.setStereotype(getStereotypeType(stereotype)); 
    196225                 
    197                 if (stereotype == null) 
    198                                 return null; 
    199  
    200                 SS res = getStereotypeType(stereotype); 
    201                  
    202                 if (res == null) 
    203                         return null; 
    204                  
    205                 List<SimpleKeyValue> ret = new ArrayList<SimpleKeyValue>(); 
    206                 CONTEXT context = null;  
    207                 switch (res) { 
     226 
     227                if (cm.getStereotype().equals(STEREOTYPE.None)) 
     228                        return; 
     229 
     230                List<SimpleKeyValue> ret = cm.getSimpleKeyValues(); 
     231                switch (cm.getStereotype()) { 
    208232                case Enumeration: 
    209                         context = CONTEXT.asEnumeration; 
     233                case CodeList: 
    210234                        for (UMLAttribute attribute : umlClass.getAttributes()) { 
    211235                                ret.add(new SimpleKeyValue(adaptName(attribute.getName()), attribute.getName())); 
     
    213237                        break; 
    214238 
    215                 case CodeList: 
    216                         context = CONTEXT.asCodeList; 
    217                         for (UMLAttribute attribute : umlClass.getAttributes()) { 
    218                                 ret.add(new SimpleKeyValue(adaptName(attribute.getName()), attribute.getName())); 
    219                         } 
    220                         break; 
    221                          
    222239                case DataType: 
    223                         context = CONTEXT.asDataType; 
    224                         break;   
     240                        break; 
    225241 
    226242                case Union: 
    227                         collectASUnion(umlClass); 
    228                         getVcontext().put(CONTEXT.asUnion.name(), ret); 
    229                         break; 
    230                          
     243                        //done later by the collectAttribute 
     244                        break; 
     245 
    231246                default: 
    232247                        break; 
    233248                } 
    234  
    235                 if (context != null) 
    236                         getVcontext().put(context.name(), ret); 
    237                  
    238                 return stereotype; 
    239         } 
    240  
    241         private void collectAttributes(UMLClass umlClass) throws NewmoonException, IOException { 
    242                 if (getVcontext().containsKey(CONTEXT.asEnumeration)  
    243                                 || getVcontext().containsKey(CONTEXT.asCodeList) 
    244                                 || getVcontext().containsKey(CONTEXT.asUnion)) 
     249        } 
     250         
     251        private void collectAttributes(ClassModel cm) throws NewmoonException, IOException { 
     252                UMLClass umlClass = cm.getAssociatedClass(); 
     253                if (cm.isEnumeration() || cm.isCodeList()) 
    245254                        return; 
    246255 
    247256                if (umlClass.getAttributes().size() == 0) 
    248257                        return; 
     258                cm.getAttributeModel().addAll(collectSimpleAttributes(cm)); 
    249259                 
    250                 ams.clear(); 
    251                 collectSimpleAttributes(umlClass); 
    252                 getVcontext().put(CONTEXT.attributes.name(), ams); 
    253         } 
    254  
    255         private <T extends UML_ID> Map<String, UnionElement> collectASUnion(UMLClass umlClass) { 
    256                 Map<String, UnionElement> ret = new HashMap<String, UnionElement>(); 
    257                 UMLClass type = null; 
    258  
    259                 for (UMLAttribute attribute : umlClass.getAttributes()) { 
    260                         type = (UMLClass) UMLElementsArchive.getInstance().getUMLClassDefinition(attribute.getClassifier()); 
    261  
    262                         if (type == null) { 
    263                                 logger.error("Canont find the associated UMLClass!"); 
    264                                 continue; 
    265                                 // Temporarely suspended 
    266                                 // throw new 
    267                                 // NullPointerException("Canont find the associated UMLClass!"); 
     260                //If isUnion has to import the used classes type 
     261                if (cm.isUnion()){ 
     262                        Iterator<AttributeModel> amIter = cm.getAttributeModel().iterator(); 
     263                        while (amIter.hasNext()) { 
     264                                AttributeModel am = amIter.next(); 
     265                                //commented just because of an error. This class will be deleted soon 
     266                                //cm.getImportCollector().updateImports(am.getAssociatedClass()); 
    268267                        } 
    269  
    270                         ret.put(adaptName(attribute.getName()), new UnionElement(type.getName(), GenerateModule.embeddedType(type.getName()))); 
    271                         getImportCollector().updateImports(type); 
    272                 } 
    273                 return ret; 
     268                } 
    274269        } 
    275270 
     
    287282         * @param importCollector 
    288283         *            the instance in charge to collect all the import statements 
     284         * @throws IOException  
     285         * @throws NewmoonException  
    289286         * */ 
    290         private UMLClass collectGeneralization(UMLClass umlClass, UMLStereotype stereotype) { 
    291                  
    292                  
     287        private UMLClass collectGeneralization(ClassModel cm, UMLStereotype stereotype) throws NewmoonException, IOException { 
     288                UMLClass umlClass = cm.getAssociatedClass(); 
     289 
    293290                UMLClass clazz = null; 
    294                 Set<UML_ID> superitems = new HashSet<UML_ID>(); 
    295  
    296                 // Process the superclasses                      
     291 
     292                // Process the superclasses 
    297293                Set<UMLClass> supertypes = UMLElementsArchive.getInstance().getSupertypesForUMLClass(umlClass); 
    298                  
     294 
    299295                Iterator<UMLClass> items = supertypes.iterator(); 
    300                  
     296 
    301297                boolean addStereotype = true; 
    302                  
    303                 while(items.hasNext()) { 
    304                         UMLClass item = items.next(); 
    305                         if (stereotype != null && getStereotypeType(stereotype).equals(getStereotypeType(getStereotype(item)))) 
     298                UMLClass item = null; 
     299                while (items.hasNext()) { 
     300                        item = items.next(); 
     301                        STEREOTYPE first = getStereotypeType(stereotype); 
     302                        STEREOTYPE second = getStereotypeType(getStereotype(item)); 
     303                        if (stereotype != null && first != null && second != null && first.equals(second)) 
    306304                                addStereotype = false; 
    307                                  
    308                         CollectionUtils.addIgnoreNull(superitems, item); 
    309                         getImportCollector().updateImports(item); 
    310                 } 
    311                  
     305                                         
     306                        CollectionUtils.addIgnoreNull(cm.getParents(), processUMLclass(item)); 
     307                        cm.getImportCollector().updateImports(item); 
     308                } 
     309 
    312310                if (stereotype != null && (CollectionUtils.isEmpty(supertypes) || addStereotype)) { 
    313                         UMLClass ds = getStereotypeDummy(getStereotypeType(stereotype)); 
    314                         CollectionUtils.addIgnoreNull(superitems, ds); 
    315                         getImportCollector().updateImports(ds); 
    316                 } 
    317                                          
    318                 getVcontext().put(CONTEXT.generalization.name(), superitems); 
     311                        ClassModel dcm = new ClassModel(getStereotypeDummy(getStereotypeType(stereotype)));  
     312                        CollectionUtils.addIgnoreNull(cm.getParents(), dcm);                     
     313                        cm.getImportCollector().updateImports(dcm.getAssociatedClass()); 
     314                } 
     315 
    319316                return clazz; 
    320317        } 
    321318 
    322         @Override 
    323         protected void preExecute() throws NewmoonException { 
    324                 super.preExecute(); 
    325                 getImportCollector().clear(); 
    326         } 
     319        private <J, T extends UML_ID> Set<J> getImplementations(Collection<T> umlIDs) { 
     320                Set<J> superitems = new HashSet<J>(); 
     321                UML_ID clazz = null; 
     322                for (T id : umlIDs) { 
     323                        // clazz = (UMLClass) 
     324                        // UMLElementsArchive.getInstance().getElementImplementation(id); 
     325                        clazz = UMLElementsArchive.getInstance().getType(id); 
     326                        if (clazz == null && id instanceof UMLStereotype) { 
     327                                clazz = id; 
     328                        } 
     329                        CollectionUtils.addIgnoreNull(superitems, clazz); 
     330                } 
     331                return superitems; 
     332        } 
     333         
     334        /** 
     335         * @see EmbeddedType#EmbeddedType() 
     336         **/ 
     337        public EmbeddedType embeddedType(String className) { 
     338                if (className.matches("Sequence(&lt;|<).*(&gt;|>)")) 
     339                        return EmbeddedType.SEQUENCE; 
     340                if (className.matches("Sequence(&lt;|<).*(&gt;|>)")) 
     341                        return EmbeddedType.SET ; 
     342                if (className.matches("Dictionary(&lt;|<).*(&gt;|>)")) 
     343                        return EmbeddedType.DICTIONARY  ;                
     344                if (className.matches("TranfiniteSet(&lt;|<).*(&gt;|>)")) 
     345                        return EmbeddedType.DICTIONARY  ;                
     346                if (className.matches("(&lt;|<)undefined(&gt;|>)")) 
     347                        return EmbeddedType.NONE; 
     348                else  
     349                        return EmbeddedType.NONE;        
     350        } 
     351         
     352        public boolean hasMolteplicity(UMLClass umlDataType) { 
     353                 EmbeddedType type = embeddedType(umlDataType.getName()); 
     354                 if (type.equals(EmbeddedType.NONE)) { 
     355                         return false; 
     356                 } 
     357                 return true; 
     358        }        
    327359} 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/GenerateFromTemplate.java

    r7996 r7998  
    2929package ndg.services.newmoon.velocity.python; 
    3030 
    31 import java.io.File; 
    3231import java.io.IOException; 
     32import java.util.ArrayList; 
     33import java.util.HashSet; 
     34import java.util.List; 
    3335import java.util.Set; 
    3436 
     
    3638import ndg.services.newmoon.UMLElementsArchive; 
    3739import ndg.services.newmoon.velocity.python.support.AttributeModel; 
    38 import ndg.services.newmoon.velocity.python.support.ImportCollector; 
     40import ndg.services.newmoon.velocity.python.support.ClassModel.STEREOTYPE; 
     41import ndg.services.newmoon.velocity.python.support.ExportModel; 
    3942import ndg.services.newmoon.xmiModel.UMLAssociationEnd; 
    4043import ndg.services.newmoon.xmiModel.UMLAttribute; 
     
    4447import ndg.services.newmoon.xmiModel.v11.Dictionary; 
    4548 
     49import org.apache.commons.collections.CollectionUtils; 
    4650import org.apache.commons.lang.StringUtils; 
    4751import org.apache.commons.lang.math.NumberUtils; 
    48 import org.apache.velocity.VelocityContext; 
     52import org.apache.velocity.context.Context; 
    4953 
    5054/** 
     
    5256 *  
    5357 */ 
    54 public abstract class GenerateFromTemplate<T> { 
    55  
    56         private final ImportCollector importCollector = new ImportCollector(); 
    57         private final VelocityContext vcontext = new VelocityContext(); 
    58         private final GenerateModuleHelper helper; 
     58public abstract class GenerateFromTemplate<T extends ExportModel> { 
     59 
     60        private final Context vcontext = NmVelocity.getInstance().createContext(); 
     61        private GenerateModuleHelper helper; 
     62        private final List<UMLClass> umlClasses = new ArrayList<UMLClass>(); 
     63        private final Set<T> models = new HashSet<T>();  
     64  
    5965         
    6066        /** 
    6167         * @param helper 
    6268         */ 
    63         public GenerateFromTemplate(GenerateModuleHelper helper) { 
     69        public GenerateFromTemplate(List<UMLClass> umlClasses) { 
    6470                super(); 
    65                 this.helper = helper; 
    66         } 
    67          
    68         public void execute(File outputFile, T data) throws NewmoonException, IOException { 
    69                 try { 
    70                         preExecute(); 
    71                         collectData(data);       
    72                         postProcess(outputFile, fillTemplate().trim());                  
    73                 } catch (NewmoonException e) { 
    74                         return; 
    75                 }catch (RuntimeException e) { 
    76                         e.printStackTrace(); 
    77                 } catch (Throwable e) { 
    78                         e.printStackTrace(); 
    79                 }                
    80         } 
    81          
    82         /** 
    83          * @return the helper 
    84          */ 
    85         protected GenerateModuleHelper getHelper() { 
    86                 return helper; 
     71                this.umlClasses.addAll(umlClasses); 
     72        } 
     73         
     74        public void execute() throws IOException, NewmoonException { 
     75                this.helper = new GenerateModuleHelper(); 
     76                loopOnClasses(); 
     77                writeAll(); 
     78        } 
     79         
     80        /** 
     81         * @return the models 
     82         */ 
     83        protected Set<T> getModels() { 
     84                return models; 
    8785        } 
    8886 
     
    9290        abstract protected void collectData(T data) throws NewmoonException, IOException; 
    9391 
    94         abstract protected void defineSimpleAttribute(UML_ID type, UMLValueTagged valueTagged, UMLClass attributeOwner) 
     92        abstract protected AttributeModel defineSimpleAttribute(UML_ID type, UMLValueTagged valueTagged, ExportModel exportOwner) 
    9593                        throws NewmoonException, IOException; 
    9694         
    97         /** 
    98          * Returns the file name of the template to be filled  
    99          * */ 
    100         abstract protected String getTemplateFile(); 
    101          
    102         protected UML_ID getElementImplementation(UML_ID refId) { 
    103                 return UMLElementsArchive.getInstance().getUMLClassDefinition(refId); 
    104         } 
    105          
    106         /** 
    107          * By default uses {@link UMLElementsArchive#writeToFile(File, String)}}. 
    108          *  
    109          * @return the importCollector 
    110          * @throws NewmoonException  
    111          */ 
    112         protected void postProcess(File outputFile, String output) throws NewmoonException, IOException { 
    113                 try { 
    114                         getHelper().writeToFile(outputFile, output); 
    115                 } catch (IOException e) { 
    116                         throw new NewmoonException(); 
    117                 } 
    118         }                
    119          
    120         /** 
    121          * Fills the template with the vcontext generated by the {@link GenerateFromTemplate#collectData(Object)} method 
    122          *  
    123          * @return the importCollector 
    124          */ 
    125         protected String fillTemplate() { 
    126                 return NmVelocity.getInstance().fillTemplate(vcontext, getTemplateFile()); 
     95        protected abstract void writeAll() throws IOException; 
     96         
     97        protected abstract T createExternalModel(UMLClass umlClass); 
     98         
     99        protected T processUMLclass(UMLClass umlClass) throws NewmoonException, IOException { 
     100                if (!processInnerModel(umlClass)) 
     101                        return null;                     
     102                T tm = getExternalModel(umlClass); 
     103                collectData(tm); 
     104                return tm; 
     105        } 
     106         
     107        /** 
     108         * @return the helper 
     109         */ 
     110        protected GenerateModuleHelper getHelper() { 
     111                return helper; 
     112        } 
     113         
     114        /** 
     115         * @return the umlClasses 
     116         */ 
     117        protected List<UMLClass> getUmlClasses() { 
     118                return umlClasses; 
     119        } 
     120 
     121        /** 
     122         * @return the vcontext 
     123         */ 
     124        protected Context getVcontext() { 
     125                return vcontext; 
    127126        }        
    128127         
    129         /** 
    130          * @return the importCollector 
    131          */ 
    132         protected ImportCollector getImportCollector() { 
    133                 return importCollector; 
    134         } 
    135  
    136         /** 
    137          * @return the vcontext 
    138          */ 
    139         protected VelocityContext getVcontext() { 
    140                 return vcontext; 
    141         } 
    142  
    143         protected void preExecute() throws NewmoonException { 
    144                 for(Object key : getVcontext().getKeys()) { 
    145                         getVcontext().remove(key); 
    146                 } 
    147         }        
    148          
    149         protected AttributeModel extractSimpleAttribute(UML_ID type, UMLValueTagged valueTagged, UMLClass attributeOwner) 
     128        protected Set<AttributeModel> collectSimpleAttributes(ExportModel attributeOwner) throws NewmoonException, IOException { 
     129                Set<AttributeModel> ret = new HashSet<AttributeModel>(); 
     130                UMLClass umlClass = attributeOwner.getAssociatedClass(); 
     131                for (UMLAttribute umlAttribute : umlClass.getAttributes()) { 
     132                        ret.add(defineSimpleAttribute(umlAttribute.getClassifier(), umlAttribute, attributeOwner)); 
     133                } 
     134 
     135                Set<UMLAssociationEnd> targets = UMLElementsArchive.getInstance().getAssociationEndsForUMLClass(umlClass); 
     136                for (UMLAssociationEnd end : targets) { 
     137                        ret.add(defineSimpleAttribute(end.getType(), end, attributeOwner)); 
     138                } 
     139                return ret; 
     140        } 
     141         
     142        protected T getExternalModel(UMLClass umlClass) { 
     143                T tm = createExternalModel(umlClass); 
     144                synchronized (getModels()) { 
     145                        if (getModels().contains(tm)) { 
     146                                for (T model : getModels()) { 
     147                                        if (model.equals(tm)) 
     148                                                return model; 
     149                                } 
     150                        } 
     151                        getModels().add(tm); 
     152                } 
     153                return tm; 
     154        } 
     155         
     156        protected AttributeModel extractSimpleAttribute(UML_ID type, UMLValueTagged valueTagged, ExportModel attributeOwner) 
    150157                        throws NewmoonException, IOException { 
    151                 UMLClass attributeType = UMLElementsArchive.getInstance().getUMLClassDefinition(type); 
     158                 
     159                //possibly refactor to eliminate thecasting 
     160                UMLClass attributeType = (UMLClass)UMLElementsArchive.getInstance().getType(type); 
    152161 
    153162                if (attributeType == null) 
     
    162171                String upperBound = StringUtils.defaultIfEmpty( 
    163172                                UMLElementsArchive.getInstance().getTaggedValue(valueTagged, Dictionary.UPPER_BOUND), "1"); 
    164                 boolean hasMultiplicity = false; 
     173                 
     174                boolean hasMultiplicity = false;         
     175 
    165176                boolean voidable = false; 
    166177                 
     
    172183                        hasMultiplicity = UMLElementsArchive.getInstance().hasMolteplicity((UMLAssociationEnd) valueTagged); 
    173184 
     185                //Sometime the attribute has an additional definition 
     186                if (UMLElementsArchive.getInstance().isSetType(valueTagged)) { 
     187                        hasMultiplicity = true; 
     188                } 
     189                 
    174190                upperBound = hasMultiplicity ? "*" : "1"; 
    175                 return new AttributeModel(attributeType, valueTagged.getName(), enumLike, lowerBound, upperBound, 
    176                                 length, voidable); 
    177         } 
    178          
    179         protected void collectSimpleAttributes(UMLClass attributeOwner) throws NewmoonException, IOException { 
    180                 for (UMLAttribute umlAttribute : attributeOwner.getAttributes()) { 
    181                         defineSimpleAttribute(umlAttribute.getClassifier(), umlAttribute, attributeOwner); 
    182                 } 
    183  
    184                 Set<UMLAssociationEnd> targets = UMLElementsArchive.getInstance().getAssociationEndsForUMLClass(attributeOwner); 
    185                 for (UMLAssociationEnd end : targets) { 
    186                         defineSimpleAttribute(end.getType(), end, attributeOwner); 
    187                 } 
    188         } 
     191                //commented just because of an error. This class will be deleted soon 
     192                //return new AttributeModel(attributeType, valueTagged.getName(), lowerBound, upperBound, 
     193                //              length, voidable); 
     194                return null; 
     195        }        
     196         
     197        private boolean processInnerModel(UMLClass umlClass) { 
     198                if (getModels().contains(createExternalModel(umlClass))) 
     199                        return false; 
     200 
     201                T model = getExternalModel(umlClass); 
     202                if (model.isSkipIt()) 
     203                        return false; 
     204 
     205                return true; 
     206        } 
     207         
     208        private void loopOnClasses() throws NewmoonException, IOException { 
     209                if (CollectionUtils.isEmpty(getUmlClasses())) 
     210                        return; 
     211 
     212                for (UMLClass umlClass : getUmlClasses()) { 
     213                        try { 
     214                                processUMLclass(umlClass);       
     215                        } catch (Exception ex) { 
     216                                ex.printStackTrace(); 
     217                        }                        
     218                } 
     219        }        
    189220} 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/GenerateModuleHelper.java

    r7974 r7998  
    3535import java.io.FileWriter; 
    3636import java.io.IOException; 
    37 import java.util.Collection; 
    38 import java.util.HashSet; 
    3937import java.util.Properties; 
    40 import java.util.Set; 
    4138 
    4239import ndg.services.newmoon.UMLElementsArchive; 
    4340import ndg.services.newmoon.UMLElementsArchive.PropertyMap; 
    44 import ndg.services.newmoon.velocity.python.GenerateClasses.SS; 
     41import ndg.services.newmoon.velocity.python.support.ClassModel.STEREOTYPE; 
    4542import ndg.services.newmoon.xmiModel.UMLClass; 
     43import ndg.services.newmoon.xmiModel.UMLClassDataType; 
    4644import ndg.services.newmoon.xmiModel.UMLModel; 
    4745import ndg.services.newmoon.xmiModel.UMLPackage; 
     
    5048import ndg.services.newmoon.xmiModel.adapter.UML_IDAdapder; 
    5149 
    52 import org.apache.commons.collections.CollectionUtils; 
    5350import org.apache.commons.io.FileUtils; 
    5451import org.apache.commons.lang.StringUtils; 
     
    6865        private final Logger logger = LoggerFactory.getLogger(UMLElementsArchive.class); 
    6966         
     67        @Deprecated 
    7068        public GenerateModuleHelper() throws IOException { 
    7169                baseDir = new File(GenerateModuleHelper.class.getClassLoader().getResource(".").getPath());                      
    7270        } 
     71         
     72        public GenerateModuleHelper(File baseDir) throws IOException { 
     73                this.baseDir = baseDir;                  
     74        } 
     75         
     76         
    7377         
    7478        /** 
     
    106110        */ 
    107111         
    108         public static boolean skipElement(UMLClass clazz){ 
     112        public static boolean skipElement(UMLClassDataType clazz){ 
    109113                return getXMIClassToSQLMap().containsKey(clazz.getName())  
    110114                                || clazz.getName().equals("EARootClass"); 
    111115        } 
    112116         
    113         public <J, T extends UML_ID> Set<J> getImplementations(Collection<T> umlIDs) { 
    114                 Set<J> superitems = new HashSet<J>(); 
    115                 UML_ID clazz = null; 
    116                 for (T id : umlIDs) { 
    117                         //clazz = (UMLClass) UMLElementsArchive.getInstance().getElementImplementation(id); 
    118                         clazz = UMLElementsArchive.getInstance().getUMLClassDefinition(id); 
    119                         if (clazz == null && id instanceof UMLStereotype) { 
    120                                 clazz = id;   
    121                         } 
    122                         CollectionUtils.addIgnoreNull(superitems, clazz); 
    123                 } 
    124                 return superitems; 
    125         } 
    126          
    127         public UMLClass getStereotype(Collection<UMLStereotype> stereotypes) { 
    128                 Set<UML_ID> superitems = getImplementations(stereotypes); 
    129117 
    130                 //I assume that there is no more than one stereotype 
    131                 //(is not right but for now it is) 
    132                 if (CollectionUtils.isNotEmpty(superitems)) { 
    133                         UML_ID ret = (UML_ID)CollectionUtils.get(superitems, 0); 
    134                         if (ret instanceof UMLClass) 
    135                                 return (UMLClass)ret; 
    136                 }                                                
    137                 return null; 
    138         } 
    139118         
    140119        public boolean isEnumLike(UMLClass umlClass) { 
    141                 if (SS.Boolean.name().equalsIgnoreCase(umlClass.getName())) 
     120                if (STEREOTYPE.Boolean.name().equalsIgnoreCase(umlClass.getName())) 
    142121                        return false; 
    143122                 
    144123                for (UMLStereotype stereotype : umlClass.getUmlStereotypes()) { 
    145                         UML_ID res = stereotype; 
     124                        UMLClass res = null; 
     125                        UML_ID umlId = null; 
    146126                        if (stereotype.isReferenceId()) { 
    147                                 res = UMLElementsArchive.getInstance().getUMLClassDefinition(new UML_IDAdapder(stereotype.getId(), stereotype.getModelId()));                    
     127                                umlId = UMLElementsArchive.getInstance().getType(new UML_IDAdapder(stereotype.getId(), stereotype.getModelId())); 
     128                                if (umlId instanceof UMLClass) 
     129                                        res = (UMLClass)umlId; 
    148130                        } 
    149131                         
    150132 
    151133                         
    152                         if (SS.Enumeration.name().equalsIgnoreCase(res.getName()) 
    153                                         || SS.CodeList.name().equalsIgnoreCase(res.getName())) 
     134                        if (STEREOTYPE.Enumeration.name().equalsIgnoreCase(res.getName()) 
     135                                        || STEREOTYPE.CodeList.name().equalsIgnoreCase(res.getName())) 
    154136                                return true; 
    155137                } 
     
    158140         
    159141        public File generatePythonPackage(UMLModel model) throws IOException { 
    160                 String path = StringUtils.replaceChars(model.toString(), '.', File.separatorChar).toLowerCase();                 
    161                 File file = new File(getBaseDir(), path); 
     142                File file =  
     143                        model == null ? getBaseDir() : 
     144                                        new File(getBaseDir(), StringUtils.replaceChars(model.toString(), '.', File.separatorChar).toLowerCase()); 
     145 
    162146                if (!file.exists()) { 
    163147                        FileUtils.forceMkdir(file); 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/GenerateTables.java

    r7996 r7998  
    4545import ndg.services.newmoon.velocity.python.support.AssociationTable; 
    4646import ndg.services.newmoon.velocity.python.support.AttributeModel; 
     47import ndg.services.newmoon.velocity.python.support.ExportModel; 
    4748import ndg.services.newmoon.velocity.python.support.ForeignKey; 
     49import ndg.services.newmoon.velocity.python.support.ImportCollector; 
    4850import ndg.services.newmoon.velocity.python.support.OverriddenAttribute; 
    4951import ndg.services.newmoon.velocity.python.support.Relationship; 
     
    5456import ndg.services.newmoon.xmiModel.UML_ID; 
    5557 
    56 import org.apache.commons.collections.CollectionUtils; 
    5758import org.apache.commons.lang.text.StrBuilder; 
    5859import org.slf4j.Logger; 
     
    6364 *  
    6465 */ 
    65 public class GenerateTables extends GenerateFromTemplate<UMLClass> { 
     66public class GenerateTables extends GenerateFromTemplate<TableModel> { 
    6667 
    6768        private enum CONTEXT { 
     
    6970        }; 
    7071 
    71         private final List<UMLClass> umlClasses = new ArrayList<UMLClass>(); 
    72  
     72        private final ImportCollector importCollector = new ImportCollector(); 
     73         
    7374        private final Logger logger = LoggerFactory.getLogger(GenerateTables.class); 
    7475 
     
    8889        private final static String associationTemplateFile = "velocity/python/association.vm"; 
    8990 
    90         private final Set<TableModel> tableModels = new HashSet<TableModel>(); 
    9191        private final Set<AssociationTable> associationTable = new HashSet<AssociationTable>(); 
    9292        private final Set<TableModel> notSortable = new HashSet<TableModel>(); 
     
    9595         * @param umlClasses the classes for which have to be generated a table instance 
    9696         */ 
    97         public GenerateTables(List<UMLClass> umlClasses, GenerateModuleHelper helper) { 
    98                 super(helper); 
    99                 this.umlClasses.addAll(umlClasses); 
    100         } 
    101  
    102         public void execute() throws IOException, NewmoonException { 
    103                 loopOnClasses(); 
    104                 writeAll(); 
    105  
    106         } 
    107  
    108         private void loopOnClasses() throws NewmoonException, IOException { 
    109                 if (CollectionUtils.isEmpty(umlClasses)) 
    110                         return; 
    111  
    112                 for (UMLClass umlClass : umlClasses) { 
    113                         if (processTableModel(umlClass)) 
    114                                 updateImportToSQLTables(umlClass); 
    115                                 execute(null, umlClass); 
    116                 } 
    117         } 
    118  
    119         private boolean processTableModel(UMLClass umlClass) { 
    120                 if (tableModels.contains(new TableModel(umlClass))) 
    121                         return false; 
    122  
    123                 TableModel model = getTableModel(umlClass); 
    124                 if (model.isSkipIt()) 
    125                         return false; 
    126  
    127                 return true; 
    128         } 
    129  
    130         /* 
    131          * (non-Javadoc) 
    132          *  
    133          * @see 
    134          * ndg.services.newmoon.velocity.python.GenerateFromTemplate#getTemplateFile 
    135          * () 
    136          */ 
    137         @Override 
    138         protected String getTemplateFile() { 
    139                 return tableTemplateFile; 
     97        public GenerateTables(List<UMLClass> umlClasses) { 
     98                super(umlClasses); 
    14099        } 
    141100 
     
    148107         */ 
    149108        @Override 
    150         protected void collectData(UMLClass data) throws NewmoonException, IOException { 
    151                 collectSimpleAttributes(data); 
    152                 collectInheritedParents(data); 
    153                 updateImportToSQLTables(data); 
    154         } 
    155  
    156         /* 
    157          * (non-Javadoc) 
    158          *  
    159          * @see 
    160          * ndg.services.newmoon.velocity.python.GenerateFromTemplate#postProcess 
    161          * (java.io.File, java.lang.String) 
     109        protected void collectData(TableModel tm) throws NewmoonException, IOException { 
     110                updateImportToSQLTables(tm.getAssociatedClass()); 
     111                collectSimpleAttributes(tm); 
     112                collectInheritedParents(tm); 
     113                updateImportToSQLTables(tm.getAssociatedClass()); 
     114        } 
     115         
     116        /* (non-Javadoc) 
     117         * @see ndg.services.newmoon.velocity.python.GenerateFromTemplate#createExternalModel(ndg.services.newmoon.xmiModel.UMLClass) 
    162118         */ 
    163119        @Override 
    164         protected void postProcess(File outputFile, String output) throws NewmoonException, IOException { 
    165  
    166         } 
    167  
    168         private void collectInheritedParents(UMLClass umlClass) throws NewmoonException, IOException { 
    169                 TableModel tm = getTableModel(umlClass); 
    170                 for (UMLClass parent : UMLElementsArchive.getInstance().getSupertypesForUMLClass(umlClass)) { 
    171                         // Check if for the specific class has been already created a Table 
    172                         if (processTableModel(parent)) { 
    173                                 execute(null, parent); 
    174                         } 
    175                         TableModel parentTM = getTableModel(parent); 
    176                         parentTM.setHasChildren(true); 
    177                         tm.getInherited().add(getTableModel(parent)); 
    178                 } 
    179         } 
    180          
    181         protected void defineSimpleAttribute(UML_ID type, UMLValueTagged valueTagged, UMLClass attributeOwner) 
     120        protected TableModel createExternalModel(UMLClass umlClass) { 
     121                return new TableModel(umlClass); 
     122        } 
     123 
     124        private void collectInheritedParents(TableModel tm) throws NewmoonException, IOException { 
     125                for (UMLClass parent : UMLElementsArchive.getInstance().getSupertypesForUMLClass(tm.getAssociatedClass())) {                     
     126                        TableModel parentTM = processUMLclass(parent); 
     127                        if (parentTM != null) { 
     128                                parentTM.setHasChildren(true); 
     129                                tm.getInherited().add(getExternalModel(parent));                                 
     130                        } 
     131                } 
     132        } 
     133         
     134        protected AttributeModel defineSimpleAttribute(UML_ID type, UMLValueTagged valueTagged, ExportModel modelOwner) 
    182135                        throws NewmoonException, IOException { 
    183  
    184                 UMLClass attributeType = UMLElementsArchive.getInstance().getUMLClassDefinition(type); 
     136                 
     137                UMLClass attributeOwner = modelOwner.getAssociatedClass(); 
     138                 
     139                //possibly refactor to eliminate thecasting 
     140                UMLClass attributeType = (UMLClass)UMLElementsArchive.getInstance().getType(type); 
    185141                 
    186142                if (attributeType == null) 
    187                         return; 
    188                  
    189                 // Check if for the specific class has been already created a Table 
    190                 if (processTableModel(attributeType)) { 
    191                         execute(null, attributeType); 
    192                 } 
    193  
    194                 TableModel child = getTableModel(attributeType); 
     143                        return null; 
     144 
     145                TableModel child = processUMLclass(attributeType); 
    195146                updateImportToSQLTables(attributeType); 
    196                 TableModel parent = getTableModel(attributeOwner); 
    197                 AttributeModel am = extractSimpleAttribute(type, valueTagged, attributeOwner); 
     147                TableModel parent = getExternalModel(attributeOwner); 
     148                AttributeModel am = extractSimpleAttribute(type, valueTagged, modelOwner); 
    198149                 
    199150                /* Voidable should be manage with a "status" more than with a NULL column */ 
    200151                boolean nullable = am.getLowerBound().equals("0") || am.isVoidable(); 
    201152                 
    202                 if (!child.isSkipIt() && !am.isMapped()) { 
     153                if (!child.isSkipIt()/* && !am.isMapped()*/) { 
    203154                        // adds relations between the child table and a notSQL-type 
    204155                        // attribute 
     
    221172                        } 
    222173                } else { 
    223                         parent.getAm().add(am); 
    224                 } 
    225         } 
    226  
    227         private TableModel getTableModel(UMLClass associatedClass) { 
     174                        parent.getAttributeModel().add(am); 
     175                } 
     176                return null; 
     177        } 
     178 
     179        /* 
     180        protected TableModel getExternalModel(UMLClass associatedClass) { 
    228181 
    229182                // Check if for the specific class has been already created a Table 
     
    242195                return tm; 
    243196        } 
     197        */ 
    244198         
    245199        private <E> void applyTemplate(Collection<E> models, CONTEXT contextName, StrBuilder sb, String templateName){ 
     
    260214        } 
    261215         
    262         private void writeAll() throws IOException { 
     216        protected void writeAll() throws IOException { 
    263217                 
    264218                checkReciprocalTables(); 
     
    302256 
    303257                // import 
    304                 getVcontext().put(CONTEXT.imports.name(), getImportCollector().getImportMap()); 
     258                getVcontext().put(CONTEXT.imports.name(), importCollector.getImportMap()); 
    305259                sqlTablesWriter.append(NmVelocity.getInstance().fillTemplate(getVcontext(), importTemplateFile)); 
    306260                sqlTablesWriter.append("\n\n"); 
     
    315269                sqlTablesWriter.append("metadata.create_all(engine)\n"); 
    316270                sqlTablesWriter.append("\n\n"); 
    317                 sqlTablesWriter.flush(); 
    318271                sqlTablesWriter.close(); 
    319272        } 
    320273 
    321274        public void updateImportToSQLTables(UMLClass umlClass) { 
    322                 synchronized (getImportCollector()) { 
    323                         getImportCollector().updateImports(umlClass); 
    324                 } 
    325         } 
    326  
    327         @Override 
    328         protected void preExecute() throws NewmoonException { 
    329                 super.preExecute(); 
     275                synchronized (importCollector) { 
     276                        importCollector.updateImports(umlClass); 
     277                } 
    330278        } 
    331279 
    332280        private void checkReciprocalTables() { 
    333                 Iterator<TableModel> iterator = tableModels.iterator(); 
     281                Iterator<TableModel> iterator = getModels().iterator(); 
    334282                while (iterator.hasNext()) { 
    335283                        TableModel tb = iterator.next(); 
     
    353301        private void checkTableAttributeOverriding(TableModel tb){ 
    354302                Set<TableModel> ovm = new HashSet<TableModel>(); 
    355                 for (AttributeModel am : tb.getAm()) { 
     303                for (AttributeModel am : tb.getAttributeModel()) { 
    356304                        ovm.clear(); 
    357305                        for (TableModel inherited : tb.getInherited()) { 
    358                                 for (AttributeModel inhAttribute : inherited.getAm()) { 
     306                                for (AttributeModel inhAttribute : inherited.getAttributeModel()) { 
    359307                                        if(inhAttribute.getName().equals(am.getName())) { 
    360308                                                ovm.add(tb); 
     
    373321                while (iterator.hasNext()) { 
    374322                        Relationship rl = iterator.next(); 
    375                         LoopFinder lf = new LoopFinder(rl, tableModels.size()); 
     323                        LoopFinder lf = new LoopFinder(rl, getModels().size()); 
    376324                        lf.search(); 
    377325                } 
     
    565513        private List<TableModel> sortTableModels() { 
    566514                List<TableModel> finalTable = new ArrayList<TableModel>(); 
    567                 Iterator<TableModel> iter = tableModels.iterator(); 
     515                Iterator<TableModel> iter = getModels().iterator(); 
    568516                TableModel tb = null; 
    569                 notSortable.addAll(tableModels); 
     517                notSortable.addAll(getModels()); 
    570518                while (iter.hasNext()) { 
    571519                        tb = iter.next(); 
     
    577525 
    578526                int index = -1; 
    579                 while (finalTable.size() < tableModels.size()) { 
     527                while (finalTable.size() < getModels().size()) { 
    580528                        index = finalTable.size(); 
    581529                        if (logger.isDebugEnabled()) 
    582                                 logger.debug("finalTable.size() : tableModels.size() - " + String.valueOf(finalTable.size()) + ":" + String.valueOf(tableModels.size())); 
     530                                logger.debug("finalTable.size() : tableModels.size() - " + String.valueOf(finalTable.size()) + ":" + String.valueOf(getModels().size())); 
    583531                        updateFinalTable(finalTable); 
    584532                         
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/NmVelocity.java

    r7974 r7998  
    3636import org.apache.velocity.VelocityContext; 
    3737import org.apache.velocity.app.VelocityEngine; 
     38import org.apache.velocity.context.Context; 
    3839import org.apache.velocity.exception.MethodInvocationException; 
    3940import org.apache.velocity.exception.ParseErrorException; 
    4041import org.apache.velocity.exception.ResourceNotFoundException; 
    4142import org.apache.velocity.runtime.RuntimeConstants; 
     43import org.apache.velocity.tools.ToolManager; 
    4244import org.slf4j.Logger; 
    4345import org.slf4j.LoggerFactory; 
     
    5153        private final VelocityEngine ve = new VelocityEngine(); 
    5254        private final static NmVelocity instance = new NmVelocity(); 
     55        private final ToolManager tm = new ToolManager(); 
    5356 
    5457        String packageBase = NmVelocity.class.getClassLoader().getResource(".").getPath(); 
     
    7073                        in.close(); 
    7174                        ve.init(prop); 
     75                        tm.autoConfigure(true); 
    7276                } catch (Exception e) { 
    7377                        e.printStackTrace(); 
     
    7983        } 
    8084 
    81         public String fillTemplate(VelocityContext vcontext, String templateName) { 
     85        public Context createContext() { 
     86                return tm.createContext(); 
     87        } 
     88         
     89        public String fillTemplate(Context vcontext, String templateName) { 
    8290                vcontext.put("tab", "\t"); 
    8391                vcontext.put("nl", "\n"); 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/UnionElement.java

    r7974 r7998  
    3232package ndg.services.newmoon.velocity.python; 
    3333 
    34 import ndg.services.newmoon.velocity.python.GenerateModule.EmbeddedType; 
     34import ndg.services.newmoon.velocity.python.GenerateClasses.EmbeddedType; 
     35 
    3536 
    3637/** 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/support/AttributeModel.java

    r7996 r7998  
    3333 
    3434import ndg.services.newmoon.UMLElementsArchive.PropertyMap; 
    35 import ndg.services.newmoon.velocity.python.GenerateModuleHelper; 
    36 import ndg.services.newmoon.xmiModel.UMLClass; 
    37 import ndg.services.newmoon.xmiModel.adapter.UMLClassAdapter; 
    38 import ndg.services.newmoon.xmiModel.adapter.UML_IDAdapder; 
    39  
    40 import org.apache.commons.lang.StringUtils; 
     35import ndg.services.newmoon.xmiModel.UMLClassDataType; 
     36import ndg.services.newmoon.xmiModel.UML_ID; 
    4137 
    4238/** 
     39 * Represents a {@link ClassModel} attribute. 
     40 * Temporarily it use a pair associatedClass/associatedDataType 
     41 * to define itself. In future a cleaner solution would be to  
     42 * bind the associatedClass with a class implementing the specified UMLDataType   
     43 *  
    4344 * @author mnagni 
    4445 * 
    4546 */ 
    46 public class AttributeModel { 
    47         private final UMLClass associatedClass;  
    48         private final String name; 
    49         private final boolean enumLike;  
    50         private final String lowerBound; 
    51         private final String upperBound; 
     47public class AttributeModel<T extends UMLClassDataType> {        
     48        private final T associatedType; 
     49        private final ClassModel associatedClassModel; 
     50        private final String name;       
     51        private final Integer lowerBound; 
     52        private final Integer upperBound; 
    5253        private final int lenght; 
    5354        private final boolean voidable; 
     55         
    5456        /** 
    55          * @param associatedClass 
     57         * @param associatedType 
    5658         * @param name 
    57          * @param enumLike 
    5859         * @param lowerBound 
    5960         * @param upperBound 
    6061         * @param lenght 
    6162         */ 
    62         public AttributeModel(UMLClass associatedClass, String name, boolean enumLike, String lowerBound, 
    63                         String upperBound, int lenght, boolean voidable) { 
    64                 super(); 
    65                 this.associatedClass = associatedClass; 
     63        public AttributeModel(T associatedType, ClassModel associatedClassModel,  
     64                        String name, int lowerBound, Integer upperBound,  
     65                        Integer lenght, boolean voidable) { 
     66                this.associatedType = associatedType; 
     67                this.associatedClassModel = associatedClassModel;                
    6668                this.name = name; 
    67                 this.enumLike = enumLike; 
    6869                this.lowerBound = lowerBound; 
    6970                this.upperBound = upperBound; 
    7071                this.lenght = lenght; 
    71                 this.voidable = voidable;                
     72                this.voidable = voidable;                        
    7273        } 
     74         
     75        /** 
     76         * @return the associatedClassModel 
     77         * @deprecated probably in future will be merged in the associatedDataType 
     78         */ 
     79        public ClassModel getAssociatedClassModel() { 
     80                return associatedClassModel; 
     81        } 
     82 
     83        /** 
     84         * Returns the associated type. 
     85         * @return the associatedType 
     86         */ 
     87        public T getAssociatedType() { 
     88                return associatedType;                                                   
     89        }        
     90         
    7391        /** 
    7492         * Returns the associated UMLClass. If the UMLClass is mapped in the  
     
    7795         * @return the associatedClass 
    7896         */ 
     97        /* 
    7998        public UMLClass getAssociatedClass() { 
     99                if (associatedClass == null || associatedClass.getName() == null) 
     100                        return null; 
     101                 
    80102                String typeName = StringUtils.defaultIfEmpty( 
    81103                                GenerateModuleHelper.getXMIClassToSQLMap().getProperty(associatedClass.getName()), associatedClass.getName()); 
     
    86108                return new UMLClassAdapter(new UML_IDAdapder(null, null, typeName), false, false, false, null);                                                  
    87109        } 
    88          
    89         /** 
    90          * Verifies if the associated UMLClass is mapped by the {@link PropertyMap#XMI_TO_SQL_MAP} file. 
    91          * @return <code>true</code> if is mapped, <code>false</code> otherwise 
    92          **/ 
    93         public boolean isMapped() { 
    94                 String typeName = StringUtils.defaultIfEmpty( 
    95                                 GenerateModuleHelper.getXMIClassToSQLMap().getProperty(associatedClass.getName()), ""); 
    96                 return typeName.equals(associatedClass.getName()); 
    97         } 
     110        */ 
    98111         
    99112        public boolean hasMultiplicity() { 
    100                 return upperBound.equals("*")  
    101                                 || (StringUtils.isNumeric(upperBound) && Integer.parseInt(upperBound) > 1); 
     113                return upperBound > 1; 
    102114        } 
    103115         
     
    114126                return name; 
    115127        } 
    116         /** 
    117          * @return the enumLike 
    118          */ 
    119         public boolean isEnumLike() { 
    120                 return enumLike; 
    121         } 
     128 
    122129        /** 
    123130         * @return the lowerBound 
    124131         */ 
    125         public String getLowerBound() { 
     132        public Integer getLowerBound() { 
    126133                return lowerBound; 
    127134        } 
     
    129136         * @return the upperBound 
    130137         */ 
    131         public String getUpperBound() { 
     138        public Integer getUpperBound() { 
    132139                return upperBound; 
    133140        } 
     
    146153                final int prime = 31; 
    147154                int result = 1; 
    148                 result = prime * result + ((associatedClass == null) ? 0 : associatedClass.hashCode()); 
    149                 result = prime * result + (enumLike ? 1231 : 1237); 
     155                result = prime * result + ((associatedType == null) ? 0 : associatedType.hashCode()); 
    150156                result = prime * result + lenght; 
    151157                result = prime * result + ((lowerBound == null) ? 0 : lowerBound.hashCode()); 
     
    166172                        return false; 
    167173                AttributeModel other = (AttributeModel) obj; 
    168                 if (associatedClass == null) { 
    169                         if (other.associatedClass != null) 
     174                if (associatedType == null) { 
     175                        if (other.associatedType != null) 
    170176                                return false; 
    171                 } else if (!associatedClass.equals(other.associatedClass)) 
    172                         return false; 
    173                 if (enumLike != other.enumLike) 
     177                } else if (!associatedType.equals(other.associatedType)) 
    174178                        return false; 
    175179                if (lenght != other.lenght) 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/support/ImportCollector.java

    r7974 r7998  
    4040import ndg.services.newmoon.velocity.python.GenerateModuleHelper; 
    4141import ndg.services.newmoon.xmiModel.UMLClass; 
     42import ndg.services.newmoon.xmiModel.UMLClassDataType; 
     43import ndg.services.newmoon.xmiModel.UML_ID; 
    4244 
    4345import org.apache.commons.collections.CollectionUtils; 
    4446 
    4547/** 
     48 * Collects all the imports necessary for the to-be-created python class. 
     49 *  
     50 *  
    4651 * @author mnagni 
    4752 * 
     
    5055        private Map<String, Set<String>> importMap = new HashMap<String, Set<String>>(); 
    5156 
    52         public void updateImports(UMLClass umlClass) { 
     57        /** 
     58         * Updates the classes to import. 
     59         * The same as {@link #updateImports(UMLClass, boolean)} with the <code>doCheck<code> 
     60         * parameter set to <code>true</code> 
     61         **/ 
     62        public <T extends UMLClassDataType> void updateImports(T umlClass) { 
     63                updateImports(umlClass, true); 
     64        } 
     65         
     66        /** 
     67         * Updates the classes to import. If enabled, checks if the import should be avoided or not 
     68         * using the {@link GenerateModuleHelper.skipElement(umlClass)} method. 
     69         *    
     70         * @param umlClass The class to import 
     71         * @param doCheck If <code>false</code> will not check if the import is avoidable  
     72         **/ 
     73        public <T extends UMLClassDataType> void updateImports(T umlClass, boolean doCheck) { 
    5374                if (umlClass == null) 
    5475                        return; 
    5576 
    56                 if (GenerateModuleHelper.skipElement(umlClass)) 
     77                if (doCheck && GenerateModuleHelper.skipElement(umlClass)) 
    5778                        return; 
    5879                 
     
    6990        } 
    7091 
    71         private String getModule(UMLClass umlClass) { 
     92        private String getModule(UMLClassDataType umlClass) { 
    7293                return NmParserHelper.getPackageParentName(umlClass.getUmlPackage()) + "." + umlClass.getName().toLowerCase(); 
    7394        } 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/support/TableModel.java

    r7974 r7998  
    4242 * 
    4343 */ 
    44 public class TableModel implements Comparable<TableModel>{ 
     44public class TableModel implements ExportModel, Comparable<TableModel>{ 
    4545        private final UMLClass associatedClass; 
    46         private final Set<AttributeModel> am = new HashSet<AttributeModel>(); 
     46        private final Set<AttributeModel> attributeModel = new HashSet<AttributeModel>(); 
    4747        private final Set<ForeignKey> fk = new HashSet<ForeignKey>(); 
    4848        private final Set<Relationship> relationship = new HashSet<Relationship>(); 
     
    105105         * @return the am 
    106106         */ 
    107         public Set<AttributeModel> getAm() { 
    108                 return am; 
     107        public Set<AttributeModel> getAttributeModel() { 
     108                return attributeModel; 
    109109        } 
    110110 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/xmiModel/UMLClass.java

    r7974 r7998  
    3232package ndg.services.newmoon.xmiModel; 
    3333 
    34 import java.util.Set; 
    3534 
    3635/** 
     
    3837 * 
    3938 */ 
    40 public interface UMLClass extends UML_ID, UMLStereotyped { 
    41         boolean isRoot(); 
    42         boolean isLeaf(); 
    43         boolean isAbstrakt(); 
    44         UMLModel getUmlPackage(); 
    45         //Set<UMLGeneralization> getGeneralization(); 
    46         Set<UMLAttribute> getAttributes(); 
    47         //Set<UMLAssociationEnd> getAssociationEnds(); 
     39public interface UMLClass extends UMLClassDataType, UMLStereotyped { 
     40 
    4841} 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/xmiModel/UMLDataType.java

    r7974 r7998  
    3737 * 
    3838 */ 
    39 public interface UMLDataType extends UML_ID { 
    40         boolean isRoot(); 
    41         boolean isLeaf(); 
    42         boolean isAbstrakt(); 
     39public interface UMLDataType extends UMLClassDataType { 
    4340        UMLModel getUmlModel(); 
    44         void setUmlModel(UMLModel umlModel); 
    4541} 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/xmiModel/adapter/UMLClassAdapter.java

    r7974 r7998  
    3636 
    3737import ndg.services.newmoon.xmiModel.UMLAssociationEnd; 
    38 import ndg.services.newmoon.xmiModel.UMLAttribute; 
    3938import ndg.services.newmoon.xmiModel.UMLClass; 
    4039import ndg.services.newmoon.xmiModel.UMLGeneralization; 
     
    4746 * 
    4847 */ 
    49 public class UMLClassAdapter extends UML_IDAdapder implements UMLClass { 
     48public class UMLClassAdapter extends UMLClassDataTypeAdapter implements UMLClass { 
    5049 
    51         private boolean root; 
    52         private boolean leaf; 
    53         private boolean abstrakt; 
    54         private final UMLModel umlPackage; 
    5550        private final Set<UMLGeneralization> generalization = new HashSet<UMLGeneralization>(); 
    56         private final Set<UMLAttribute> attributes = new HashSet<UMLAttribute>(); 
    5751        private final Set<UMLAssociationEnd> associationEnds = new HashSet<UMLAssociationEnd>(); 
    5852        private final Set<UMLStereotype> umlStereotypes = new HashSet<UMLStereotype>(); 
     
    6660         */ 
    6761        public UMLClassAdapter(UML_ID id, boolean root, boolean leaf, boolean abstrakt, UMLModel umlPackage) { 
    68                 super(id); 
    69                 this.root = root; 
    70                 this.leaf = leaf; 
    71                 this.abstrakt = abstrakt; 
    72                 this.umlPackage = umlPackage; 
    73                 if (umlPackage != null) 
    74                         this.umlPackage.getUmlClasses().add(this); 
     62                super(id, root, leaf, abstrakt, umlPackage); 
     63                if (getUmlPackage() != null) 
     64                        getUmlPackage().getUmlClasses().add(this); 
    7565        } 
    7666 
    77         /* (non-Javadoc) 
    78          * @see ndg.services.newmoon.xmiModel.UMLClass#isRoot() 
    79          */ 
    80         public boolean isRoot() { 
    81                 return this.root; 
    82         } 
    8367 
    84         /* (non-Javadoc) 
    85          * @see ndg.services.newmoon.xmiModel.UMLClass#isLeaf() 
    86          */ 
    87         public boolean isLeaf() { 
    88                 return this.leaf; 
    89         } 
    90  
    91         /* (non-Javadoc) 
    92          * @see ndg.services.newmoon.xmiModel.UMLClass#isAbstract() 
    93          */ 
    94         public boolean isAbstrakt() { 
    95                 return this.abstrakt; 
    96         } 
    97  
    98         /** 
    99          * @return the UMLClass's UMLPackage 
    100          */ 
    101         public UMLModel getUmlPackage() { 
    102                 return umlPackage; 
    103         }        
    104  
    105         /** 
    106          * @param root the root to set 
    107          */ 
    108         protected void setRoot(boolean root) { 
    109                 this.root = root; 
    110         } 
    111  
    112         /** 
    113          * @param leaf the leaf to set 
    114          */ 
    115         protected void setLeaf(boolean leaf) { 
    116                 this.leaf = leaf; 
    117         } 
    118  
    119         /** 
    120          * @param abstrakt the abstrakt to set 
    121          */ 
    122         protected void setAbstrakt(boolean abstrakt) { 
    123                 this.abstrakt = abstrakt; 
    124         }        
    12568         
    12669        /* (non-Javadoc) 
     
    13073                return generalization;  
    13174        } 
    132          
    133         /** 
    134          * @return the attributes 
    135          */ 
    136         public Set<UMLAttribute> getAttributes() { 
    137                 return attributes; 
    138         } 
    139          
     75                 
    14076        /* (non-Javadoc) 
    14177         * @see ndg.services.newmoon.xmiModel.UMLClass#getUMLStereotype() 
     
    15894        @Override 
    15995        public String toString() { 
    160                 return "UMLClassAdapter [name=" + getName() + ", umlPackage=" + umlPackage + "]"; 
     96                return "UMLClassAdapter [name=" + getName() + ", umlPackage=" + getUmlPackage() + "]"; 
    16197        } 
    16298 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/xmiModel/adapter/UMLDataTypeAdapter.java

    r7974 r7998  
    4040 * 
    4141 */ 
    42 public class UMLDataTypeAdapter extends UML_IDAdapder implements UMLDataType { 
    43  
    44         private boolean root; 
    45         private boolean leaf; 
    46         private boolean abstrakt; 
    47         private UMLModel umlModel; 
     42public class UMLDataTypeAdapter extends UMLClassDataTypeAdapter implements UMLDataType { 
    4843 
    4944        /** 
     
    5348         * @param abstrakt 
    5449         */ 
    55         public UMLDataTypeAdapter(UML_ID id, boolean root, boolean leaf, boolean abstrakt) { 
    56                 super(id); 
    57                 this.root = root; 
    58                 this.leaf = leaf; 
    59                 this.abstrakt = abstrakt; 
     50        public UMLDataTypeAdapter(UML_ID id, boolean root, boolean leaf, boolean abstrakt, UMLModel umlModel) { 
     51                super(id, root, leaf, abstrakt, umlModel); 
    6052        } 
    61  
    62         /* (non-Javadoc) 
    63          * @see ndg.services.newmoon.xmiModel.UMLClass#isRoot() 
    64          */ 
    65         public boolean isRoot() { 
    66                 return this.root; 
    67         } 
    68  
    69         /* (non-Javadoc) 
    70          * @see ndg.services.newmoon.xmiModel.UMLClass#isLeaf() 
    71          */ 
    72         public boolean isLeaf() { 
    73                 return this.leaf; 
    74         } 
    75  
    76         /* (non-Javadoc) 
    77          * @see ndg.services.newmoon.xmiModel.UMLClass#isAbstract() 
    78          */ 
    79         public boolean isAbstrakt() { 
    80                 return this.abstrakt; 
    81         } 
    82  
    83         /** 
    84          * @return the umlModel 
    85          */ 
    86         public UMLModel getUmlModel() { 
    87                 return umlModel; 
    88         } 
    89  
    90         /** 
    91          * @param umlModel the umlModel to set 
    92          */ 
    93         public void setUmlModel(UMLModel umlModel) { 
    94                 this.umlModel = umlModel; 
    95         } 
    96  
    97         /** 
    98          * @param root the root to set 
    99          */ 
    100         protected void setRoot(boolean root) { 
    101                 this.root = root; 
    102         } 
    103  
    104         /** 
    105          * @param leaf the leaf to set 
    106          */ 
    107         protected void setLeaf(boolean leaf) { 
    108                 this.leaf = leaf; 
    109         } 
    110  
    111         /** 
    112          * @param abstrakt the abstrakt to set 
    113          */ 
    114         protected void setAbstrakt(boolean abstrakt) { 
    115                 this.abstrakt = abstrakt; 
    116         }        
    11753 
    11854        /* (non-Javadoc) 
     
    12157        @Override 
    12258        public String toString() { 
    123                 return "UMLClassAdapter [id=" + super.getId() + ", umlModel=" + umlModel + "]"; 
     59                return "UMLClassAdapter [id=" + super.getId() + ", umlModel=" + getUmlModel() + "]"; 
    12460        } 
    12561 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/xmiModel/v11/UMLDataTypeImpl.java

    r7974 r7998  
    3232package ndg.services.newmoon.xmiModel.v11; 
    3333 
     34import ndg.services.newmoon.xmiModel.UMLModel; 
    3435import ndg.services.newmoon.xmiModel.adapter.UMLDataTypeAdapter; 
    3536import ndg.services.newmoon.xmiModel.adapter.UML_IDAdapder; 
     
    4950         * @param abstrakt 
    5051         */ 
    51         public UMLDataTypeImpl(Element el, String modelId) { 
     52        public UMLDataTypeImpl(Element el, String modelId, UMLModel umlModel) { 
    5253                super(new UML_IDAdapder(el.getAttribute(Dictionary.XMI_ID), modelId, el.getAttribute(Dictionary.NAME)), 
    5354                                Boolean.getBoolean(el.getAttribute(Dictionary.ROOT)),  
    5455                                Boolean.getBoolean(el.getAttribute(Dictionary.LEAF)),  
    55                                 Boolean.getBoolean(el.getAttribute(Dictionary.ABSTRACT))); 
     56                                Boolean.getBoolean(el.getAttribute(Dictionary.ABSTRACT)),  
     57                                umlModel); 
    5658        } 
    5759 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/global_library.vm

    r7996 r7998  
    1414#set ($tmn = $tableModel.associatedClass.name) 
    1515#if ($relation.isManyToMany()) 
    16 '${relation.name}': relationship(${tt},  
     16'_${relation.name}': relationship(${tt},  
    1717secondary=${tt.toLowerCase()}_${ft.toLowerCase()}_table, 
    18 #if ($relation.backrefName) backref='${relation.backrefName}' #end 
     18#if ($relation.backrefName) backref='_${relation.backrefName}' #end 
    1919#elseif($relation.isOneToMany()) 
    20 '${relation.name}': relationship(${tt} 
     20'_${relation.name}': relationship(${tt} 
    2121#elseif($relation.isOneToOne()) 
    22 '${relation.name}': relationship(${tt}, uselist=False#end 
     22'_${relation.name}': relationship(${tt}, uselist=False#end 
    2323#if($tt == $tmn) 
    2424, remote_side=[#tableName($tmn).c.${tmn.toLowerCase()}_id] 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/velocity.properties

    r7974 r7998  
    33nmVelocity.resource.loader.class = org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader 
    44velocimacro.library = global_library.vm 
     5runtime.references.strict = false 
     6 
     7tools.application.date = org.apache.velocity.tools.generic.DateTool 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/velocity/python/mapping.vm

    r7996 r7998  
    4141#end 
    4242 
    43 mapper($tableModel.associatedClass.name, #tableName($tableModel)#inheritedClasses($tableModel)  
     43mapper($tableModel.associatedClass.name, #tableName($tableModel)  
    4444#generateProperties($tableModel)) 
    4545 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/velocity/python/pythonClass.vm

    r7974 r7998  
     1########################################################################## 
    12## pythonClass.vm 
     3## The form expects the following context attributes 
     4## classModel - an instance of ClassModel class 
     5## imports    - a Map<String, Set<String>> defining the modules to import 
     6## stereotype - an instance of UMLClass 
     7########################################################################## 
     8 
    29#set ($object = "object") 
    310#set ($newline = '\n') 
    4  
    5  
    6 #macro( superclass $superclasses) 
    7 #if($superclasses.size() == 0) 
     11#macro( superclass $superclasses, $stereotype) 
     12#if($superclasses.size() == 0 && !$stereotype) 
    813$object#end 
    9 #foreach( $class in $superclasses)       
    10 $class.name#if($foreach.hasNext),#end#end 
     14#if($stereotype) 
     15${stereotype.name}#end 
     16#if($stereotype && $superclasses.size() > 0),#end 
     17#if($superclasses.size() > 0) 
     18#foreach( $classModel in $superclasses) 
     19${classModel.associatedClass.name}#if($foreach.hasNext),#end 
     20#end 
     21#end 
    1122#end 
    1223 
    1324#macro( asEnumeration $asEnumeration) 
    14 #foreach($item in $asEnumeration) 
    15 ${tab}${item.key} = "${item.value}"  
     25#foreach($item in $asEnumeration.simpleKeyValues) 
     26${tab}en_${item.key.replaceAll("[()]", "")} = "${item.value}"  
    1627#end 
    1728#end 
    1829 
    1930#macro( asCodeList $asCodeList) 
    20 #foreach($item in $asCodeList) 
    21 ${tab}${item.key} = "${item.value}"  
     31#foreach($item in $asCodeList.simpleKeyValues) 
     32${tab}cl_${item.key.replaceAll("[()]", "")} = "${item.value}"  
    2233#end 
    2334#end 
    2435 
    25 #macro( asUnionElement $unionElement) 
    26 UnionElement($unionElement.type, "$unionElement.collectionType") 
     36#macro( asUnion $classModel) 
     37${tab}types = {#unionDictionary($classModel.attributeModel)} 
    2738#end 
    2839 
    29 #macro( asUnion $asUnion, $umlClass) 
    30 #set ( $values = "values = {#foreach($key in $asUnion.keySet())'$key':#asUnionElement($asUnion.get($key))#if($foreach.hasNext),#end#end}" ) 
    31 super($umlClass.name, self).__init__($values) 
     40#macro (unionDictionary $attributeModel) 
     41#foreach($item in $attributeModel) 
     42'${item.name}':${item.associatedClass.name}#if($foreach.hasNext),#end   
     43#end 
    3244#end 
    3345 
    34 #macro( attributes $asAttributes) 
    35 #foreach($key in $asAttributes) 
    36 #if($key.hasMultiplicity()) 
    37 ${tab}${tab}self.${key.name} = []${nl} 
    38 #else 
     46#macro( attributes $classModel) 
     47#foreach($key in $classModel.attributeModel) 
    3948#if($key.name) 
    40 ${tab}${tab}self.${key.name} 
     49${tab}${tab}self._${key.name} 
     50#end 
     51#end 
     52#if($classModel.parents && $classModel.parents.size() > 0) 
     53#foreach( $parent in $classModel.parents) 
     54${tab}${tab}self._${parent.associatedClass.name}         
    4155#end 
    4256#end 
    4357#end 
     58 
     59#macro (getter $attributeModel, $parentName) 
     60#set ( $methodName = "$display.capitalize( $attributeModel.name )") 
     61${tab}def get${methodName}(self): 
     62#if($parentName != '') 
     63${tab}${tab}return self._${parentName}.${key.name} 
     64#else 
     65${tab}${tab}return self._${key.name} 
    4466#end 
     67#end 
     68 
     69#macro (setter $attributeModel, $parentName) 
     70#set ( $methodName = "$display.capitalize( $attributeModel.name )") 
     71${tab}def set${methodName}(self, value): 
     72#if($parentName != '') 
     73${tab}${tab} self._${parentName}.set${methodName}(value) 
     74#else 
     75${tab}${tab} self._${key.name} = value 
     76#end 
     77#end 
     78 
     79#macro ( dogettersetter $attributeModel, $parentName) 
     80#foreach($key in $attributeModel) 
     81#if($key.name) 
     82 
     83#getter($key, $parentName) 
     84 
     85#setter($key, $parentName) 
     86#end 
     87#end 
     88#end 
     89 
     90 
     91#macro( gettersetter $classModel) 
     92#dogettersetter( $classModel.attributeModel, '') 
     93#foreach($parent in $classModel.parents) 
     94#dogettersetter($parent.attributeModel, $parent.associatedClass.name) 
     95#end 
     96#end 
     97 
    4598 
    4699#macro( importing $toImport) 
     
    55108#importing($imports) 
    56109 
     110''' 
     111Created on $date 
    57112 
    58 class ${umlClass.name}(#superclass($generalization)): 
    59 #if($asEnumeration && $asEnumeration.size() > 0) 
    60 #asEnumeration($asEnumeration) 
    61 #elseif ($asCodeList && $asCodeList.size() > 0) 
    62 #asCodeList($asCodeList) 
    63 #elseif ($asUnion && $asUnion.size() > 0) 
     113@author: mnagni 
     114''' 
     115 
     116class ${classModel.associatedClass.name}(#superclass($classModel.parents, $stereotype)): 
     117${tab}''' 
     118${tab}${tab}Represents a data entity defined in a UML diagram and supposed to  
     119${tab}${tab}be persisted in a relational database.  
     120  
     121${tab}${tab}This class has been genererated automatically using the Apache Velocity project. 
     122${tab}''' 
     123#if($classModel.isEnumeration()) 
     124#asEnumeration($classModel) 
     125#elseif ($classModel.isCodeList()) 
     126#asCodeList($classModel) 
     127#elseif ($classModel.isUnion()) 
     128#asUnion($classModel)  
     129#else 
     130${tab}''' 
     131${tab}${tab}Please note that any access to the inner attributes should be done using  
     132${tab}${tab}the given get/set methods and NOT accessing them directly. 
     133${tab}''' 
    64134${tab}def __init__(self): 
    65 #asUnion($asUnion $umlClass)  
    66 #else 
    67 ${tab}def __init__(self): 
    68 ${tab}${tab}super($umlClass.name, self).__init__() 
     135${tab}${tab}super(${classModel.associatedClass.name}, self).__init__() 
    69136#end 
    70 #if (!(($asCodeList && $asCodeList.size() > 0) || ($asEnumeration && $asEnumeration.size() > 0) || ($asUnion && $asUnion.size() > 0))) 
    71 #attributes($attributes) 
     137#if (!($classModel.isEnumeration() || $classModel.isCodeList() || $classModel.isUnion())) 
     138#attributes($classModel.attributeModel) 
     139#gettersetter($classModel) 
    72140#end 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/velocity/python/sqlAlchemyTables.vm

    r7996 r7998  
     1########################################################################## 
    12## sqlAlchemyTables.vm 
     3## The form expects the following context attributes 
     4## tableModel - an instance of ClassModel class 
     5########################################################################## 
     6 
    27 
    38#macro( attributeType $attribute) 
    4 #if($attribute.enumLike) 
    5 ${attribute.associatedClass.name}.db_type()#elseif($attribute.hasMultiplicity()) 
    6 ARRAY(${attribute.associatedClass.name})#else 
    7 ${attribute.associatedClass.name}(#if($attribute.lenght > 0)${attribute.lenght}#end)#end 
     9#set ($fkName = ${attribute.associatedClassModel.associatedType}) 
     10#if(($attribute.associatedClassModel.isCodeList() || $attribute.associatedClassModel.isEnumeration())) 
     11${attribute.associatedType.name}.db_type()#elseif($attribute.hasMultiplicity()) 
     12ARRAY(${attribute.associatedType.name})#else 
     13${attribute.associatedType.name}(#if($attribute.lenght > 0)${attribute.lenght}#end)#end 
    814#end 
    915 
    10 #macro( column $simpleAttribute) 
    11 Column('${simpleAttribute.name}', #attributeType($simpleAttribute) #checkNullable($simpleAttribute)), 
     16#macro( column $attribute) 
     17Column('_${attribute.name}', #attributeType($attribute) #checkNullable($attribute)), 
    1218#end 
    1319 
     
    6167${tab}#fk($foreignKey, $tableModel) 
    6268#end 
    63 #foreach( $simpleAttribute in $tableModel.am) 
    64 ${tab}#column($simpleAttribute) 
     69#foreach( $attribute in $tableModel.attributeModel) 
     70${tab}#column($attribute) 
    6571#end 
    6672Column('t_type', String(30), nullable=False, default='${associatedCN}'), 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/xmiToSQLMap.properties

    r7996 r7998  
    77Vector=ARRAY 
    88Number=NUMERIC 
    9 Date=DATE 
    10 DateTime=DateTime 
     9#Date=DATE 
     10#DateTime=DateTime 
  • mauRepo/xmi2sqlalchemy/trunk/src/test/java/ngn/services/newmoon/DOMParser.java

    r7978 r7998  
    33import static org.junit.Assert.fail; 
    44 
     5import java.io.File; 
    56import java.io.InputStream; 
    67import java.util.ArrayList; 
     8import java.util.HashMap; 
    79import java.util.List; 
     10import java.util.Map; 
    811import java.util.Scanner; 
    912import java.util.concurrent.Future; 
    1013 
     14import ndg.services.newmoon.NewmoonManager; 
    1115import ndg.services.newmoon.NmParser; 
    1216import ndg.services.newmoon.UMLElementsArchive; 
    13 import ndg.services.newmoon.velocity.python.GenerateModule; 
     17import ndg.services.newmoon.NewmoonManager.NM_PARAM; 
     18import ndg.services.newmoon.collect.CollectClasses; 
     19import ndg.services.newmoon.velocity.python.GenerateClassesClosure; 
     20import ndg.services.newmoon.velocity.python.GenerateFromClassModel; 
     21import ndg.services.newmoon.velocity.python.GenerateModuleHelper; 
    1422import ndg.services.newmoon.velocity.python.GenerateTables; 
     23import ndg.services.newmoon.velocity.python.GenerateTables_; 
     24import ndg.services.newmoon.velocity.python.support.ClassModel; 
    1525import ndg.services.newmoon.xmiModel.UMLClass; 
    1626import ndg.services.newmoon.xmiModel.UMLModel; 
     
    2131 
    2232public class DOMParser { 
     33 
     34        public enum NM_PARAM { 
     35                XMI_DOC("xmi-path"), REPORT_NAME("reportname"), WORKING_DIRECTORY("working-directory"), DEPENDENCY_REGISTER_PATH( 
     36                                "dependency-register-path"), GLM_VERSION("gml-version"), ROOT_COLLECTION_URI("root-collection-uri"), XMLDB_USER( 
     37                                "xmldb-user"), XMLDB_PASSWORD("xmldb-password"), ROOT_COLLECTION_PATH("root-collection-path"), DEFAULT_ENCODE_REPORT_NAME( 
     38                                "EncodeReport"), DEFAULT_CONFORMANCE_REPORT_NAME("ConformanceTestReport"), CONFORMANCE_TEST_DIR( 
     39                                "conformanceDir"), ENCODE_DIR("encodeDir"), RESOURCE_NAME("defaultResourceName"), OUTPUT_DIR( 
     40                                "exportDir"), EXECUTION_DIR("execution-directory"); 
     41 
     42                private final String name; 
     43 
     44                private NM_PARAM(String name) { 
     45                        this.name = name; 
     46                } 
     47 
     48                public String getParamName() { 
     49                        return this.name; 
     50                } 
     51        } 
    2352 
    2453         
     
    3867                InputStream inputXML = NmParser.class.getClassLoader().getResourceAsStream("CEDA_Model/CEDA_ModelXMI.xml"); 
    3968                InputStream inputAddClass = NmParser.class.getClassLoader().getResourceAsStream("CEDA_Model/AdditionalClasses.txt"); 
     69                 
     70                File baseDir = new File(GenerateModuleHelper.class.getClassLoader().getResource(".").getPath()); 
     71                 
    4072                try { 
    4173                        NmParser xmiParser = new NmParser(inputXML, null); 
     
    4678                        /*  I try to generate just what I need */ 
    4779                        UMLModel umlModel = myModel.get(); 
     80                         
     81                        List<UMLClass> umlClasses = new ArrayList<UMLClass>(); 
     82                        umlClasses.addAll(UMLElementsArchive.getInstance().getUMLElementByType(UMLClass.class)); 
     83                         
     84                        CollectClasses cc = new CollectClasses(umlClasses); 
     85                        UMLElementsArchive.getInstance().getClassModel().addAll(cc.execute()); 
     86                         
     87                        GenerateFromClassModel gen = new GenerateFromClassModel(new GenerateClassesClosure(baseDir)); 
     88                        gen.execute(UMLElementsArchive.getInstance().getClassModel()); 
     89                         
     90                        GenerateTables_ gen2 = new GenerateTables_(baseDir); 
     91                        gen2.execute(umlModel); 
     92                         
     93                        //GenerateClasses gp = new GenerateClasses(cms); 
     94                        //gp.execute(); 
     95                         
     96                        /* 
    4897                        GenerateModule module = new GenerateModule(umlModel); 
    4998                        UMLElementsArchive.getInstance().startNewParser(module);                         
    5099                        UMLElementsArchive.getInstance().waitParserToComplete(); 
     100                        */ 
    51101                         
    52102                         
    53103                         
    54104                        // Is better to generate the table on a separate process in order to minimize the generated tables 
    55                         List<UMLClass> umlClasses = new ArrayList<UMLClass>(); 
     105                        /* 
     106                        umlClasses.clear(); 
    56107                        umlClasses.addAll(UMLElementsArchive.getInstance().getUMLClassesByUMLModel(umlModel)); 
    57108                        if (inputAddClass != null) { 
     
    62113                                } 
    63114                        } 
     115                        */ 
    64116                         
    65                         GenerateTables tables = new GenerateTables(umlClasses, module.getHelper()); 
    66                         tables.execute(); 
     117                        //GenerateTables tables = new GenerateTables(umlClasses); 
     118                        //tables.execute(); 
    67119 
    68120                } catch (Exception e) { 
     
    75127                Assert.assertTrue(Boolean.TRUE); // TODO 
    76128        } 
     129         
     130        private class XMI2SQL { 
     131                Map<NewmoonManager.NM_PARAM, String> params = new HashMap<NewmoonManager.NM_PARAM, String>(); 
     132                // ---- mandatory parameters ----// 
     133                // hidden 
     134                //params.put(NM_PARAM.WORKING_DIRECTORY, ); 
     135        } 
    77136} 
  • mauRepo/xmi2sqlalchemy/trunk/src/test/java/ngn/services/newmoon/velocity/python/GenerateClassTest.java

    r7974 r7998  
    7979        private void simpleUmlClasses(String simpleClassFile, String compareToResultFile) { 
    8080                try { 
    81                         GenerateClasses gc = new GenerateClasses(null, null, new GenerateModuleHelper()); 
     81                        GenerateClasses gc = new GenerateClasses(null); 
    8282                        initializeTest(simpleClassFile); 
    8383                        File generatedOutput = new File(baseDir, umlClass.getName() + ".py");  
    84                         gc.execute(generatedOutput, umlClass); 
     84                        //gc.execute(generatedOutput, umlClass); 
    8585                        String actual = FileUtils.readFileToString(generatedOutput); 
    8686                        String expected = FileUtils.readFileToString(new File(baseDir, "testResults/"+ compareToResultFile)); 
  • mauRepo/xmi2sqlalchemy/trunk/src/test/java/ngn/services/newmoon/velocity/python/GenerateTableTest.java

    r7974 r7998  
    4040import ndg.services.newmoon.NmEntityResolver; 
    4141import ndg.services.newmoon.NmParser; 
    42 import ndg.services.newmoon.velocity.python.GenerateTables; 
    43 import ndg.services.newmoon.velocity.python.MappedGenerateTable; 
    4442import ndg.services.newmoon.xmiModel.UMLClass; 
    4543 
    46 import org.apache.commons.io.FileUtils; 
    4744import org.junit.Test; 
    4845import org.w3c.dom.Document; 
     
    7269        @Test 
    7370        public final void simpleUmlClasses() { 
    74                 simpleUmlClasses("simpleUmlClass.xml", "Sample.py"); 
    75                 simpleUmlClasses("unionUmlClass.xml", "GeoEntity.py"); 
    76                 simpleUmlClasses("enumerationUmlClass.xml", "Heaviness.py"); 
     71                //simpleUmlClasses("simpleUmlClass.xml", "Sample.py"); 
     72                //simpleUmlClasses("unionUmlClass.xml", "GeoEntity.py"); 
     73                //simpleUmlClasses("enumerationUmlClass.xml", "Heaviness.py"); 
    7774        } 
    78          
     75        /* 
    7976        private void simpleUmlClasses(String simpleClassFile, String compareToResultFile) { 
    8077                try { 
     78                 
    8179                        GenerateTables gc = new MappedGenerateTable(null); 
    8280                        initializeTest(simpleClassFile); 
    8381                        File generatedOutput = new File(baseDir, umlClass.getName() + ".sql");  
    84                         gc.execute(generatedOutput, umlClass); 
     82                        //gc.execute(generatedOutput, umlClass); 
    8583                        String actual = FileUtils.readFileToString(generatedOutput); 
    8684                        String expected = FileUtils.readFileToString(new File(baseDir, "testResults/"+ compareToResultFile)); 
     
    111109                } 
    112110        }        
    113          
     111        */ 
    114112        private Document parseXmlFile(InputStream inputXML) throws ParserConfigurationException, SAXException, IOException { 
    115113                // get the factory 
  • mauRepo/xmi2sqlalchemy/trunk/src/test/resources/simpleUmlClass.xml

    r7974 r7998  
    11<UML:Class xmlns:UML="omg.org/UML1.3" timestamp="2008-12-08 16:26:03" name="Sample" xmi.id="EAID_A6C40697_7934_4094_8FAA_FD12E7702BD6" visibility="public" namespace="EAPK_2AD002DC_4918_48d9_8DCA_53D41BFA3855" isRoot="false" isLeaf="false" isAbstract="false" isActive="false"> 
    2         <UML:ModelElement.stereotype> 
    3                 <UML:Stereotype name="FeatureType"/> 
    4         </UML:ModelElement.stereotype> 
    52        <UML:ModelElement.taggedValue> 
    63                <UML:TaggedValue tag="documentation" value="Specialized sample for testing"/> 
Note: See TracChangeset for help on using the changeset viewer.