Ignore:
Timestamp:
05/12/11 17:12:15 (8 years ago)
Author:
mnagni
Message:
 
Location:
mauRepo/xmi2sqlalchemy/trunk/src
Files:
1 added
1 deleted
24 edited

Legend:

Unmodified
Added
Removed
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/ModelXMI11Factory.java

    r7998 r8004  
    3737import ndg.services.newmoon.xmiModel.UMLAttribute; 
    3838import ndg.services.newmoon.xmiModel.UMLClass; 
     39import ndg.services.newmoon.xmiModel.UMLClassDataType; 
    3940import ndg.services.newmoon.xmiModel.UMLClassifierRole; 
    4041import ndg.services.newmoon.xmiModel.UMLCollaboration; 
     
    100101         */ 
    101102        @Override 
    102         public UMLDataType createUMLDataType(Element el, String modelId, UMLModel umlModel){ 
    103                 return new UMLDataTypeImpl(el, modelId, umlModel); 
     103        public UMLDataType createUMLDataType(Element el, String modelId, UMLModel umlModel, UMLClassDataType type){ 
     104                return new UMLDataTypeImpl(el, modelId, umlModel, type); 
    104105        } 
    105106         
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/ModelXMIFactory.java

    r7998 r8004  
    3434import ndg.services.newmoon.xmiModel.UMLAttribute; 
    3535import ndg.services.newmoon.xmiModel.UMLClass; 
     36import ndg.services.newmoon.xmiModel.UMLClassDataType; 
    3637import ndg.services.newmoon.xmiModel.UMLClassifierRole; 
    3738import ndg.services.newmoon.xmiModel.UMLCollaboration; 
     
    6061        public abstract UMLClassifierRole createUMLClassifierRole(Element el, String modelId); 
    6162 
    62         public abstract UMLDataType createUMLDataType(Element el, String modelId, UMLModel umlModel); 
     63        public abstract UMLDataType createUMLDataType(Element el, String modelId, UMLModel umlModel, UMLClassDataType type); 
    6364 
    6465        public abstract UMLCollaboration createUMLCollaboration(Element el, String modelId); 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/NmParser.java

    r7998 r8004  
    292292        private UMLDataType processDataType(Node node, UMLModel umlModel) { 
    293293                //Process the DataType element 
    294                 UMLDataType umlDT = modelFactory.createUMLDataType((Element)node, getMainModelId(), umlModel); 
     294                /*Actually I set the 'type' parameter to null because the 
     295                 * uml:dataType I met are defined just on their name,say Set<GF_AttributeType> 
     296                 * as consequence I cannot realistically set the type in the better way. 
     297                 * Probably at the ClassModel level process it would be possible to update such value  
     298                 */ 
     299                UMLDataType umlDT = modelFactory.createUMLDataType((Element)node, getMainModelId(), umlModel, null); 
    295300                umlModel.getUmlDataType().add(umlDT); 
    296301                return umlDT; 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/UMLElementsArchive.java

    r7998 r8004  
    862862         
    863863        public ClassModel getClassModelByUMLClass(UMLClassDataType umlClass) { 
     864                UMLClassDataType intClass = umlClass; 
     865                if (umlClass instanceof UMLDataType) 
     866                        intClass = ((UMLDataType)umlClass).getType(); 
    864867                ClassModel cm = null; 
    865868                Iterator<ClassModel> iter = getClassModel().iterator(); 
    866869                while (iter.hasNext()) { 
    867870                        cm = iter.next(); 
    868                         if (cm.getAssociatedClass().equals(umlClass)) 
     871                        if (cm.getAssociatedClass().equals(intClass)) 
    869872                                return cm; 
    870873                } 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/collect/CollectClassesClosure.java

    r7998 r8004  
    4040 
    4141import ndg.services.newmoon.NewmoonException; 
     42import ndg.services.newmoon.NmParser; 
    4243import ndg.services.newmoon.UMLElementsArchive; 
     44import ndg.services.newmoon.velocity.python.GenerateClasses.EmbeddedType; 
    4345import ndg.services.newmoon.velocity.python.support.AttributeModel; 
    4446import ndg.services.newmoon.velocity.python.support.ClassModel; 
     
    5052import ndg.services.newmoon.xmiModel.UMLClassDataType; 
    5153import ndg.services.newmoon.xmiModel.UMLDataType; 
     54import ndg.services.newmoon.xmiModel.UMLModel; 
    5255import ndg.services.newmoon.xmiModel.UMLStereotype; 
    5356import ndg.services.newmoon.xmiModel.UMLValueTagged; 
     
    5962import org.apache.commons.lang.StringUtils; 
    6063import org.apache.commons.lang.math.NumberUtils; 
     64import org.w3c.dom.Node; 
    6165 
    6266/** 
     
    6569 */ 
    6670public class CollectClassesClosure implements Closure { 
    67         public enum DataType {NONE, SET, SEQUENCE, DICTIONARY, TRANSFINITE_SET} 
     71        public enum CollectionType {NONE, SET, SEQUENCE, DICTIONARY, TRANSFINITE_SET} 
    6872         
    6973        private final List<ClassModel> models = new ArrayList<ClassModel>(); 
     
    114118        private ClassModel processUMLclass(UMLClass umlClass) throws NewmoonException, IOException { 
    115119                ClassModel cm = getExternalModel(umlClass); 
    116                 if (cm == null) { 
     120                if (cm == null && umlClass != null) { 
    117121                        cm = new ClassModel(umlClass); 
    118122                        models.add(cm); 
     
    224228                                if (input instanceof UMLAttribute) { 
    225229                                        generateSimpleKeyValues((UMLAttribute) input); 
    226                                         ret.add(extractSimpleAttribute((UMLAttribute) input)); 
     230                                        ret.add(extractAttribute((UMLAttribute) input)); 
    227231                                } 
    228232                                         
    229233                                         
    230234                                if (input instanceof UMLAssociationEnd) 
    231                                         ret.add(extractSimpleAttribute((UMLAssociationEnd) input)); 
     235                                        ret.add(extractAttribute((UMLAssociationEnd) input)); 
    232236                        } catch (NewmoonException e) { 
    233237                                this.exceptions.add(e); 
     
    252256                } 
    253257 
    254                 private AttributeModel extractSimpleAttribute(UMLAttribute umlAttribute) throws NewmoonException, 
     258                private AttributeModel extractAttribute(UMLAttribute umlAttribute) throws NewmoonException, 
    255259                                IOException { 
    256                         return extractSimpleAttribute(umlAttribute.getClassifier(), umlAttribute, cm, 
     260                        return extractAttribute(umlAttribute.getClassifier(), umlAttribute, cm, 
    257261                                        hasMolteplicity(umlAttribute), UMLElementsArchive.getInstance().isVoidable(umlAttribute)); 
    258262                } 
    259263 
    260                 private AttributeModel extractSimpleAttribute(UMLAssociationEnd end) throws NewmoonException, IOException { 
    261                         return extractSimpleAttribute(end.getType(), end, cm, hasMolteplicity(end), false); 
    262                 } 
    263  
    264                 private AttributeModel extractSimpleAttribute(UML_ID type, UMLValueTagged valueTagged, 
     264                private AttributeModel extractAttribute(UMLAssociationEnd end) throws NewmoonException, IOException { 
     265                        return extractAttribute(end.getType(), end, cm, hasMolteplicity(end), false); 
     266                } 
     267 
     268                private AttributeModel extractAttribute(UML_ID type, UMLValueTagged valueTagged, 
    265269                                ClassModel attributeOwner, boolean hasMultiplicity, boolean isVoidable) throws NewmoonException, 
    266270                                IOException { 
     
    271275                } 
    272276 
    273                 private <T extends UMLClassDataType> AttributeModel<T> processAttribute(T umlAttribute, UMLValueTagged valueTagged, 
     277                private <T extends UMLClassDataType> AttributeModel processAttribute(T umlAttribute, UMLValueTagged valueTagged, 
    274278                                boolean hasMultiplicity, boolean isVoidable) throws NewmoonException, IOException { 
    275279 
     
    278282                                throw new NewmoonException("No type for UML_ID: " + umlAttribute); 
    279283 
    280                         ClassModel associatedClassModel = null;  
    281                         if (umlAttribute instanceof UMLClass) { 
    282                                 associatedClassModel = processUMLclass((UMLClass) umlAttribute); 
    283                         } 
    284                          
    285                         return new AttributeModel<T>(umlAttribute, associatedClassModel,  
     284                        ClassModel attrClassModel = null; 
     285                        //Processes the attribute type (the called method will skip it if already exists) 
     286                        if (umlAttribute instanceof UMLClass) 
     287                                attrClassModel = processUMLclass((UMLClass) umlAttribute); 
     288 
     289                        if (umlAttribute instanceof UMLDataType) { 
     290                                UMLClass attrClass = extractUMLClassByDataType((UMLDataType)umlAttribute); 
     291                                //Does the Setting missed in the NmParser ingestion 
     292                                ((UMLDataType)umlAttribute).setType(attrClass); 
     293                                attrClassModel = processUMLclass(attrClass); 
     294                        } 
     295                                                         
     296                        return new AttributeModel(attrClassModel,  
    286297                                        valueTagged.getName(),  
    287298                                        extractIntegerValue(valueTagged, Dictionary.LOWER_BOUND),  
    288299                                        extractIntegerValue(valueTagged, Dictionary.UPPER_BOUND), 
    289300                                        extractIntegerValue(valueTagged, Dictionary.LENGTH),  
    290                                         isVoidable);                                     
     301                                        isVoidable, 
     302                                        extractCollectionType(umlAttribute.getName())); 
    291303                } 
    292304                 
     
    302314                } 
    303315                 
    304                 private UMLClass extractUMLClassByDataType(UMLDataType umlDataType) { 
     316                private <T extends UMLClassDataType> UMLClass extractUMLClassByDataType(T umlDataType) { 
    305317                        /* For now I assume that any DataType name is of the format  
    306318                         * 'xxx<UMLClass_name>'  
     
    308320                        int beginIndex = umlDataType.getName().indexOf("<") + 1; 
    309321                        int endIndex = umlDataType.getName().indexOf(">"); 
    310                         String umlClassName = umlDataType.getName().substring(beginIndex, endIndex); 
     322                        String umlClassName = umlDataType.getName(); 
     323                        if (beginIndex > 0 && endIndex > 0) 
     324                                umlClassName = umlDataType.getName().substring(beginIndex, endIndex); 
    311325                        return UMLElementsArchive.getInstance().getUMLClassByName(umlClassName); 
    312326                } 
     
    381395                } 
    382396        } 
     397         
     398        /** 
     399         * @see EmbeddedType#EmbeddedType() 
     400         **/ 
     401        private CollectionType extractCollectionType(String definition) { 
     402                if (definition.matches("Sequence(&lt;|<).*(&gt;|>)")) 
     403                        return CollectionType.SEQUENCE; 
     404                if (definition.matches("Set(&lt;|<).*(&gt;|>)")) 
     405                        return CollectionType.SET       ; 
     406                if (definition.matches("Dictionary(&lt;|<).*(&gt;|>)")) 
     407                        return CollectionType.DICTIONARY        ;                
     408                if (definition.matches("TranfiniteSet(&lt;|<).*(&gt;|>)")) 
     409                        return CollectionType.DICTIONARY        ;                
     410                if (definition.matches("(&lt;|<)undefined(&gt;|>)")) 
     411                        return CollectionType.NONE; 
     412                else  
     413                        return CollectionType.NONE;      
     414        } 
    383415} 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/GenerateClassesClosure.java

    r7999 r8004  
    4242import ndg.services.newmoon.velocity.python.support.ASCodeList; 
    4343import ndg.services.newmoon.velocity.python.support.ASEnumeration; 
     44import ndg.services.newmoon.velocity.python.support.ASText; 
    4445import ndg.services.newmoon.velocity.python.support.ASUnion; 
    4546import ndg.services.newmoon.velocity.python.support.ClassModel; 
     
    122123                if (cm.isUnion()) { 
    123124                        CollectionUtils.addAll(toImport, cm.getAttributeModel().iterator()); 
     125                        //not the best solution but ok for now 
     126                        toImport.add(new ASText());                      
    124127                } 
    125128                 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/GenerateModuleHelper.java

    r7998 r8004  
    4949 
    5050import org.apache.commons.io.FileUtils; 
     51import org.apache.commons.io.IOUtils; 
    5152import org.apache.commons.lang.StringUtils; 
    5253import org.slf4j.Logger; 
     
    140141         
    141142        public File generatePythonPackage(UMLModel model) throws IOException { 
     143                checkRootInit(); 
     144                 
    142145                File file =  
    143146                        model == null ? getBaseDir() : 
    144147                                        new File(getBaseDir(), StringUtils.replaceChars(model.toString(), '.', File.separatorChar).toLowerCase()); 
    145  
     148                         
    146149                if (!file.exists()) { 
    147150                        FileUtils.forceMkdir(file); 
     
    155158                return file; 
    156159        } 
     160         
     161        private void checkRootInit() throws IOException { 
     162                File file = new File(getBaseDir(), "__init__.py"); 
     163                if (!file.exists()) 
     164                        file.createNewFile(); 
     165        } 
    157166} 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/GenerateTables_.java

    r7998 r8004  
    133133        private void writeAll(InnerGenerateTablesClosure closure) throws IOException { 
    134134                PythonImportClosure importClosure = new PythonImportClosure(); 
    135                  
    136                 checkReciprocalTables(closure); 
     135   
     136                checkReciprocalTables(closure, importClosure); 
    137137 
    138138                List<TableModel> tbs = sortTableModels(closure); 
    139139                //-- THINK BEFORE CHANGE THE ORDER!! --// 
    140                 applyTemplate(tbs, CONTEXT.tableModel, sqlTablesStrBuffer, tableTemplateFile); 
    141                 CollectionUtils.forAllDo(tbs, importClosure); 
    142                  
    143                 applyTemplate(closure.getNotSortable(), CONTEXT.tableModel, sqlTablesStrBuffer, tableTemplateFile); 
    144                 CollectionUtils.forAllDo(closure.getNotSortable(), importClosure); 
    145                  
    146                 applyTemplate(closure.getAssociationTable(), CONTEXT.associationTable, sqlTablesStrBuffer, associationTemplateFile); 
    147                 CollectionUtils.forAllDo(closure.getAssociationTable(), importClosure);          
    148                  
     140                applyTemplate(tbs, CONTEXT.tableModel, sqlTablesStrBuffer, tableTemplateFile);   
     141                applyTemplate(closure.getNotSortable(), CONTEXT.tableModel, sqlTablesStrBuffer, tableTemplateFile);              
     142                applyTemplate(closure.getAssociationTable(), CONTEXT.associationTable, sqlTablesStrBuffer, associationTemplateFile);                             
    149143                vcontext.put(CONTEXT.imports.name(), importClosure.getImportMap()); 
    150144                 
     
    202196        } 
    203197 
    204         private void checkReciprocalTables(InnerGenerateTablesClosure closure) { 
    205                 Iterator<TableModel> iterator = closure.getTableModels().iterator(); 
     198        private void checkReciprocalTables(InnerGenerateTablesClosure closure, PythonImportClosure importClosure) { 
     199                //Imports the classes necessaries for the table declaration 
     200                CollectionUtils.forAllDo(closure.getTableModels(), importClosure); 
     201                 
     202                Iterator<TableModel> iterator = closure.getTableModels().iterator();             
    206203                while (iterator.hasNext()) { 
    207204                        TableModel tb = iterator.next(); 
    208                          
    209205                        /* 
    210206                         * Checks if one attribute or one of attribuite's children  
     
    219215                         *              and eventually set up a many-to-many relationship  
    220216                         */ 
    221                         checkTableAttributeOverriding(tb); 
    222                 } 
    223         } 
    224  
    225         private void checkTableAttributeOverriding(TableModel tb){ 
     217                        checkTableAttributeOverriding(tb, importClosure); 
     218                } 
     219        } 
     220 
     221        private void checkTableAttributeOverriding(TableModel tb, PythonImportClosure importClosure){ 
     222                //Imports the classes necessaries for the table definition 
     223                CollectionUtils.forAllDo(tb.getAttributeModel(), importClosure); 
     224                 
    226225                Set<TableModel> ovm = new HashSet<TableModel>(); 
    227226                for (AttributeModel am : tb.getAttributeModel()) { 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/InnerGenerateTablesClosure.java

    r7999 r8004  
    5555import ndg.services.newmoon.xmiModel.UMLClass; 
    5656import ndg.services.newmoon.xmiModel.UMLClassDataType; 
     57import ndg.services.newmoon.xmiModel.UMLDataType; 
    5758 
    5859import org.apache.commons.collections.Closure; 
     
    142143 
    143144        private ClassModel getClassModel(UMLClassDataType umlClass) { 
    144                 return UMLElementsArchive.getInstance().getClassModelByUMLClass( 
    145                                 umlClass); 
     145                return UMLElementsArchive.getInstance().getClassModelByUMLClass(umlClass); 
    146146        } 
    147147 
    148148        private TableModel processUMLclass(ClassModel classModel) 
    149149                        throws NewmoonException, IOException { 
     150                 
     151                if (checkIfSkipProcess(classModel)) 
     152                        return null; 
     153                 
    150154                if (tableModelExists(classModel)) 
    151155                        return getTableModel(classModel); 
     
    168172                        IOException { 
    169173                AttributeModel am = null; 
    170                 Iterator<AttributeModel> iter = getClassModel( 
    171                                 parent.getAssociatedClass()).getAttributeModel().iterator(); 
     174                Iterator<AttributeModel> iter = getClassModel(parent.getAssociatedClass()) 
     175                                .getAttributeModel().iterator(); 
    172176                while (iter.hasNext()) { 
    173177                        am = iter.next(); 
    174  
    175                         ClassModel cm = getClassModel(am.getAssociatedType()); 
    176  
    177                         if (cm == null || isToSkip(cm)) { 
     178                        ClassModel cm = am.getAssociatedType(); 
     179 
     180                        if (cm == null || checkIfSkipProcess(cm)) { 
    178181                                parent.getAttributeModel().add(am); 
    179182                                continue; 
     
    181184 
    182185                        TableModel child = processUMLclass(cm); 
     186                        if (child == null) 
     187                                continue; 
     188                         
    183189                        /* 
    184190                         * Voidable should be manage with a "status" more than with a NULL 
     
    210216        } 
    211217 
    212         private boolean isToSkip(ClassModel classModel) { 
    213                 return (classModel.isCodeList() || classModel.isEnumeration() || isMapped(classModel 
    214                                 .getAssociatedClass())); 
    215         } 
    216  
     218        private boolean checkIfSkipProcess(ClassModel classModel) { 
     219                return (classModel.isCodeList()  
     220                                || classModel.isEnumeration()  
     221                                || checkIfIsPrimitiveAttribute(classModel)); 
     222        } 
     223 
     224        private boolean checkIfIsPrimitiveAttribute(ClassModel classModel) { 
     225                return GenerateModuleHelper.getXMIClassToSQLMap().containsKey(classModel.getAssociatedClass().getName()); 
     226        } 
     227         
    217228        private boolean tableModelExists(ClassModel classModel) { 
    218229                return tableModels.contains(new TableModel(classModel 
     
    675686                return helper; 
    676687        } 
    677  
    678         /** 
    679          * Verifies if the associated UMLClass is mapped by the 
    680          * {@link PropertyMap#XMI_TO_SQL_MAP} file. 
    681          *  
    682          * @return <code>true</code> if is mapped, <code>false</code> otherwise 
    683          **/ 
    684         public boolean isMapped(UMLClassDataType associatedClass) { 
    685                 String typeName = StringUtils.defaultIfEmpty(GenerateModuleHelper 
    686                                 .getXMIClassToSQLMap().getProperty(associatedClass.getName()), 
    687                                 ""); 
    688                 return typeName.equals(associatedClass.getName()); 
    689         } 
    690688} 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/PythonImportClosure.java

    r7998 r8004  
    3939import ndg.services.newmoon.velocity.python.support.ImportCollector; 
    4040import ndg.services.newmoon.velocity.python.support.TableModel; 
    41 import ndg.services.newmoon.xmiModel.UMLClass; 
    4241import ndg.services.newmoon.xmiModel.UMLClassDataType; 
    43 import ndg.services.newmoon.xmiModel.UMLDataType; 
    4442 
    4543import org.apache.commons.collections.Closure; 
     
    5755                public void execute(Object input) { 
    5856                        UMLClassDataType umlType = null; 
    59                         if (input instanceof UMLClassDataType) 
     57                        if (input instanceof UMLClassDataType) { 
    6058                                umlType = (UMLClassDataType)input; 
    61                          
    62                         if (input instanceof TableModel) 
    63                                 umlType = ((TableModel)input).getAssociatedClass();                      
    64                         if (input instanceof AttributeModel) 
    65                                 umlType = ((AttributeModel)input).getAssociatedType(); 
    66                         if (input instanceof ClassModel) 
     59                        } else if (input instanceof TableModel) { 
     60                                umlType = ((TableModel)input).getAssociatedClass(); 
     61                        } else if (input instanceof AttributeModel) { 
     62                                umlType = ((AttributeModel)input).getAssociatedType().getAssociatedClass(); 
     63                        } else if (input instanceof ClassModel) { 
    6764                                umlType = ((ClassModel)input).getAssociatedClass(); 
     65                        }                                
    6866                        importCollector.updateImports(umlType); 
    6967                }        
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/support/ASCodeList.java

    r7974 r8004  
    4444 
    4545        /** 
    46          * @param id 
    47          * @param root 
    48          * @param leaf 
    49          * @param abstrakt 
    50          * @param umlPackage 
    5146         */ 
    5247        public ASCodeList() { 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/support/ASEnumeration.java

    r7974 r8004  
    4444 
    4545        /** 
    46          * @param id 
    47          * @param root 
    48          * @param leaf 
    49          * @param abstrakt 
    50          * @param umlPackage 
    5146         */ 
    5247        public ASEnumeration() { 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/support/ASUnion.java

    r7998 r8004  
    4444 
    4545        /** 
    46          * @param id 
    47          * @param root 
    48          * @param leaf 
    49          * @param abstrakt 
    50          * @param umlPackage 
    5146         */ 
    5247        public ASUnion() { 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/support/AttributeModel.java

    r7998 r8004  
    3232package ndg.services.newmoon.velocity.python.support; 
    3333 
    34 import ndg.services.newmoon.UMLElementsArchive.PropertyMap; 
    35 import ndg.services.newmoon.xmiModel.UMLClassDataType; 
    36 import ndg.services.newmoon.xmiModel.UML_ID; 
     34import ndg.services.newmoon.collect.CollectClassesClosure.CollectionType; 
    3735 
    3836/** 
     
    4543 * 
    4644 */ 
    47 public class AttributeModel<T extends UMLClassDataType> {        
    48         private final T associatedType; 
    49         private final ClassModel associatedClassModel; 
     45public class AttributeModel {    
     46        private final ClassModel associatedType; 
    5047        private final String name;       
    5148        private final Integer lowerBound; 
     
    5350        private final int lenght; 
    5451        private final boolean voidable; 
     52        private final CollectionType collectionType; 
    5553         
    5654        /** 
     
    6159         * @param lenght 
    6260         */ 
    63         public AttributeModel(T associatedType, ClassModel associatedClassModel,  
     61        public AttributeModel(ClassModel associatedType,  
    6462                        String name, int lowerBound, Integer upperBound,  
    65                         Integer lenght, boolean voidable) { 
    66                 this.associatedType = associatedType; 
    67                 this.associatedClassModel = associatedClassModel;                
     63                        Integer lenght, boolean voidable, CollectionType collectionType) { 
     64                this.associatedType = associatedType;            
    6865                this.name = name; 
    6966                this.lowerBound = lowerBound; 
    7067                this.upperBound = upperBound; 
    7168                this.lenght = lenght; 
    72                 this.voidable = voidable;                        
     69                this.voidable = voidable; 
     70                this.collectionType = collectionType; 
    7371        } 
    7472         
    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  
    8373        /** 
    8474         * Returns the associated type. 
    8575         * @return the associatedType 
    8676         */ 
    87         public T getAssociatedType() { 
     77        public ClassModel getAssociatedType() {   
    8878                return associatedType;                                                   
    8979        }        
    9080         
    91         /** 
    92          * Returns the associated UMLClass. If the UMLClass is mapped in the  
    93          * {@link PropertyMap#XMI_TO_SQL_MAP} file then the appropriate UMLClass 
    94          * is returned. 
    95          * @return the associatedClass 
    96          */ 
    97         /* 
    98         public UMLClass getAssociatedClass() { 
    99                 if (associatedClass == null || associatedClass.getName() == null) 
    100                         return null; 
    101                  
    102                 String typeName = StringUtils.defaultIfEmpty( 
    103                                 GenerateModuleHelper.getXMIClassToSQLMap().getProperty(associatedClass.getName()), associatedClass.getName()); 
    104                  
    105                 if (typeName.equals(associatedClass.getName())) 
    106                         return associatedClass; 
    107                          
    108                 return new UMLClassAdapter(new UML_IDAdapder(null, null, typeName), false, false, false, null);                                                  
    109         } 
    110         */ 
    111          
    11281        public boolean hasMultiplicity() { 
    113                 return upperBound > 1; 
     82                return upperBound > 1  
     83                                || collectionType.equals(CollectionType.SET) 
     84                                || collectionType.equals(CollectionType.SEQUENCE); 
    11485        } 
    11586         
     
    139110                return upperBound; 
    140111        } 
    141  
     112         
     113        /** 
     114         * @return the collection 
     115         */ 
     116        public CollectionType getCollectionType() { 
     117                return collectionType; 
     118        } 
     119         
    142120        /** 
    143121         * @return the lenght 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/support/ImportCollector.java

    r7998 r8004  
    4141import ndg.services.newmoon.xmiModel.UMLClass; 
    4242import ndg.services.newmoon.xmiModel.UMLClassDataType; 
    43 import ndg.services.newmoon.xmiModel.UML_ID; 
    4443 
    4544import org.apache.commons.collections.CollectionUtils; 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/xmiModel/UMLDataType.java

    r7998 r8004  
    3939public interface UMLDataType extends UMLClassDataType { 
    4040        UMLModel getUmlModel(); 
     41        UMLClassDataType getType(); 
     42        void setType(UMLClassDataType type);     
    4143} 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/xmiModel/adapter/UMLDataTypeAdapter.java

    r7998 r8004  
    3232package ndg.services.newmoon.xmiModel.adapter; 
    3333 
     34import ndg.services.newmoon.xmiModel.UMLClassDataType; 
    3435import ndg.services.newmoon.xmiModel.UMLDataType; 
    3536import ndg.services.newmoon.xmiModel.UMLModel; 
     
    4243public class UMLDataTypeAdapter extends UMLClassDataTypeAdapter implements UMLDataType { 
    4344 
     45        private UMLClassDataType type; 
     46         
    4447        /** 
    4548         * @param id 
     
    4851         * @param abstrakt 
    4952         */ 
    50         public UMLDataTypeAdapter(UML_ID id, boolean root, boolean leaf, boolean abstrakt, UMLModel umlModel) { 
     53        public UMLDataTypeAdapter(UML_ID id, boolean root, boolean leaf, boolean abstrakt, UMLModel umlModel, UMLClassDataType type) { 
    5154                super(id, root, leaf, abstrakt, umlModel); 
     55                this.type = type; 
     56        } 
     57         
     58        /* (non-Javadoc) 
     59         * @see ndg.services.newmoon.xmiModel.UMLDataType#getType() 
     60         */ 
     61        @Override 
     62        public UMLClassDataType getType() { 
     63                return type; 
    5264        } 
    5365 
     
    7789                return super.equals(obj); 
    7890        } 
     91 
     92        /* (non-Javadoc) 
     93         * @see ndg.services.newmoon.xmiModel.UMLDataType#setType(ndg.services.newmoon.xmiModel.UMLClassDataType) 
     94         */ 
     95        @Override 
     96        public void setType(UMLClassDataType type) { 
     97                this.type = type;                
     98        } 
    7999} 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/xmiModel/v11/UMLDataTypeImpl.java

    r7998 r8004  
    3232package ndg.services.newmoon.xmiModel.v11; 
    3333 
     34import ndg.services.newmoon.xmiModel.UMLClassDataType; 
    3435import ndg.services.newmoon.xmiModel.UMLModel; 
    3536import ndg.services.newmoon.xmiModel.adapter.UMLDataTypeAdapter; 
     
    5051         * @param abstrakt 
    5152         */ 
    52         public UMLDataTypeImpl(Element el, String modelId, UMLModel umlModel) { 
     53        public UMLDataTypeImpl(Element el, String modelId, UMLModel umlModel, UMLClassDataType type) { 
    5354                super(new UML_IDAdapder(el.getAttribute(Dictionary.XMI_ID), modelId, el.getAttribute(Dictionary.NAME)), 
    5455                                Boolean.getBoolean(el.getAttribute(Dictionary.ROOT)),  
    5556                                Boolean.getBoolean(el.getAttribute(Dictionary.LEAF)),  
    5657                                Boolean.getBoolean(el.getAttribute(Dictionary.ABSTRACT)),  
    57                                 umlModel); 
     58                                umlModel, 
     59                                type); 
    5860        } 
    5961 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/global_library.vm

    r7998 r8004  
     1#macro( substituteType $typeName) 
     2#if($typeName.equals('CharacterString')) 
     3ASText#elseif($typeName.equals('Character')) 
     4ASText#elseif($typeName.equals('Integer')) 
     5Integer#elseif($typeName.equals('Boolean')) 
     6BOOLEAN#elseif($typeName.equals('Real')) 
     7NUMERIC#elseif($typeName.equals('Vector')) 
     8ARRAY#elseif($typeName.equals('Number')) 
     9NUMERIC#else 
     10${typeName} 
     11#end 
     12#end 
    113 
    214#macro( tableName $tableModel) 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/velocity.properties

    r7998 r8004  
    22nmVelocity.resource.loader.description = Velocity Classpath Resource Loader 
    33nmVelocity.resource.loader.class = org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader 
     4nmVelocity.resource.loader.path = . 
     5 
    46velocimacro.library = global_library.vm 
    57runtime.references.strict = false 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/velocity/python/mapping.vm

    r7998 r8004  
    11## mapping.vm 
     2 
    23 
    34#macro( beforeInsertListener $tableModel) 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/velocity/python/pythonClass.vm

    r7998 r8004  
    4040#macro (unionDictionary $attributeModel) 
    4141#foreach($item in $attributeModel) 
    42 '${item.name}':${item.associatedClass.name}#if($foreach.hasNext),#end   
     42'${item.name}':#substituteType(${item.associatedType.associatedClass.name})#if($foreach.hasNext),#end   
    4343#end 
    4444#end 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/velocity/python/sqlAlchemyTables.vm

    r7998 r8004  
    55########################################################################## 
    66 
    7  
    87#macro( attributeType $attribute) 
    9 #set ($fkName = ${attribute.associatedClassModel.associatedType}) 
    10 #if(($attribute.associatedClassModel.isCodeList() || $attribute.associatedClassModel.isEnumeration())) 
    11 ${attribute.associatedType.name}.db_type()#elseif($attribute.hasMultiplicity()) 
    12 ARRAY(${attribute.associatedType.name})#else 
    13 ${attribute.associatedType.name}(#if($attribute.lenght > 0)${attribute.lenght}#end)#end 
     8#if(($attribute.associatedType.isCodeList() || $attribute.associatedType.isEnumeration())) 
     9${attribute.associatedType.associatedClass.name}.db_type()#elseif($attribute.hasMultiplicity()) 
     10ARRAY(#substituteType(${attribute.associatedType.associatedClass.name}))#else 
     11#substituteType(${attribute.associatedType.associatedClass.name})(#if($attribute.lenght > 0)${attribute.lenght}#end)#end 
    1412#end 
    1513 
    1614#macro( column $attribute) 
    17 Column('_${attribute.name}', #attributeType($attribute) #checkNullable($attribute)), 
    18 #end 
    19  
    20 #macro( inheritanceColumn $tableModel) 
    21         #foreach( $parent in $tableModel.inherited) 
    22                 #set ($pn = ${parent.associatedClass.name.toLowerCase()}) 
    23                 #set ($tn = ${tableModel.associatedClass.name.toLowerCase()}) 
    24 ${tab}Column('${tn}_${pn}_id', Integer),#end 
    25         #if($tableModel.inherited && $tableModel.inherited.size() > 0) 
    26         #foreach( $parent in $tableModel.inherited) 
    27                 #set ($pn = ${parent.associatedClass.name.toLowerCase()}) 
    28                 #set ($tn = ${tableModel.associatedClass.name.toLowerCase()}) 
    29 ForeignKeyConstraint(['${tn}_${pn}_id'],  
    30         ['${pn}.${pn}_id']),#end 
    31         #end 
     15Column('_${attribute.name}', #attributeType(${attribute}) #checkNullable($attribute)), 
    3216#end 
    3317 
     
    7155#end 
    7256Column('t_type', String(30), nullable=False, default='${associatedCN}'), 
    73 ##inheritanceColumn($tableModel) 
    7457${tab}extend_existing=False,) 
    7558#end 
  • mauRepo/xmi2sqlalchemy/trunk/src/test/java/ngn/services/newmoon/DOMParser.java

    r7998 r8004  
    55import java.io.File; 
    66import java.io.InputStream; 
    7 import java.util.ArrayList; 
     7import java.net.URL; 
    88import java.util.HashMap; 
    9 import java.util.List; 
    109import java.util.Map; 
    1110import java.util.Scanner; 
     
    1514import ndg.services.newmoon.NmParser; 
    1615import ndg.services.newmoon.UMLElementsArchive; 
    17 import ndg.services.newmoon.NewmoonManager.NM_PARAM; 
    1816import ndg.services.newmoon.collect.CollectClasses; 
    1917import ndg.services.newmoon.velocity.python.GenerateClassesClosure; 
    2018import ndg.services.newmoon.velocity.python.GenerateFromClassModel; 
    2119import ndg.services.newmoon.velocity.python.GenerateModuleHelper; 
    22 import ndg.services.newmoon.velocity.python.GenerateTables; 
    2320import ndg.services.newmoon.velocity.python.GenerateTables_; 
    24 import ndg.services.newmoon.velocity.python.support.ClassModel; 
    2521import ndg.services.newmoon.xmiModel.UMLClass; 
    2622import ndg.services.newmoon.xmiModel.UMLModel; 
    2723 
    28 import org.apache.commons.collections.CollectionUtils; 
     24import org.apache.commons.io.FileUtils; 
     25import org.apache.commons.io.IOUtils; 
    2926import org.junit.Assert; 
    3027import org.junit.Test; 
     
    3229public class DOMParser { 
    3330 
     31        //EXECUTION_DIR is where the incoming file/ZIP is copied 
     32        //XMI_DOC is the name of the main XMI file 
    3433        public enum NM_PARAM { 
    3534                XMI_DOC("xmi-path"), REPORT_NAME("reportname"), WORKING_DIRECTORY("working-directory"), DEPENDENCY_REGISTER_PATH( 
     
    6564        @Test 
    6665        public final void testParseXmlFile() { 
    67                 InputStream inputXML = NmParser.class.getClassLoader().getResourceAsStream("CEDA_Model/CEDA_ModelXMI.xml"); 
    68                 InputStream inputAddClass = NmParser.class.getClassLoader().getResourceAsStream("CEDA_Model/AdditionalClasses.txt"); 
     66                //InputStream inputXML = NmParser.class.getClassLoader().getResourceAsStream("CEDA_Model/CEDA_ModelXMI.xml"); 
     67                //InputStream inputAddClass = NmParser.class.getClassLoader().getResourceAsStream("CEDA_Model/AdditionalClasses.txt");           
     68                //File baseDir = new File(GenerateModuleHelper.class.getClassLoader().getResource(".").getPath()); 
    6969                 
    70                 File baseDir = new File(GenerateModuleHelper.class.getClassLoader().getResource(".").getPath()); 
     70                Map<NewmoonManager.NM_PARAM, String> params = new HashMap<NewmoonManager.NM_PARAM, String>(); 
     71                params.put(NewmoonManager.NM_PARAM.EXECUTION_DIR, GenerateModuleHelper.class.getClassLoader().getResource(".").getPath()); 
     72                params.put(NewmoonManager.NM_PARAM.XMI_DOC, "CEDA_Model/CEDA_ModelXMI.xml"); 
     73                params.put(NewmoonManager.NM_PARAM.OUTPUT_DIR, "encode"); 
    7174                 
     75                execute(params); 
     76        } 
     77         
     78        private void execute(Map<NewmoonManager.NM_PARAM, String> params) { 
    7279                try { 
     80                        File baseDir = new File(params.get(NewmoonManager.NM_PARAM.EXECUTION_DIR)); 
     81                         
     82                        InputStream inputXML = FileUtils.openInputStream(new File(baseDir, params.get(NewmoonManager.NM_PARAM.XMI_DOC))); 
     83                        InputStream inputAddClass = FileUtils.openInputStream(new File(baseDir, "CEDA_Model/AdditionalClasses.txt")); 
     84 
    7385                        NmParser xmiParser = new NmParser(inputXML, null); 
    74                         Future<UMLModel> myModel = UMLElementsArchive.getInstance().startNewParser(xmiParser); 
    75                           
    76                         UMLElementsArchive.getInstance().waitParserToComplete(); 
     86                        Future<UMLModel> myModel = UMLElementsArchive.getInstance().startNewParser(xmiParser);                   
     87                        UMLElementsArchive.getInstance().waitParserToComplete();                         
    7788                         
    7889                        /*  I try to generate just what I need */ 
    7990                        UMLModel umlModel = myModel.get(); 
    8091                         
    81                         List<UMLClass> umlClasses = new ArrayList<UMLClass>(); 
    82                         umlClasses.addAll(UMLElementsArchive.getInstance().getUMLElementByType(UMLClass.class)); 
    8392                         
    84                         CollectClasses cc = new CollectClasses(umlClasses); 
     93                        File outDir = new File(baseDir, params.get(NewmoonManager.NM_PARAM.OUTPUT_DIR)); 
     94                        outDir.mkdir(); 
     95                         
     96                        //Generates the ClassModels 
     97                        CollectClasses cc = new CollectClasses(UMLElementsArchive.getInstance().getUMLElementByType(UMLClass.class)); 
    8598                        UMLElementsArchive.getInstance().getClassModel().addAll(cc.execute()); 
    8699                         
    87                         GenerateFromClassModel gen = new GenerateFromClassModel(new GenerateClassesClosure(baseDir)); 
     100                        //Generates the python classes                   
     101                        GenerateFromClassModel gen = new GenerateFromClassModel(new GenerateClassesClosure(outDir)); 
    88102                        gen.execute(UMLElementsArchive.getInstance().getClassModel()); 
    89                          
    90                         GenerateTables_ gen2 = new GenerateTables_(baseDir); 
     103 
     104                        //Generates the sqlalchemy tables 
     105                        GenerateTables_ gen2 = new GenerateTables_(outDir); 
    91106                        gen2.execute(umlModel); 
    92                          
    93                         //GenerateClasses gp = new GenerateClasses(cms); 
    94                         //gp.execute(); 
    95                          
    96                         /* 
    97                         GenerateModule module = new GenerateModule(umlModel); 
    98                         UMLElementsArchive.getInstance().startNewParser(module);                         
    99                         UMLElementsArchive.getInstance().waitParserToComplete(); 
    100                         */ 
    101                          
    102                          
    103                          
    104                         // Is better to generate the table on a separate process in order to minimize the generated tables 
    105                         /* 
    106                         umlClasses.clear(); 
    107                         umlClasses.addAll(UMLElementsArchive.getInstance().getUMLClassesByUMLModel(umlModel)); 
    108                         if (inputAddClass != null) { 
    109                                 Scanner sc = new Scanner(inputAddClass); 
    110                                 if (sc.hasNext()) {                                      
    111                                         CollectionUtils.addIgnoreNull(umlClasses,  
    112                                                         UMLElementsArchive.getInstance().getUMLClassByName(sc.next())); 
    113                                 } 
    114                         } 
    115                         */ 
    116                          
    117                         //GenerateTables tables = new GenerateTables(umlClasses); 
    118                         //tables.execute(); 
    119  
    120107                } catch (Exception e) { 
    121108                        e.printStackTrace(); 
     
    127114                Assert.assertTrue(Boolean.TRUE); // TODO 
    128115        } 
    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         } 
    136116} 
Note: See TracChangeset for help on using the changeset viewer.