Ignore:
Timestamp:
03/10/12 23:31:29 (7 years ago)
Author:
mnagni
Message:

XMIEncoder --> GMLEncoder + RDBMEncoder

Location:
mauRepo/newmoonProject/trunk/project
Files:
560 added
5 deleted
6 edited

Legend:

Unmodified
Added
Removed
  • mauRepo/newmoonProject/trunk/project/.project

    r8176 r8607  
    44        <comment></comment> 
    55        <projects> 
    6                 <project>fullmoon</project> 
    76                <project>newmoonJSP</project> 
    87                <project>newmoonReport</project> 
  • mauRepo/newmoonProject/trunk/project/pom.xml

    r8176 r8607  
    7070        <modules> 
    7171                <module>newmoonReport</module> 
    72                 <module>fullmoon</module> 
     72                <module>newmoon</module> 
    7373                <module>newmoonJSP</module> 
    7474                <module>xmi2rdbms</module> 
     75                <module>xmi2gml</module> 
    7576        </modules> 
    7677 
  • mauRepo/newmoonProject/trunk/project/xmi2rdbms/.classpath

    r8176 r8607  
    77        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/> 
    88        <classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER"/> 
     9        <classpathentry combineaccessrules="false" kind="src" path="/core"/> 
    910        <classpathentry kind="output" path="target/classes"/> 
    1011</classpath> 
  • mauRepo/newmoonProject/trunk/project/xmi2rdbms/.project

    r8176 r8607  
    44        <comment></comment> 
    55        <projects> 
    6                 <project>newmoonProject</project> 
     6                <project>core</project> 
    77        </projects> 
    88        <buildSpec> 
  • mauRepo/newmoonProject/trunk/project/xmi2rdbms/pom.xml

    r8175 r8607  
    1919                        <artifactId>velocity</artifactId> 
    2020                        <version>1.7</version> 
    21                 </dependency> 
    22                 <dependency> 
    23                         <groupId>ndg.services.newmoon</groupId> 
    24                         <artifactId>fullmoon</artifactId> 
    25                         <version>2.0.0-SNAPSHOT</version> 
    26                         <exclusions> 
    27                                 <exclusion> 
    28                                         <groupId>exist</groupId> 
    29                                         <artifactId>exist</artifactId> 
    30                                 </exclusion> 
    31                                 <exclusion> 
    32                                         <groupId>exist</groupId> 
    33                                         <artifactId>exist-modules</artifactId> 
    34                                 </exclusion> 
    35                         </exclusions> 
    3621                </dependency> 
    3722                <dependency> 
  • mauRepo/newmoonProject/trunk/project/xmi2rdbms/src/main/java/ndg/services/newmoon/UmlToRDBM.java

    r8414 r8607  
    3333 
    3434import java.io.File; 
    35 import java.io.FileNotFoundException; 
    36 import java.io.IOException; 
    3735import java.io.InputStream; 
    38 import java.util.Collection; 
    39 import java.util.HashMap; 
    40 import java.util.HashSet; 
    41 import java.util.Iterator; 
    42 import java.util.List; 
    4336import java.util.Map; 
    44 import java.util.Set; 
    4537import java.util.concurrent.Future; 
    4638 
    47 import ndg.services.newmoon.NewmoonManager.NM_PARAM; 
    48 import ndg.services.newmoon.collect.AttributeModel; 
    49 import ndg.services.newmoon.collect.ClassModel; 
    50 import ndg.services.newmoon.collect.CollectClasses; 
    51 import ndg.services.newmoon.collect.SuperAttribute; 
    5239import ndg.services.newmoon.exception.NM_ParamException; 
    53 import ndg.services.newmoon.velocity.python.GenerateClasses; 
    54 import ndg.services.newmoon.velocity.python.GenerateFromClassModel; 
    55 import ndg.services.newmoon.velocity.python.GenerateTables; 
    56 import ndg.services.newmoon.xmiModel.UMLClass; 
     40import ndg.services.newmoon.exception.NewmoonException; 
    5741import ndg.services.newmoon.xmiModel.UMLModel; 
    5842 
    59 import org.apache.commons.collections.CollectionUtils; 
    60 import org.apache.commons.collections.ListUtils; 
    61 import org.apache.commons.io.FileUtils; 
    62 import org.apache.commons.io.IOUtils; 
    63 import org.apache.commons.lang.StringUtils; 
    6443import org.slf4j.Logger; 
    6544import org.slf4j.LoggerFactory; 
     
    6948 * 
    7049 */ 
     50@Deprecated 
    7151public class UmlToRDBM extends XMIParserAbstract { 
    7252         
     
    8868                InputStream inputAddClass = null; 
    8969                InputStream constraints = null; 
    90                 Set<String> additionalClasses = null; 
    9170                try { 
    9271                        inputAddClass = openInputStream(params, NewmoonManager.NM_PARAM.XMI_ADD_CLASSES, baseDir); 
    93                         additionalClasses = NmParserHelper.getCSVFromInputStream(inputAddClass); 
    9472                } catch (NM_ParamException ex) { 
    9573                        if (logger.isWarnEnabled()) { 
     
    10785                 
    10886                try { 
    109                         UMLElementsArchive umlArchive = new UMLElementsArchive(); 
    110                         NmParser xmiParser = new NmParser(inputXML, null, umlArchive);           
    111                         Future<UMLModel> myModel = umlArchive.startNewParser(xmiParser);                         
    112                         umlArchive.waitParserToComplete();                       
     87                        NmParser xmiParser = new NmParser(inputXML, null);               
     88                        Future<UMLModel> myModel = xmiParser.getUmlArchive().startNewParser(xmiParser);                  
     89                        xmiParser.getUmlArchive().waitParserToComplete();                        
    11390                         
    11491                        /*  I try to generate just what I need */ 
    11592                        UMLModel umlModel = myModel.get();                       
    11693                         
    117                         //Generates the ClassModels 
    118                         CollectClasses cc = new CollectClasses(umlArchive); 
    119                         List<ClassModel> cms = cc.execute(); 
    120                         umlArchive.getClassModel().addAll(cms); 
    121                  
    122                         applyConstrains(constraints, umlArchive); 
    123                          
    124                         //Update the ClassModels substituting the SuperAttributes when necessary 
    125                         substitutesSuperAttributes(cms); 
    126                                  
    127                          
    128                         //Generates the python classes 
    129                         GenerateFromClassModel gen = new GenerateFromClassModel(new GenerateClasses(outDir, umlArchive)); 
    130                         gen.execute(umlArchive.getClassModel()); 
    131  
    132                         //Generates the sqlalchemy tables 
    133                         GenerateTables gen2 = new GenerateTables(outDir, umlArchive, additionalClasses); 
    134                         gen2.execute(umlModel); 
     94                        XMIToRDBM xmi_to_rdbm = new XMIToRDBM(); 
     95                        xmi_to_rdbm.execute(outDir, xmiParser.getUmlArchive(), inputAddClass, constraints, umlModel); 
    13596                } catch (Exception e) { 
    13697                        e.printStackTrace(); 
     
    140101                        logger.warn("Not yet implemented");     //TODO 
    141102                } 
    142         } 
    143          
    144         private void applyConstrains(InputStream constraints, UMLElementsArchive umlArchive) throws NewmoonException { 
    145                 try { 
    146                         List<String> rules = IOUtils.readLines(constraints); 
    147                         String[] template; 
    148                         for (String rule : rules) { 
    149                                 template = StringUtils.split(rule, ":"); 
    150                                 if (template.length != 3) { 
    151                                         logger.error("Constraint rule not appliable: " + rule); 
    152                                         continue; 
    153                                 } 
    154                                 ClassModel target = umlArchive.getClassModelByClassName(template[0]); 
    155                                 ClassModel constrain = umlArchive.getClassModelByClassName(template[2]); 
    156                                 if (target == null || constrain == null) { 
    157                                         throw new NewmoonException("Cannot apply constrain rule because target--> "  
    158                                                         + template[0] + ":" + target + " constrain--> " + template[2] + ":" + constrain); 
    159                                 } 
    160                                 for (AttributeModel am : target.getAttributeModel()) { 
    161                                         if (am.getName().equals(template[1])) { 
    162                                                 am.setAssociatedType(constrain); 
    163                                         } 
    164                                 } 
    165                         } 
    166                 } catch (IOException ex) { 
    167                         logger.error("Cannot apply constraints", ex); 
    168                 } 
    169         } 
    170          
    171         private void substitutesSuperAttributes(List<ClassModel> cms) { 
    172                 //creates a map between parents and childrens (classes and their subclasses) 
    173                 Map<ClassModel, Set<ClassModel>> pc = new HashMap<ClassModel, Set<ClassModel>>(); 
    174                 for (ClassModel cm : cms) {                      
    175                         for(ClassModel cmp : cm.getParents()) { 
    176                                 if (!pc.containsKey(cmp)) { 
    177                                         pc.put(cmp, new HashSet<ClassModel>()); 
    178                                 } 
    179                                 pc.get(cmp).add(cm); 
    180                         } 
    181                 } 
    182                  
    183                 //removes the item which has zero or one mapping  
    184                 StringBuffer sb = new StringBuffer(); 
    185                 Iterator<ClassModel> iter = pc.keySet().iterator(); 
    186                 while(iter.hasNext()) { 
    187                         ClassModel umlClass = iter.next(); 
    188                         if (pc.get(umlClass).size() <= 1) { 
    189                                 iter.remove(); 
    190                                 continue; 
    191                         }                
    192                         sb.append(umlClass.getAssociatedClass().getName()); 
    193                         sb.append(": ");                         
    194                         for (ClassModel ic : pc.get(umlClass)) { 
    195                                 sb.append(ic.getAssociatedClass().getName()); 
    196                                 sb.append(", ");                                 
    197                         } 
    198                         sb.append("\n"); 
    199                         logger.info(sb.toString()); 
    200                         sb.delete(0, sb.length()); 
    201                 } 
    202                  
    203                 // 
    204                 Map<ClassModel, Set<ClassModel>> classUsers = new HashMap<ClassModel, Set<ClassModel>>(); 
    205                 for (ClassModel cm : cms) { 
    206                         if (cm.isUnion()) { 
    207                                 continue; 
    208                         } 
    209                         Iterator<AttributeModel> iterAttr = cm.getAttributeModel().iterator(); 
    210                         Set<AttributeModel> sas = new HashSet<AttributeModel>(); 
    211                         //Done in this way because seems I cannot trust the iterAttr.remove() method 
    212                         Set<AttributeModel> toRemove = new HashSet<AttributeModel>(); 
    213                         AttributeModel attr = null; 
    214                         while (iterAttr.hasNext()) { 
    215                                 attr = iterAttr.next(); 
    216                                 if (attr == null  
    217                                                 || attr.getAssociatedType() == null  
    218                                                 || attr.getAssociatedType().getAssociatedClass() == null 
    219                                                 || !pc.containsKey(attr.getAssociatedType()) 
    220                                                 || attr instanceof SuperAttribute 
    221                                                 || attr.getAssociatedType().getAssociatedClass().getUmlPackage().toString().contains("19103")) { 
    222                                         continue; 
    223                                 } 
    224  
    225                                 if (!classUsers.containsKey(attr.getAssociatedType())) { 
    226                                         classUsers.put(attr.getAssociatedType(), new HashSet<ClassModel>()); 
    227                                 }                                
    228                                 classUsers.get(attr.getAssociatedType()).add(cm); 
    229                                  
    230                                 SuperAttribute sa = new SuperAttribute(attr);                    
    231                                 sa.getSubTypes().addAll(pc.get(attr.getAssociatedType())); 
    232                                 toRemove.add(attr); 
    233                                 sas.add(sa);                             
    234                         } 
    235                         sas.addAll(ListUtils.removeAll(cm.getAttributeModel(), toRemove)); 
    236                         cm.getAttributeModel().clear(); 
    237                         cm.getAttributeModel().addAll(sas); 
    238                 } 
    239                 logger.info("\n Users list \n"); 
    240                 iter = classUsers.keySet().iterator(); 
    241                 while(iter.hasNext()) { 
    242                         ClassModel umlClass = iter.next(); 
    243                         sb.append(umlClass.getAssociatedClass().getName()); 
    244                         sb.append(": ");                         
    245                         for (ClassModel ic : classUsers.get(umlClass)) { 
    246                                 sb.append(ic.getAssociatedClass().getName()); 
    247                                 sb.append(", ");                                 
    248                         } 
    249                         sb.append("\n"); 
    250                         logger.info(sb.toString()); 
    251                         sb.delete(0, sb.length()); 
    252                 } 
    253103        }  
    254104} 
Note: See TracChangeset for help on using the changeset viewer.