Ignore:
Timestamp:
13/01/12 17:17:12 (8 years ago)
Author:
mnagni
Message:

Removed the UMLElementsArchive as singleton in order to use the application "on request"
Included a folder with Spiros's test XMIs

Location:
mauRepo/xmi2sqlalchemy/trunk/src
Files:
15 added
1 deleted
13 edited

Legend:

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

    r7974 r8060  
    5858 
    5959        final static Logger logger = LoggerFactory.getLogger(DepenciesParser.class); 
     60        private final UMLElementsArchive umlArchive; 
    6061 
    6162        /** 
    6263         * @param model 
    6364         */ 
    64         public DepenciesParser(UMLModel model) { 
     65        public DepenciesParser(UMLModel model, UMLElementsArchive umlArchive) { 
    6566                super(); 
    6667                this.model = model; 
     68                this.umlArchive = umlArchive; 
    6769        } 
    6870 
     
    7375        public Properties getXMIMaps() { 
    7476                if (xmiMaps == null) 
    75                         xmiMaps = UMLElementsArchive.getInstance().loadProperties(PropertyMap.XMI_MAP); 
     77                        xmiMaps = UMLElementsArchive.loadProperties(PropertyMap.XMI_MAP); 
    7678                return xmiMaps;          
    7779        }        
     
    98100         */ 
    99101        private synchronized void processDependency(UMLDependency dependency) throws NewmoonException { 
    100                 UMLElementsArchive archive = UMLElementsArchive.getInstance(); 
    101102                 
    102                 if (archive.getUmlModelByUMLDependency(dependency) != null) 
     103                if (umlArchive.getUmlModelByUMLDependency(dependency) != null) 
    103104                        return; 
    104105                 
    105                 EAStub eaStub = archive.getEAStubByUMLDependency(dependency); 
     106                EAStub eaStub = umlArchive.getEAStubByUMLDependency(dependency); 
    106107                if (eaStub == null) 
    107108                        return; 
     
    112113                NmParser xmiParser; 
    113114                InputStream inputXML; 
    114                 if (archive.getPakkages().contains(eaStub.getName())) 
     115                if (umlArchive.getPakkages().contains(eaStub.getName())) 
    115116                        return; 
    116117 
    117118                inputXML = getXMIModelFromStub(eaStub); 
    118119                if (inputXML == null) { 
    119                         archive.synchPackageElement(eaStub.getName(), false); 
     120                        umlArchive.synchPackageElement(eaStub.getName(), false); 
    120121                        return; 
    121122                } 
    122                 archive.synchPackageElement(eaStub.getName(), true); 
     123                umlArchive.synchPackageElement(eaStub.getName(), true); 
    123124                try { 
    124                         xmiParser = new NmParser(inputXML, eaStub.getName()); 
    125                         archive.startNewParser(xmiParser); 
     125                        xmiParser = new NmParser(inputXML, eaStub.getName(), umlArchive); 
     126                        umlArchive.startNewParser(xmiParser); 
    126127                } catch (Exception e) { 
    127128                        logger.warn("Cannot load " + dependency, e); 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/NmParser.java

    r8017 r8060  
    6161        private final ModelXMIFactory modelFactory = new ModelXMI11Factory(); 
    6262        private final String XMI_DOCUMENT_IDENTIFICATOR = Long.toString(Calendar.getInstance().getTimeInMillis()); 
     63        private final UMLElementsArchive umlArchive; 
    6364 
    6465        /** 
     
    6869         * @throws IOException if problems occurs with document parsing  
    6970         **/ 
    70         public NmParser(InputStream inputXML, String keyName) throws IOException { 
     71        public NmParser(InputStream inputXML, String keyName, UMLElementsArchive umlArchive) throws IOException { 
    7172                this.inputXML = IOUtils.toByteArray(inputXML); 
    7273                this.keyName = keyName; 
    73         } 
    74          
    75         /** 
    76          * Generates the python/SQL code from an XMI model.  
    77          * It is used just for test purpose.   
    78          **/ 
    79         public NmParser() { 
    80                 this.inputXML = null; 
    81                 this.keyName = "TestRun"; 
     74                this.umlArchive = umlArchive; 
    8275        } 
    8376         
     
    124117                processXMI(doc.getDocumentElement()); 
    125118                 
    126                 DepenciesParser dp = new DepenciesParser(mainUmlModel); 
     119                DepenciesParser dp = new DepenciesParser(mainUmlModel, umlArchive); 
    127120                dp.startProcess();       
    128121                processGeneralizations(); 
     
    188181                UMLModel model = modelFactory.createUMLModel((Element)node, XMI_DOCUMENT_IDENTIFICATOR, null); 
    189182                 
    190                 UMLModel ret = UMLElementsArchive.getInstance().getUMLModelDefinition(model); 
     183                UMLModel ret = umlArchive.getUMLModelDefinition(model); 
    191184                if (ret != null) { 
    192185                        ret.getKeyNames().add(keyName); 
     
    339332                logger.debug("Now processing Package: " + umlPkg.getName() + " Model: " + umlModel.getName()); 
    340333                 
    341                 UMLElementsArchive.getInstance().synchPackageElement(umlPkg.getName(), true); 
     334                umlArchive.synchPackageElement(umlPkg.getName(), true); 
    342335                 
    343336                node = helper.getFirstSiblingNoTextNode(node.getFirstChild());           
     
    533526                 
    534527                return !element.isReferenceId() ? 
    535                         UMLElementsArchive.getInstance().appendElement(element) : false; 
     528                                umlArchive.appendElement(element) : false; 
    536529        }        
    537530         
     
    543536 
    544537        private void processGeneralizations() { 
    545                 List<UMLGeneralization> generalizations = UMLElementsArchive.getInstance().getUMLElementByType(UMLGeneralization.class); 
     538                List<UMLGeneralization> generalizations = umlArchive.getUMLElementByType(UMLGeneralization.class); 
    546539                for (UMLGeneralization generalization : generalizations) { 
    547                         UML_Element subtype = UMLElementsArchive.getInstance().getType(generalization.getSubtype()); 
     540                        UML_Element subtype = umlArchive.getType(generalization.getSubtype()); 
    548541                        if (subtype instanceof UMLClass) { 
    549542                                ((UMLClass)subtype).getGeneralization().add(generalization); 
     
    553546         
    554547        private void processAssociations() { 
    555                 List<UMLAssociation> associations = UMLElementsArchive.getInstance().getUMLElementByType(UMLAssociation.class); 
     548                List<UMLAssociation> associations = umlArchive.getUMLElementByType(UMLAssociation.class); 
    556549                for (UMLAssociation association : associations) { 
    557550                        if (association.getAssociationEnds().size() == 2) { 
     
    563556         
    564557        private void processEndAssociations(UMLAssociationEnd source, UMLAssociationEnd target) { 
    565                 UML_Element elSource = UMLElementsArchive.getInstance().getType(source.getType()); 
    566                 UML_Element elTarget = UMLElementsArchive.getInstance().getType(target.getType()); 
     558                UML_Element elSource = umlArchive.getType(source.getType()); 
     559                UML_Element elTarget = umlArchive.getType(target.getType()); 
    567560                if (StringUtils.isNotEmpty(target.getName()) && elSource instanceof UMLClass) { 
    568561                        CollectionUtils.addIgnoreNull(((UMLClass)elSource).getAssociationEnds(), target); 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/UMLElementsArchive.java

    r8017 r8060  
    4747import ndg.services.newmoon.collect.ClassModel; 
    4848import ndg.services.newmoon.xmiModel.EAStub; 
    49 import ndg.services.newmoon.xmiModel.UMLAssociation; 
    5049import ndg.services.newmoon.xmiModel.UMLAssociationEnd; 
    5150import ndg.services.newmoon.xmiModel.UMLAttribute; 
     
    9190        private final Map<String, UMLModel> modelIdToModel = Collections.synchronizedMap(new HashMap<String, UMLModel>()); 
    9291        private final Map<EAStub, UMLModel> stubToModel = Collections.synchronizedMap(new HashMap<EAStub, UMLModel>()); 
    93         private final Map<String, UMLClass> classFromNameAndModelID = Collections 
    94                         .synchronizedMap(new HashMap<String, UMLClass>()); 
    95         private final List<UMLAssociation> associations = Collections.synchronizedList(new ArrayList<UMLAssociation>()); 
     92//      private final Map<String, UMLClass> classFromNameAndModelID = Collections.synchronizedMap(new HashMap<String, UMLClass>()); 
     93//      private final List<UMLAssociation> associations = Collections.synchronizedList(new ArrayList<UMLAssociation>()); 
    9694        private final Map<UMLModel, List<UMLDependency>> umlDependenciesByUMLModel = new HashMap<UMLModel, List<UMLDependency>>(); 
    97         private final Map<UMLClass, Set<UMLGeneralization>> umlGeneralizationByUMLClass = new HashMap<UMLClass, Set<UMLGeneralization>>(); 
    9895 
    9996        private final List<EAStub> eaStubList = new ArrayList<EAStub>(); 
     
    10299     
    103100    private final Set<ClassModel> modelClasses = new HashSet<ClassModel>(); 
    104          
    105          
    106         private final static UMLElementsArchive instance = new UMLElementsArchive(); 
    107101 
    108102        private final Map<String, Boolean> multeplicity = new HashMap<String, Boolean>(); 
     
    126120                } 
    127121        }; 
    128  
    129         private UMLElementsArchive() { 
    130         } 
    131  
    132         public static UMLElementsArchive getInstance() { 
    133                 return instance; 
    134         } 
    135122 
    136123        /** 
     
    344331        } 
    345332 
     333        /* 
    346334        private UMLClass getUMLClassFromUMLModelByNameAndModelId(String elementName, String modelId) { 
    347335                if (classFromNameAndModelID.containsKey(elementName + "_" + modelId)) { 
     
    357345                        classFromNameAndModelID.put(elementName + "_" + modelId, umlClass) : umlClass; 
    358346        } 
     347        */ 
    359348 
    360349        private UMLModel getUMLModelByUML_IDModelId(UML_ID elementOwner) { 
     
    434423        } 
    435424         
     425        /* 
    436426        private List<UMLAssociation> getUMLAssociations() { 
    437427                synchronized (associations) { 
     
    440430                } 
    441431                return associations; 
    442         }        
     432        } 
     433        */       
    443434         
    444435        private <T extends UML_ID> List<T> selectUMLElementByPredicate(Predicate predicate) { 
     
    564555        } 
    565556 
    566         private class UMLGeneralizationByUMLClassPredicate implements Predicate { 
    567  
    568                 private UMLClass umlClass; 
    569  
    570                 /** 
    571                  * @param modelId 
    572                  */ 
    573                 public UMLGeneralizationByUMLClassPredicate(UMLClass umlClass) { 
    574                         super(); 
    575                         this.umlClass = umlClass; 
    576                 } 
    577  
    578                 /* 
    579                  * (non-Javadoc) 
    580                  *  
    581                  * @see 
    582                  * org.apache.commons.collections.Predicate#evaluate(java.lang.Object) 
    583                  */ 
    584                 public boolean evaluate(Object object) { 
    585                         if (!(object instanceof UMLGeneralization)) 
    586                                 return false; 
    587                         UMLGeneralization umlGeneralization = ((UMLGeneralization) object); 
    588                         return umlClass.getId().equals(umlGeneralization.getSubtype().getId()); 
    589                 } 
    590         }        
     557//      private class UMLGeneralizationByUMLClassPredicate implements Predicate { 
     558// 
     559//              private UMLClass umlClass; 
     560// 
     561//              /** 
     562//               * @param modelId 
     563//               */ 
     564//              public UMLGeneralizationByUMLClassPredicate(UMLClass umlClass) { 
     565//                      super(); 
     566//                      this.umlClass = umlClass; 
     567//              } 
     568// 
     569//              /* 
     570//               * (non-Javadoc) 
     571//               *  
     572//               * @see 
     573//               * org.apache.commons.collections.Predicate#evaluate(java.lang.Object) 
     574//               */ 
     575//              public boolean evaluate(Object object) { 
     576//                      if (!(object instanceof UMLGeneralization)) 
     577//                              return false; 
     578//                      UMLGeneralization umlGeneralization = ((UMLGeneralization) object); 
     579//                      return umlClass.getId().equals(umlGeneralization.getSubtype().getId()); 
     580//              } 
     581//      }        
    591582         
    592583        private class UMLClassesByUMLModelPredicate implements Predicate { 
     
    642633        } 
    643634 
    644         private class UMLClassFromUMLModelByNameAndModelIdPredicate implements Predicate { 
    645  
    646                 private final String className; 
    647                 private final String modelId; 
    648  
    649                 /** 
    650                  * @param classToSearch 
    651                  */ 
    652                 public UMLClassFromUMLModelByNameAndModelIdPredicate(String className, String modelId) { 
    653                         super(); 
    654                         this.className = className; 
    655                         this.modelId = modelId; 
    656                 } 
    657  
    658                 /* 
    659                  * (non-Javadoc) 
    660                  *  
    661                  * @see 
    662                  * org.apache.commons.collections.Predicate#evaluate(java.lang.Object) 
    663                  */ 
    664                 public boolean evaluate(Object object) { 
    665                         return ((UMLClass) object).getName().equals(className) && ((UMLClass) object).getModelId().equals(modelId); 
    666                 } 
    667         } 
     635//      private class UMLClassFromUMLModelByNameAndModelIdPredicate implements Predicate { 
     636// 
     637//              private final String className; 
     638//              private final String modelId; 
     639// 
     640//              /** 
     641//               * @param classToSearch 
     642//               */ 
     643//              public UMLClassFromUMLModelByNameAndModelIdPredicate(String className, String modelId) { 
     644//                      super(); 
     645//                      this.className = className; 
     646//                      this.modelId = modelId; 
     647//              } 
     648// 
     649//              /* 
     650//               * (non-Javadoc) 
     651//               *  
     652//               * @see 
     653//               * org.apache.commons.collections.Predicate#evaluate(java.lang.Object) 
     654//               */ 
     655//              public boolean evaluate(Object object) { 
     656//                      return ((UMLClass) object).getName().equals(className) && ((UMLClass) object).getModelId().equals(modelId); 
     657//              } 
     658//      } 
    668659 
    669660        /* 
     
    800791        } 
    801792 
    802         public Properties loadProperties(PropertyMap propertiesFile) { 
     793        public static Properties loadProperties(PropertyMap propertiesFile) { 
     794                Logger intLogger = LoggerFactory.getLogger(UMLElementsArchive.class); 
    803795                Properties props = new Properties(); 
    804796                try { 
    805797                        props.load(DepenciesParser.class.getClassLoader().getResourceAsStream(propertiesFile.getPropName())); 
    806798                } catch (IOException e) { 
    807                         if (logger.isWarnEnabled()) 
    808                                 logger.warn("Cannot retieve the " + propertiesFile, e); 
     799                        if (intLogger.isWarnEnabled()) 
     800                                intLogger.warn("Cannot retieve the " + propertiesFile, e); 
    809801                } 
    810802                return props; 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/collect/CollectClassModel.java

    r8009 r8060  
    7979        @Override 
    8080        public void execute(Object input) { 
    81                 if (!(input instanceof UMLClass)) 
    82                         return; 
     81                if (input instanceof UMLClass) { 
     82                        process((UMLClass)input);        
     83                } 
    8384                 
    84                 ClassModel tm = new ClassModel((UMLClass)input);                         
     85                if (input instanceof String) { 
     86                        process((String)input);  
     87                } 
     88        } 
     89         
     90        private void process(UMLClass umlClass) { 
     91                ClassModel tm = new ClassModel(umlClass);                        
    8592                if (models.contains(tm)) { 
    8693                        for (ClassModel model : models) { 
     
    9198                        } 
    9299                } 
    93         }                
     100        } 
     101         
     102        private void process(String className) { 
     103                for (ClassModel model : models) { 
     104                        if (model.getAssociatedClass().getName().equals(className)) { 
     105                                result.add(model); 
     106                                return; 
     107                        }                                                
     108                } 
     109        } 
    94110} 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/collect/CollectClasses.java

    r8009 r8060  
    3434 
    3535import ndg.services.newmoon.NewmoonException; 
     36import ndg.services.newmoon.UMLElementsArchive; 
    3637import ndg.services.newmoon.xmiModel.UMLClass; 
    3738 
     
    4546         
    4647        private final List<UMLClass> umlClasses = new ArrayList<UMLClass>(); 
    47  
    48         public CollectClasses(List<UMLClass> umlClasses) { 
    49                 super(); 
    50                 this.umlClasses.addAll(umlClasses); 
     48        private final UMLElementsArchive umlArchive; 
     49         
     50        public CollectClasses(UMLElementsArchive umlArchive) { 
     51                super();                 
     52                this.umlArchive = umlArchive; 
     53                this.umlClasses.addAll(this.umlArchive.getUMLElementByType(UMLClass.class)); 
    5154        } 
    5255 
    5356        public List<ClassModel> execute() throws IOException, NewmoonException { 
    54                 CollectClassesClosure cc = new CollectClassesClosure(); 
     57                CollectClassesClosure cc = new CollectClassesClosure(umlArchive); 
    5558                CollectionUtils.forAllDo(umlClasses, cc); 
    5659 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/collect/CollectClassesClosure.java

    r8041 r8060  
    6868        private List<NewmoonException> exceptions = new ArrayList<NewmoonException>(); 
    6969 
     70        private final UMLElementsArchive umlArchive; 
     71         
     72        public CollectClassesClosure(UMLElementsArchive umlArchive) { 
     73                super(); 
     74                this.umlArchive = umlArchive; 
     75        } 
     76         
    7077        /* 
    7178         * (non-Javadoc) 
     
    162169         * */ 
    163170        private void collectGeneralization(ClassModel cm) throws NewmoonException, IOException { 
    164                 Set<UMLClass> supertypes = UMLElementsArchive.getInstance().getSupertypesForUMLClass( 
     171                Set<UMLClass> supertypes = umlArchive.getSupertypesForUMLClass( 
    165172                                cm.getAssociatedClass()); 
    166173                Iterator<UMLClass> items = supertypes.iterator(); 
     
    254261                        generateSimpleKeyValues(umlAttribute); 
    255262                        return extractAttribute(umlAttribute.getClassifier(), umlAttribute, cm, 
    256                                         hasMolteplicity(umlAttribute), UMLElementsArchive.getInstance().isVoidable(umlAttribute)); 
     263                                        hasMolteplicity(umlAttribute), umlArchive.isVoidable(umlAttribute)); 
    257264                } 
    258265 
     
    264271                                ClassModel attributeOwner, boolean hasMultiplicity, boolean isVoidable) throws NewmoonException, 
    265272                                IOException { 
    266                         UMLClassDataType umlId = UMLElementsArchive.getInstance().getType(type); 
     273                        UMLClassDataType umlId = umlArchive.getType(type); 
    267274                        if (umlId == null) 
    268275                                throw new NewmoonException("No type for UML_ID: " + type); 
     
    303310                                sBound = extractMulteplicity((UMLAssociationEnd)valueTagged, bound);  
    304311                        } else { 
    305                                 sBound = UMLElementsArchive.getInstance().getTaggedValue(valueTagged, bound); 
     312                                sBound = umlArchive.getTaggedValue(valueTagged, bound); 
    306313                        }  
    307314                        return extractIntegerValue(sBound); 
     
    339346                        if (beginIndex > 0 && endIndex > 0) 
    340347                                umlClassName = umlDataType.getName().substring(beginIndex, endIndex); 
    341                         return UMLElementsArchive.getInstance().getUMLClassByName(umlClassName); 
     348                        return umlArchive.getUMLClassByName(umlClassName); 
    342349                } 
    343350 
     
    355362                private boolean hasMolteplicity(UMLAttribute umlAttribute) { 
    356363                        return hasMolteplicity( 
    357                                         UMLElementsArchive.getInstance().getTaggedValue(umlAttribute, Dictionary.LOWER_BOUND), 
    358                                         UMLElementsArchive.getInstance().getTaggedValue(umlAttribute, Dictionary.UPPER_BOUND)); 
     364                                        umlArchive.getTaggedValue(umlAttribute, Dictionary.LOWER_BOUND), 
     365                                        umlArchive.getTaggedValue(umlAttribute, Dictionary.UPPER_BOUND)); 
    359366                } 
    360367 
     
    405412                 **/ 
    406413                private boolean isSetType(UMLValueTagged valueTagged) { 
    407                         String value = UMLElementsArchive.getInstance().getTaggedValue(valueTagged, Dictionary.TYPE); 
     414                        String value = umlArchive.getTaggedValue(valueTagged, Dictionary.TYPE); 
    408415                        if (value == null) 
    409416                                return false; 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/GenerateClasses.java

    r8048 r8060  
    4040 
    4141import ndg.services.newmoon.NewmoonException; 
     42import ndg.services.newmoon.UMLElementsArchive; 
    4243import ndg.services.newmoon.collect.ClassModel; 
    4344 
     
    5960        private GenerateModuleHelper helper;     
    6061        private final File baseDir; 
     62        private final UMLElementsArchive umlArchive; 
    6163         
    6264        /** 
    6365         * @param baseDir 
    6466         */ 
    65         public GenerateClasses(File baseDir) { 
     67        public GenerateClasses(File baseDir, UMLElementsArchive umlArchive) { 
    6668                super(); 
    6769                this.baseDir = baseDir; 
     70                this.umlArchive = umlArchive;            
    6871        } 
    6972 
     
    9295                if (helper == null) 
    9396                        try { 
    94                                 helper = new GenerateModuleHelper(baseDir); 
     97                                helper = new GenerateModuleHelper(baseDir, umlArchive); 
    9598                        } catch (IOException e) { 
    9699                                // TODO Auto-generated catch block 
     
    112115                        vcontext.put(CONTEXT.attributes.name(), pcm.getAttributes()); 
    113116                        File fl = new File(getHelper().generatePythonPackage(cm.getAssociatedClass().getUmlPackage()), cm.getAssociatedClass().getName().toLowerCase() + ".py"); 
    114                         Writer sqlTablesWriter = new FileWriter(fl, true); 
     117                        Writer sqlTablesWriter = new FileWriter(fl, false); 
    115118                        sqlTablesWriter.append(NmVelocity.getInstance().fillTemplate(vcontext, templateFile));           
    116119                        sqlTablesWriter.close();                         
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/GenerateModuleHelper.java

    r8048 r8060  
    5858         
    5959        private final Logger logger = LoggerFactory.getLogger(UMLElementsArchive.class); 
     60        private final UMLElementsArchive umlArchive; 
    6061         
    61         @Deprecated 
    62         public GenerateModuleHelper() throws IOException { 
    63                 baseDir = new File(GenerateModuleHelper.class.getClassLoader().getResource(".").getPath());                      
    64         } 
    65          
    66         public GenerateModuleHelper(File baseDir) throws IOException { 
    67                 this.baseDir = baseDir;                  
     62        public GenerateModuleHelper(File baseDir, UMLElementsArchive umlArchive) throws IOException { 
     63                this.baseDir = baseDir;  
     64                this.umlArchive = umlArchive; 
    6865        } 
    6966         
     
    9188                        UML_ID umlId = null; 
    9289                        if (stereotype.isReferenceId()) { 
    93                                 umlId = UMLElementsArchive.getInstance().getType(new UML_IDAdapder(stereotype.getId(), stereotype.getModelId())); 
     90                                umlId = umlArchive.getType(new UML_IDAdapder(stereotype.getId(), stereotype.getModelId())); 
    9491                                if (umlId instanceof UMLClass) 
    9592                                        res = (UMLClass)umlId; 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/GenerateTables.java

    r8048 r8060  
    8989         
    9090        private final File baseDir; 
     91        private final UMLElementsArchive umlArchive;     
    9192         
    9293        /** 
    9394         * @param baseDir 
    9495         */ 
    95         public GenerateTables(File baseDir) { 
     96        public GenerateTables(File baseDir, UMLElementsArchive umlArchive) { 
    9697                super(); 
    9798                this.baseDir = baseDir; 
     99                this.umlArchive = umlArchive;            
    98100        } 
    99101 
    100102        public void execute(UMLModel umlModel) throws IOException { 
    101                 CollectClassModel ccm = new CollectClassModel(UMLElementsArchive.getInstance().getClassModel()); 
    102                 CollectionUtils.forAllDo(UMLElementsArchive.getInstance().getUMLClassesByUMLModel(umlModel), ccm); 
    103                  
    104                 GenerateTablesClosure closure = new GenerateTablesClosure(); 
     103                CollectClassModel ccm = new CollectClassModel(umlArchive.getClassModel()); 
     104                CollectionUtils.forAllDo(umlArchive.getUMLClassesByUMLModel(umlModel), ccm); 
     105                 
     106                processOrphans(ccm); 
     107                 
     108                GenerateTablesClosure closure = new GenerateTablesClosure(umlArchive); 
    105109                CollectionUtils.forAllDo(ccm.getResult(), closure); 
    106110                writeAll(closure); 
     111        } 
     112         
     113        private void processOrphans(CollectClassModel ccm) { 
     114                Set<String> externalClasses = new HashSet<String>(); 
     115                externalClasses.add("MO_Organization"); 
     116                CollectionUtils.forAllDo(externalClasses, ccm); 
    107117        } 
    108118         
     
    501511                if (helper == null) 
    502512                        try { 
    503                                 helper = new GenerateModuleHelper(baseDir); 
     513                                helper = new GenerateModuleHelper(baseDir, umlArchive); 
    504514                        } catch (IOException e) { 
    505515                                // TODO Auto-generated catch block 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/GenerateTablesClosure.java

    r8048 r8060  
    4040import ndg.services.newmoon.collect.AttributeModel; 
    4141import ndg.services.newmoon.collect.ClassModel; 
    42 import ndg.services.newmoon.collect.ClassModel.STEREOTYPE; 
    4342import ndg.services.newmoon.velocity.python.support.AssociationTable; 
    4443import ndg.services.newmoon.velocity.python.support.ForeignKey; 
     
    6463        private List<NewmoonException> exceptions = new ArrayList<NewmoonException>(); 
    6564 
     65        private final UMLElementsArchive umlArchive; 
     66         
     67        public GenerateTablesClosure(UMLElementsArchive umlArchive) { 
     68                super(); 
     69                this.umlArchive = umlArchive; 
     70        } 
     71         
    6672        private final Logger logger = LoggerFactory 
    6773                        .getLogger(GenerateTablesClosure.class); 
     
    105111 
    106112        private ClassModel getClassModel(UMLClassDataType umlClass) { 
    107                 return UMLElementsArchive.getInstance().getClassModelByUMLClass(umlClass); 
     113                return umlArchive.getClassModelByUMLClass(umlClass); 
    108114        } 
    109115 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/NmVelocity.java

    r8043 r8060  
    8888         
    8989        public String fillTemplate(Context vcontext, String templateName) { 
    90                 vcontext.put("tab", "\t"); 
     90                vcontext.put("tab", "    "); //four spaces instead of a TAB as required by python standard 
    9191                vcontext.put("nl", "\n"); 
    9292                vcontext.put("vh", NmVelocityHelper.class); 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/NmVelocityHelper.java

    r8048 r8060  
    128128        public static String transformToPythonName(String text) { 
    129129                String trans = StringUtils.replaceChars(text, '-', '_').toLowerCase(); 
     130                 trans = StringUtils.replaceChars(trans, '/', '_').toLowerCase(); 
    130131                 trans = StringUtils.replaceChars(trans, ')', '_').toLowerCase(); 
    131132                 trans = StringUtils.replaceChars(trans, '(', '_').toLowerCase(); 
     
    142143        private static Properties getXMIToSQL() { 
    143144                if (xmiToSQLMaps == null) 
    144                         xmiToSQLMaps = UMLElementsArchive.getInstance().loadProperties(PropertyMap.XMI_TO_SQL_MAP); 
     145                        xmiToSQLMaps = UMLElementsArchive.loadProperties(PropertyMap.XMI_TO_SQL_MAP); 
    145146                return xmiToSQLMaps;             
    146147        } 
  • mauRepo/xmi2sqlalchemy/trunk/src/test/java/ngn/services/newmoon/DOMParser.java

    r8043 r8060  
    1414import ndg.services.newmoon.NmParser; 
    1515import ndg.services.newmoon.UMLElementsArchive; 
     16import ndg.services.newmoon.UmlToRDBM; 
    1617import ndg.services.newmoon.collect.CollectClasses; 
    1718import ndg.services.newmoon.velocity.python.GenerateClasses; 
     
    6263                 
    6364         
    64         @Test 
     65        //@Test 
    6566        public final void testParseXmlFile() { 
    6667                //InputStream inputXML = NmParser.class.getClassLoader().getResourceAsStream("CEDA_Model/CEDA_ModelXMI.xml"); 
     
    7374                params.put(NewmoonManager.NM_PARAM.OUTPUT_DIR, "encode"); 
    7475                 
    75                 execute(params); 
    76         } 
    77          
    78         private void execute(Map<NewmoonManager.NM_PARAM, String> params) { 
    79                 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  
    85                         NmParser xmiParser = new NmParser(inputXML, null); 
    86                         Future<UMLModel> myModel = UMLElementsArchive.getInstance().startNewParser(xmiParser);                   
    87                         UMLElementsArchive.getInstance().waitParserToComplete();                         
    88                          
    89                         /*  I try to generate just what I need */ 
    90                         UMLModel umlModel = myModel.get(); 
    91                          
    92                          
    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)); 
    98                         UMLElementsArchive.getInstance().getClassModel().addAll(cc.execute()); 
    99                          
    100                         //Generates the python classes                   
    101                         GenerateFromClassModel gen = new GenerateFromClassModel(new GenerateClasses(outDir)); 
    102                         gen.execute(UMLElementsArchive.getInstance().getClassModel()); 
    103  
    104                         //Generates the sqlalchemy tables 
    105                         GenerateTables gen2 = new GenerateTables(outDir); 
    106                         gen2.execute(umlModel); 
    107                 } catch (Exception e) { 
    108                         e.printStackTrace(); 
    109                         fail("Not yet implemented"); // TODO 
    110                 } catch (Throwable e) { 
    111                         e.printStackTrace(); 
    112                         fail("Not yet implemented"); // TODO 
    113                 } 
    114                 Assert.assertTrue(Boolean.TRUE); // TODO 
     76                UmlToRDBM umlToDB = new UmlToRDBM(); 
     77                umlToDB.execute(params); 
    11578        } 
    11679} 
Note: See TracChangeset for help on using the changeset viewer.