[Eugene-commits] r1272 - trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml

11 Jun 2013

Author: agiraudet
Date: 2013-06-11 14:16:35 +0200 (Tue, 11 Jun 2013)
New Revision: 1272

Url: http://nuiton.org/projects/eugene/repository/revisions/1272

Log:
formatage du code org.nuiton.eugene.models.object.reader.yaml.*

Modified:
   trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/LoadObjectModel.java
   trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/LoadYamlFile.java
   trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/Parser.java
   trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/ParserPureYaml.java
   trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/ParserUserFriendly.java
   trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxePureYaml.java
   trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxeUserFriendly.java
   trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadObjectModel.java
   trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadYamlFile.java
   trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlObject.java
   trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlToObjectModel.java
   trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlUtil.java

Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/LoadObjectModel.java
===================================================================

--- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/LoadObjectModel.java	2013-06-11 10:11:42 UTC (rev 1271)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/LoadObjectModel.java	2013-06-11 12:16:35 UTC (rev 1272)
@@ -15,8 +15,7 @@
     protected YamlObject modelYAMLO;
     protected ObjectModelImpl modelOM;
 
-    public LoadObjectModel(YamlObject modelYAMLO, ObjectModelImpl modelOM)
-    {
+    public LoadObjectModel(YamlObject modelYAMLO, ObjectModelImpl modelOM) {
         this.packageL = "default";
         this.modelOM = modelOM;
         this.modelYAMLO = modelYAMLO;
@@ -27,263 +26,204 @@
 
     public void loadModel() {
         String packageYAMLO = modelYAMLO.getFirstMapStringListString(PACKAGE);
-        if(packageYAMLO == null)
-        {
+        if (packageYAMLO == null) {
             //valeur par defaut
-        }
-        else
-        {
+        } else {
             packageL = packageYAMLO;
         }
 
         String nameYAMLO = modelYAMLO.getFirstMapStringListString(NAME);
-        if(nameYAMLO == null)
-        {
+        if (nameYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             modelOM.setName(nameYAMLO);
         }
 
         String versionYAMLO = modelYAMLO.getFirstMapStringListString(VERSION);
-        if(versionYAMLO == null)
-        {
+        if (versionYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             modelOM.setVersion(versionYAMLO);
         }
 
         //tageValues
         //TODO: tester
         YamlObject tagValues = modelYAMLO.getFirstMapStringListYamlObject(TAG_VALUES);
-        if(tagValues != null)
-        {
-            for(Map.Entry<String,List<String>> tagValue :tagValues.getMapStringListString().entrySet())
-            {
-                if(!tagValue.getValue().isEmpty())//taille strictement = 1
+        if (tagValues != null) {
+            for (Map.Entry<String, List<String>> tagValue : tagValues.getMapStringListString().entrySet()) {
+                if (!tagValue.getValue().isEmpty())//taille strictement = 1
                 {
-                    modelOM.addTagValue(tagValue.getKey(),tagValue.getValue().get(0));
+                    modelOM.addTagValue(tagValue.getKey(), tagValue.getValue().get(0));
                 }
             }
         }
 
         //classes
-        for(YamlObject classYAMLO : modelYAMLO.getMapStringListYamlObject(CLASS))
-        {
+        for (YamlObject classYAMLO : modelYAMLO.getMapStringListYamlObject(CLASS)) {
             ObjectModelClassImpl classOM = new ObjectModelClassImpl();
-            loadClass(classYAMLO,classOM);
+            loadClass(classYAMLO, classOM);
             modelOM.addClass(classOM);
         }
         //interfaces
-        for(YamlObject interfaceYAMLO : modelYAMLO.getMapStringListYamlObject(INTERFACE))
-        {
+        for (YamlObject interfaceYAMLO : modelYAMLO.getMapStringListYamlObject(INTERFACE)) {
             ObjectModelInterfaceImpl interfaceOM = new ObjectModelInterfaceImpl();
-            loadInterface(interfaceYAMLO,interfaceOM);
+            loadInterface(interfaceYAMLO, interfaceOM);
             modelOM.addInterface(interfaceOM);
         }
         //classes d'association
-        for(YamlObject associationClassYAMLO : modelYAMLO.getMapStringListYamlObject(ASSOCIATION_CLASS))
-        {
+        for (YamlObject associationClassYAMLO : modelYAMLO.getMapStringListYamlObject(ASSOCIATION_CLASS)) {
             ObjectModelAssociationClassImpl associationClassOM = new ObjectModelAssociationClassImpl();
-            loadAssociationClass(associationClassYAMLO,associationClassOM);
+            loadAssociationClass(associationClassYAMLO, associationClassOM);
             modelOM.addAssociationClass(associationClassOM);
         }
         //enumerations
-        for(YamlObject enumerationYAMLO : modelYAMLO.getMapStringListYamlObject(ENUMERATION))
-        {
+        for (YamlObject enumerationYAMLO : modelYAMLO.getMapStringListYamlObject(ENUMERATION)) {
             ObjectModelEnumerationImpl enumerationOM = new ObjectModelEnumerationImpl();
-            loadEnumeration(enumerationYAMLO,enumerationOM);
+            loadEnumeration(enumerationYAMLO, enumerationOM);
             modelOM.addEnumeration(enumerationOM);
         }
     }
 
-    public void loadElement(YamlObject elementYAMLO, ObjectModelElementImpl elementOM)
-    {
+    public void loadElement(YamlObject elementYAMLO, ObjectModelElementImpl elementOM) {
         String nameYAMLO = elementYAMLO.getFirstMapStringListString(NAME);
-        if(nameYAMLO == null)
-        {
+        if (nameYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             elementOM.setName(nameYAMLO);
         }
 
         String staticYAMLO = elementYAMLO.getFirstMapStringListString(STATIC);
-        if(staticYAMLO == null)
-        {
+        if (staticYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             elementOM.setStatic(Boolean.valueOf(staticYAMLO));
         }
 
         String documentationYAMLO = elementYAMLO.getFirstMapStringListString(DOCUMENTATION);
-        if(documentationYAMLO == null)
-        {
+        if (documentationYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             elementOM.setDocumentation(documentationYAMLO);
         }
 
         //TODO: tester
         YamlObject tagValues = elementYAMLO.getFirstMapStringListYamlObject(TAG_VALUES);
-        if(tagValues != null)
-        {
-            for(Map.Entry<String,List<String>> tagValue :tagValues.getMapStringListString().entrySet())
-            {
-                if(!tagValue.getValue().isEmpty())//taille strictement = 1
+        if (tagValues != null) {
+            for (Map.Entry<String, List<String>> tagValue : tagValues.getMapStringListString().entrySet()) {
+                if (!tagValue.getValue().isEmpty())//taille strictement = 1
                 {
-                    elementOM.addTagValue(tagValue.getKey(),tagValue.getValue().get(0));
+                    elementOM.addTagValue(tagValue.getKey(), tagValue.getValue().get(0));
                 }
             }
         }
 
         List<String> comments = elementYAMLO.getMapStringListString(COMMENTS);
-        for(String comment : comments)
-        {
+        for (String comment : comments) {
             elementOM.addComment(comment);
         }
 
         List<String> stereotypes = elementYAMLO.getMapStringListString(STEREOTYPES);
-        for(String stereotype : stereotypes)
-        {
+        for (String stereotype : stereotypes) {
             ObjectModelImplRef stereotypeOM = new ObjectModelImplRef();
             stereotypeOM.setName(stereotype);
             elementOM.addStereotype(stereotypeOM);
         }
     }
 
-    public void loadClassifier(YamlObject classifierYAMLO, ObjectModelClassifierImpl classifierOM)
-    {
+    public void loadClassifier(YamlObject classifierYAMLO, ObjectModelClassifierImpl classifierOM) {
         loadElement(classifierYAMLO, classifierOM);
 
-        String  packageYAMLO = classifierYAMLO.getFirstMapStringListString(PACKAGE);
-        if(packageYAMLO == null)
-        {
+        String packageYAMLO = classifierYAMLO.getFirstMapStringListString(PACKAGE);
+        if (packageYAMLO == null) {
             classifierOM.setPackage(packageL);
-        }
-        else
-        {
+        } else {
             classifierOM.setPackage(packageYAMLO);
         }
 
 
         String externYAMLO = classifierYAMLO.getFirstMapStringListString(EXTERN);
-        if(externYAMLO == null)
-        {
+        if (externYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             classifierOM.setExtern(Boolean.valueOf(externYAMLO));
 
         }
 
         String innerYAMLO = classifierYAMLO.getFirstMapStringListString(INNER);
-        if(innerYAMLO == null)
-        {
+        if (innerYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             classifierOM.setInner(Boolean.valueOf(innerYAMLO));
         }
 
         String typeYAMLO = classifierYAMLO.getFirstMapStringListString(TYPE);
-        if(typeYAMLO == null)
-        {
+        if (typeYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             classifierOM.setType(typeYAMLO);
         }
 
-        for(YamlObject attributeYAMLO : classifierYAMLO.getMapStringListYamlObject(ATTRIBUTE))
-        {
+        for (YamlObject attributeYAMLO : classifierYAMLO.getMapStringListYamlObject(ATTRIBUTE)) {
             ObjectModelAttributeImpl attributeOM = new ObjectModelAttributeImpl();
-            loadAttribute(attributeYAMLO,attributeOM);
+            loadAttribute(attributeYAMLO, attributeOM);
             classifierOM.addAttribute(attributeOM);
         }
 
-        for(YamlObject operationYAMLO : classifierYAMLO.getMapStringListYamlObject(OPERATION))
-        {
+        for (YamlObject operationYAMLO : classifierYAMLO.getMapStringListYamlObject(OPERATION)) {
             ObjectModelOperationImpl operationOM = new ObjectModelOperationImpl();
-            loadOperation(operationYAMLO,operationOM);
+            loadOperation(operationYAMLO, operationOM);
             classifierOM.addOperation(operationOM);
         }
 
         List<String> superInterfacesYAMLO = classifierYAMLO.getMapStringListString(SUPER_INTERFACES);
-        for(String superInterfaceYAMLO : superInterfacesYAMLO)
-        {
+        for (String superInterfaceYAMLO : superInterfacesYAMLO) {
             ObjectModelImplRef superInterfaceOM = new ObjectModelImplRef();
             superInterfaceOM.setName(superInterfaceYAMLO);
             classifierOM.addInterface(superInterfaceOM);
         }
     }
 
-    public void loadClass(YamlObject classYAMLO, ObjectModelClassImpl classOM)
-    {
+    public void loadClass(YamlObject classYAMLO, ObjectModelClassImpl classOM) {
         loadClassifier(classYAMLO, classOM);
 
         String abstractYAMLO = classYAMLO.getFirstMapStringListString(ABSTRACT);
-        if(abstractYAMLO == null)
-        {
+        if (abstractYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             classOM.setAbstract(Boolean.valueOf(abstractYAMLO));
         }
 
         List<String> superClassesYAMLO = classYAMLO.getMapStringListString(SUPER_CLASSES);
-        for(String superClassYAMLO : superClassesYAMLO)
-        {
+        for (String superClassYAMLO : superClassesYAMLO) {
             ObjectModelImplSuperClassRef superClassOM = new ObjectModelImplSuperClassRef();
             superClassOM.setName(superClassYAMLO);
             classOM.addSuperclass(superClassOM);
         }
     }
 
-    public void loadInterface(YamlObject interfaceYAMLO, ObjectModelInterfaceImpl interfaceOM)
-    {
-        loadClassifier(interfaceYAMLO,interfaceOM);
+    public void loadInterface(YamlObject interfaceYAMLO, ObjectModelInterfaceImpl interfaceOM) {
+        loadClassifier(interfaceYAMLO, interfaceOM);
     }
 
-    public void loadAssociationClass(YamlObject associationClassYAML, ObjectModelAssociationClassImpl associationClassOM)
-    {
+    public void loadAssociationClass(YamlObject associationClassYAML, ObjectModelAssociationClassImpl associationClassOM) {
         loadClass(associationClassYAML, associationClassOM);
 
         //TODO: remplacer name par type et attribute par name ?
-        for(YamlObject participantYAMLO : associationClassYAML.getMapStringListYamlObject(PARTICIPANT))
-        {
+        for (YamlObject participantYAMLO : associationClassYAML.getMapStringListYamlObject(PARTICIPANT)) {
             ObjectModeImplAssociationClassParticipant participantOM = new ObjectModeImplAssociationClassParticipant();
             participantOM.setAssociationClass(associationClassOM);
 
             String nameYAMLO = participantYAMLO.getFirstMapStringListString(NAME);
-            if(nameYAMLO == null)
-            {
+            if (nameYAMLO == null) {
                 ;//valeur par defaut
-            }
-            else
-            {
+            } else {
                 participantOM.setName(nameYAMLO);
             }
 
             String attributeYAMLO = participantYAMLO.getFirstMapStringListString(ATTRIBUTE);
-            if(attributeYAMLO == null)
-            {
+            if (attributeYAMLO == null) {
                 ;//valeur par defaut
-            }
-            else
-            {
+            } else {
                 participantOM.setAttribute(attributeYAMLO);
             }
 
@@ -291,248 +231,181 @@
         }
     }
 
-    public void loadEnumeration(YamlObject enumerationYAMLO, ObjectModelEnumerationImpl enumerationOM)
-    {
+    public void loadEnumeration(YamlObject enumerationYAMLO, ObjectModelEnumerationImpl enumerationOM) {
         loadElement(enumerationYAMLO, enumerationOM);
 
         //TODO: remplacer LITERAL par LITERALS (List)
         List<String> literalsYAMLO = enumerationYAMLO.getMapStringListString(LITERAL);
-        for(String literalYAMLO : literalsYAMLO)
-        {
+        for (String literalYAMLO : literalsYAMLO) {
             ObjectModelImplRef literalOM = new ObjectModelImplRef();
             literalOM.setName(literalYAMLO);
             enumerationOM.addLiteral(literalOM);
         }
 
         String packageYAMLO = enumerationYAMLO.getFirstMapStringListString(PACKAGE);
-        if(packageYAMLO == null)
-        {
+        if (packageYAMLO == null) {
             enumerationOM.setPackage(packageL);
-        }
-        else
-        {
+        } else {
             enumerationOM.setPackage(packageYAMLO);
         }
     }
 
-    public void loadParameter(YamlObject parameterYAMLO, ObjectModelParameterImpl parameterOM)
-    {
-        loadElement(parameterYAMLO,parameterOM);
+    public void loadParameter(YamlObject parameterYAMLO, ObjectModelParameterImpl parameterOM) {
+        loadElement(parameterYAMLO, parameterOM);
 
         String orderingYAMLO = parameterYAMLO.getFirstMapStringListString(ORDERING);
-        if(orderingYAMLO == null)
-        {
+        if (orderingYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             parameterOM.setOrdering(orderingYAMLO);
         }
 
         String typeYAMLO = parameterYAMLO.getFirstMapStringListString(TYPE);
-        if(typeYAMLO == null)
-        {
+        if (typeYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             parameterOM.setType(typeYAMLO);
         }
 
         String defaultValueYAMLO = parameterYAMLO.getFirstMapStringListString(DEFAULT_VALUE);
-        if(defaultValueYAMLO == null)
-        {
+        if (defaultValueYAMLO == null) {
             ;//default
-        }
-        else
-        {
+        } else {
             parameterOM.setDefaultValue(defaultValueYAMLO);
         }
 
         String minMultiplicityYAMLO = parameterYAMLO.getFirstMapStringListString(MIN_MULTIPLICITY);
-        if(minMultiplicityYAMLO == null)
-        {
+        if (minMultiplicityYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             parameterOM.setMinMultiplicity(Integer.valueOf(minMultiplicityYAMLO));
         }
 
         String maxMultiplicityYAMLO = parameterYAMLO.getFirstMapStringListString(MAX_MULTIPLICITY);
-        if(maxMultiplicityYAMLO == null)
-        {
+        if (maxMultiplicityYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             parameterOM.setMaxMultiplicity(Integer.valueOf(maxMultiplicityYAMLO));
 
         }
 
         String orderedYAMLO = parameterYAMLO.getFirstMapStringListString(ORDERED);
-        if(orderedYAMLO == null)
-        {
+        if (orderedYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             parameterOM.setOrdered(Boolean.valueOf(orderedYAMLO));
         }
 
         String uniqueYAMLO = parameterYAMLO.getFirstMapStringListString(UNIQUE);
-        if(uniqueYAMLO == null)
-        {
+        if (uniqueYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             parameterOM.setUnique(Boolean.valueOf(uniqueYAMLO));
         }
     }
 
-    public void loadAttribute(YamlObject attributeYAMLO, ObjectModelAttributeImpl attributeOM)
-    {
-        loadParameter(attributeYAMLO,attributeOM);
+    public void loadAttribute(YamlObject attributeYAMLO, ObjectModelAttributeImpl attributeOM) {
+        loadParameter(attributeYAMLO, attributeOM);
 
         String navigableYAMLO = attributeYAMLO.getFirstMapStringListString(NAVIGABLE);
-        if(navigableYAMLO == null)
-        {
+        if (navigableYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setNavigable(Boolean.valueOf(navigableYAMLO));
         }
 
         String associationTypeYAMLO = attributeYAMLO.getFirstMapStringListString(ASSOCIATION_TYPE);
-        if(associationTypeYAMLO == null)
-        {
+        if (associationTypeYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setAssociationType(associationTypeYAMLO);
         }
 
         String finalYAMLO = attributeYAMLO.getFirstMapStringListString(FINAL);
-        if(finalYAMLO == null)
-        {
+        if (finalYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setFinal(Boolean.valueOf(finalYAMLO));
         }
 
         String staticYAMLO = attributeYAMLO.getFirstMapStringListString(STATIC);
-        if(staticYAMLO == null)
-        {
+        if (staticYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setStatic(Boolean.valueOf(staticYAMLO));
         }
 
         String associationClassNameYAMLO = attributeYAMLO.getFirstMapStringListString(ASSOCIATION_CLASS_NAME);
-        if(associationClassNameYAMLO == null)
-        {
+        if (associationClassNameYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setAssociationClassName(associationClassNameYAMLO);
         }
 
         String reverseAttributeNameYAMLO = attributeYAMLO.getFirstMapStringListString(REVERSE_ATTRIBUTE_NAME);
-        if(reverseAttributeNameYAMLO == null)
-        {
+        if (reverseAttributeNameYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setReverseAttributeName(reverseAttributeNameYAMLO);
         }
 
         String reverseMaxMultiplicityYAMLO = attributeYAMLO.getFirstMapStringListString(REVERSE_MAX_MULTIPLICITY);
-        if(reverseMaxMultiplicityYAMLO == null)
-        {
+        if (reverseMaxMultiplicityYAMLO == null) {
             //test
             attributeOM.setReverseMaxMultiplicity(1);//valeur par defaut
             //test
-        }
-        else
-        {
+        } else {
             attributeOM.setReverseMaxMultiplicity(Integer.valueOf(reverseMaxMultiplicityYAMLO));
         }
 
         String transientYAMLO = attributeYAMLO.getFirstMapStringListString(TRANSIENT);
-        if(transientYAMLO == null)
-        {
+        if (transientYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setTransient(Boolean.valueOf(transientYAMLO));
         }
 
         String visibilityYAMLO = attributeYAMLO.getFirstMapStringListString(VISIBILITY);
-        if(visibilityYAMLO == null)
-        {
+        if (visibilityYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setVisibility(visibilityYAMLO);
         }
     }
 
-    public void loadOperation(YamlObject operationYAMLO, ObjectModelOperationImpl operationOM)
-    {
-        loadElement(operationYAMLO,operationOM);
+    public void loadOperation(YamlObject operationYAMLO, ObjectModelOperationImpl operationOM) {
+        loadElement(operationYAMLO, operationOM);
 
         String abstractYAMLO = operationYAMLO.getFirstMapStringListString(ABSTRACT);
-        if(abstractYAMLO == null)
-        {
+        if (abstractYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             operationOM.setAbstract(Boolean.valueOf(abstractYAMLO));
         }
 
         String visibilityYAMLO = operationYAMLO.getFirstMapStringListString(VISIBILITY);
-        if(visibilityYAMLO == null)
-        {
+        if (visibilityYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             operationOM.setVisibility(visibilityYAMLO);
         }
 
-        for(YamlObject returnParameterYAMLO : operationYAMLO.getMapStringListYamlObject(RETURN_PARAMETER))
-        {
+        for (YamlObject returnParameterYAMLO : operationYAMLO.getMapStringListYamlObject(RETURN_PARAMETER)) {
             ObjectModelParameterImpl returnParameterOM = new ObjectModelAttributeImpl();
-            loadParameter(returnParameterYAMLO,returnParameterOM);
+            loadParameter(returnParameterYAMLO, returnParameterOM);
             operationOM.setReturnParameter(returnParameterOM);
         }
 
-        for(YamlObject parameterYAMLO : operationYAMLO.getMapStringListYamlObject(PARAMETER))
-        {
+        for (YamlObject parameterYAMLO : operationYAMLO.getMapStringListYamlObject(PARAMETER)) {
             ObjectModelParameterImpl parameterOM = new ObjectModelAttributeImpl();
-            loadParameter(parameterYAMLO,parameterOM);
+            loadParameter(parameterYAMLO, parameterOM);
             operationOM.addParameter(parameterOM);
         }
 
         String bodyCodeYAMLO = operationYAMLO.getFirstMapStringListString(BODY_CODE);
-        if(bodyCodeYAMLO == null)
-        {
+        if (bodyCodeYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             operationOM.setBodyCode(bodyCodeYAMLO);
         }
     }

Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/LoadYamlFile.java
===================================================================
--- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/LoadYamlFile.java	2013-06-11 10:11:42 UTC (rev 1271)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/LoadYamlFile.java	2013-06-11 12:16:35 UTC (rev 1272)
@@ -19,13 +19,11 @@
 public class LoadYamlFile extends KeyWords {
     Yaml yaml;
 
-    public LoadYamlFile()
-    {
+    public LoadYamlFile() {
         yaml = new Yaml();
     }
 
-    public void loadFile(File file, ObjectModel model) throws IOException
-    {
+    public void loadFile(File file, ObjectModel model) throws IOException {
         InputStream inputModel = new FileInputStream(file);
         Object modelYAML = yaml.load(inputModel);
         inputModel.close();
@@ -37,39 +35,30 @@
         String syntaxeVersion = "0";
         String defaultVersion = "0";
 
-        if(modelYAML instanceof List)
-        {
+        if (modelYAML instanceof List) {
             version = YamlUtil.collectElementList((List) modelYAML, SYNTAXE);
             syntaxeVersion = "1";
             defaultVersion = "0";
-        }
-        else if(modelYAML instanceof Map)
-        {
+        } else if (modelYAML instanceof Map) {
             version = YamlUtil.collectElementMap((Map) modelYAML, SYNTAXE);
             syntaxeVersion = "2";
             defaultVersion = "0";
         }
 
-        if(version != null)
-        {
-            syntaxeVersion = YamlUtil.beforeChar(String.valueOf(version),'.');
-            defaultVersion = YamlUtil.afterChar(String.valueOf(version),'.');
+        if (version != null) {
+            syntaxeVersion = YamlUtil.beforeChar(String.valueOf(version), '.');
+            defaultVersion = YamlUtil.afterChar(String.valueOf(version), '.');
         }
 
-        if(syntaxeVersion.equals("1"))
-        {
-            SyntaxePureYaml.loadYamlObject(modelYAML,modelYAMLO);
-        }
-        else if(syntaxeVersion.equals("2"))
-        {
-            SyntaxeUserFriendly.loadYamlObject(modelYAML,modelYAMLO);
-        }
-        else
-        {
+        if (syntaxeVersion.equals("1")) {
+            SyntaxePureYaml.loadYamlObject(modelYAML, modelYAMLO);
+        } else if (syntaxeVersion.equals("2")) {
+            SyntaxeUserFriendly.loadYamlObject(modelYAML, modelYAMLO);
+        } else {
             ;//impossible de charger le modele
         }
 
-        LoadObjectModel loader = new LoadObjectModel(modelYAMLO,modelOM);//+defaultVersion
+        LoadObjectModel loader = new LoadObjectModel(modelYAMLO, modelOM);//+defaultVersion
         loader.loadModel();
     }
 }

Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/Parser.java
===================================================================
--- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/Parser.java	2013-06-11 10:11:42 UTC (rev 1271)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/Parser.java	2013-06-11 12:16:35 UTC (rev 1272)
@@ -15,7 +15,7 @@
 
 /**
  * principe : recuperer Object, retourner YamlObject et resoudre YamlObject
- *
+ * <p/>
  * methode1 : syntaxe stricte, recuperer element en fonction de leur emplacement dans la liste et avec des contains ex: get(indexOf(truc)) ?
  * methode2 : syntaxe moins restrictive, supprimer les élément et en déduir les restant
  * methode3 : la methode3 (ninja hybride)
@@ -24,6 +24,7 @@
 public class Parser extends KeyWords {
 
     private static boolean _loginit = true;
+
     private static void log(String str) {
         try {
             FileWriter log;
@@ -37,11 +38,12 @@
             log = new FileWriter(path, true);
             log.write("[LOG] " + str + "\n");
             log.close();
-        } catch (IOException e) {;}
+        } catch (IOException e) {
+            ;
+        }
     }
 
-    public Parser()
-    {
+    public Parser() {
         ;
     }
 
@@ -51,66 +53,50 @@
     //retourner YAMLO ou modifier YAMLO ?
     //charger class, interface, associationClass ou enumeration
     //it work !
-    public YamlObject parseModel(Object modelYAML, YamlObject modelYAMLO)
-    {
-        if(modelYAML instanceof Map)
-        {
-            for(Object entry : ((Map) modelYAML).entrySet())
-            {
-                if(entry instanceof Map.Entry)
-                {
+    public YamlObject parseModel(Object modelYAML, YamlObject modelYAMLO) {
+        if (modelYAML instanceof Map) {
+            for (Object entry : ((Map) modelYAML).entrySet()) {
+                if (entry instanceof Map.Entry) {
                     String key = String.valueOf(((Map.Entry) entry).getKey());
                     Object value = ((Map.Entry) entry).getValue();
                     //TODO: 1/ containsKey + remove & for() sur le reste
-                    if(key.equals(PACKAGE))
-                    {
-                        modelYAMLO.addStringToMap(PACKAGE,String.valueOf(value));
+                    if (key.equals(PACKAGE)) {
+                        modelYAMLO.addStringToMap(PACKAGE, String.valueOf(value));
                     }
 
-                    if(key.equals(NAME))
-                    {
-                        modelYAMLO.addStringToMap(NAME,String.valueOf(value));
+                    if (key.equals(NAME)) {
+                        modelYAMLO.addStringToMap(NAME, String.valueOf(value));
                     }
 
-                    if(key.equals(VERSION))
-                    {
-                        modelYAMLO.addStringToMap(VERSION,String.valueOf(value));
+                    if (key.equals(VERSION)) {
+                        modelYAMLO.addStringToMap(VERSION, String.valueOf(value));
                     }
 
-                    if(key.equals(IMPORTS))
-                    {
-                        if(value instanceof List)
-                        {
-                            for(Object imp : (List) value)
-                            {
-                                modelYAMLO.addStringToMap(IMPORTS,String.valueOf(imp));
+                    if (key.equals(IMPORTS)) {
+                        if (value instanceof List) {
+                            for (Object imp : (List) value) {
+                                modelYAMLO.addStringToMap(IMPORTS, String.valueOf(imp));
                             }
                         }
                     }
 
-                    List<String> tmp = YamlUtil.charParseIgnore(key,' ','<','>');
-                    if(tmp.contains(CLASS))
-                    {   YamlObject classYAMLO = new YamlObject();
-                        parseClass(key,value,classYAMLO);
-                        modelYAMLO.addYamlObjectToMap(CLASS,classYAMLO);
-                    }
-                    else if(tmp.contains(INTERFACE))
-                    {
+                    List<String> tmp = YamlUtil.charParseIgnore(key, ' ', '<', '>');
+                    if (tmp.contains(CLASS)) {
+                        YamlObject classYAMLO = new YamlObject();
+                        parseClass(key, value, classYAMLO);
+                        modelYAMLO.addYamlObjectToMap(CLASS, classYAMLO);
+                    } else if (tmp.contains(INTERFACE)) {
                         YamlObject interfaceYAMLO = new YamlObject();
-                        parseInterface(key,value,interfaceYAMLO);
-                        modelYAMLO.addYamlObjectToMap(INTERFACE,interfaceYAMLO);
-                    }
-                    else if(tmp.contains(ASSOCIATION_CLASS))
-                    {
+                        parseInterface(key, value, interfaceYAMLO);
+                        modelYAMLO.addYamlObjectToMap(INTERFACE, interfaceYAMLO);
+                    } else if (tmp.contains(ASSOCIATION_CLASS)) {
                         YamlObject associationClassYAMLO = new YamlObject();
-                        parseAssociationClass(key,value,associationClassYAMLO);
-                        modelYAMLO.addYamlObjectToMap(ASSOCIATION_CLASS,associationClassYAMLO);
-                    }
-                    else if(tmp.contains(ENUMERATION))
-                    {
+                        parseAssociationClass(key, value, associationClassYAMLO);
+                        modelYAMLO.addYamlObjectToMap(ASSOCIATION_CLASS, associationClassYAMLO);
+                    } else if (tmp.contains(ENUMERATION)) {
                         YamlObject enumerationYAMLO = new YamlObject();
-                        parseEnumeration(key,value,enumerationYAMLO);
-                        modelYAMLO.addYamlObjectToMap(ENUMERATION,enumerationYAMLO);
+                        parseEnumeration(key, value, enumerationYAMLO);
+                        modelYAMLO.addYamlObjectToMap(ENUMERATION, enumerationYAMLO);
                     }
                 }
             }
@@ -121,51 +107,39 @@
     //name, abstract, static, stereotypes, extern inner, atribute, operation et super classes et super interfaces
     public void parseClass(String key, Object value, YamlObject classYAMLO)//classYAMLO
     {
-        List<String> classPARSE = YamlUtil.charParseIgnore(key,' ','<','>');
-        if(classPARSE.contains(CLASS))
-        {
+        List<String> classPARSE = YamlUtil.charParseIgnore(key, ' ', '<', '>');
+        if (classPARSE.contains(CLASS)) {
             classPARSE.remove(classPARSE.indexOf(CLASS));
         }
-        if(classPARSE.contains(ABSTRACT))
-        {
-            classYAMLO.addStringToMap(ABSTRACT,String.valueOf(true));
+        if (classPARSE.contains(ABSTRACT)) {
+            classYAMLO.addStringToMap(ABSTRACT, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(ABSTRACT));
         }
-        if(classPARSE.contains(STATIC))
-        {
-            classYAMLO.addStringToMap(STATIC,String.valueOf(true));
+        if (classPARSE.contains(STATIC)) {
+            classYAMLO.addStringToMap(STATIC, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(STATIC));
         }
-        if(classPARSE.contains(EXTERN))
-        {
-            classYAMLO.addStringToMap(EXTERN,String.valueOf(true));
+        if (classPARSE.contains(EXTERN)) {
+            classYAMLO.addStringToMap(EXTERN, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(EXTERN));
         }
-        if(classPARSE.contains(INNER))
-        {
-            classYAMLO.addStringToMap(INNER,String.valueOf(true));
+        if (classPARSE.contains(INNER)) {
+            classYAMLO.addStringToMap(INNER, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(INNER));
         }
-        if(classPARSE.contains(PUBLIC))
-        {
-            classYAMLO.addStringToMap(VISIBILITY,PUBLIC);
+        if (classPARSE.contains(PUBLIC)) {
+            classYAMLO.addStringToMap(VISIBILITY, PUBLIC);
             classPARSE.remove(classPARSE.indexOf(PUBLIC));
-        }
-        else if(classPARSE.contains(PRIVATE))
-        {
-            classYAMLO.addStringToMap(VISIBILITY,PRIVATE);
+        } else if (classPARSE.contains(PRIVATE)) {
+            classYAMLO.addStringToMap(VISIBILITY, PRIVATE);
             classPARSE.remove(classPARSE.indexOf(PRIVATE));
-        }
-        else if(classPARSE.contains(PROTECTED))
-        {
-            classYAMLO.addStringToMap(VISIBILITY,PROTECTED);
+        } else if (classPARSE.contains(PROTECTED)) {
+            classYAMLO.addStringToMap(VISIBILITY, PROTECTED);
             classPARSE.remove(classPARSE.indexOf(PROTECTED));
         }
 
-        for(String tmp1 : classPARSE)
-        {
-            if(tmp1.contains("<<") && tmp1.contains(">>"))
-            {
+        for (String tmp1 : classPARSE) {
+            if (tmp1.contains("<<") && tmp1.contains(">>")) {
                 List<Character> targets = new LinkedList<Character>();
                 targets.add('<');
                 targets.add('>');
@@ -174,63 +148,47 @@
                 targets.add(' ');
                 targets.add(',');
                 List<String> tmp3 = YamlUtil.multiCharParse(tmp2, targets);
-                for(String tmp4 : tmp3)
-                {
-                    classYAMLO.addStringToMap(STEREOTYPES,tmp4);
-                    log("stereotype="+tmp4);
+                for (String tmp4 : tmp3) {
+                    classYAMLO.addStringToMap(STEREOTYPES, tmp4);
+                    log("stereotype=" + tmp4);
                 }
             }
         }
-        if(classPARSE.size() > 0)//prend compte de l'ordre : nom avant stereotypes
+        if (classPARSE.size() > 0)//prend compte de l'ordre : nom avant stereotypes
         {
-            classYAMLO.addStringToMap(NAME,classPARSE.get(0));
-            log("name="+classPARSE.get(0));
+            classYAMLO.addStringToMap(NAME, classPARSE.get(0));
+            log("name=" + classPARSE.get(0));
         }
 
-        if(value instanceof Map)
-        {
-            for(Object entry : ((Map) value).entrySet())
-            {
-                if(entry instanceof Map.Entry)
-                {
+        if (value instanceof Map) {
+            for (Object entry : ((Map) value).entrySet()) {
+                if (entry instanceof Map.Entry) {
                     String keyP = String.valueOf(((Map.Entry) entry).getKey());
                     Object valueP = ((Map.Entry) entry).getValue();
 
-                    if(keyP.equals(SUPER_CLASSES))
-                    {
-                        if(valueP instanceof List)
-                        {
-                            for(Object superClass : (List) valueP)
-                            {
+                    if (keyP.equals(SUPER_CLASSES)) {
+                        if (valueP instanceof List) {
+                            for (Object superClass : (List) valueP) {
                                 //TODO: superClasses sur une ligne
-                                classYAMLO.addStringToMap(SUPER_CLASSES,String.valueOf(superClass));
+                                classYAMLO.addStringToMap(SUPER_CLASSES, String.valueOf(superClass));
                             }
                         }
-                    }
-                    else if(keyP.equals(SUPER_INTERFACES))
-                    {
-                        if(valueP instanceof List)
-                        {
-                            for(Object superInterface : (List) valueP)
-                            {
+                    } else if (keyP.equals(SUPER_INTERFACES)) {
+                        if (valueP instanceof List) {
+                            for (Object superInterface : (List) valueP) {
                                 //TODO: superInterfaces sur une ligne
-                                classYAMLO.addStringToMap(SUPER_INTERFACES,String.valueOf(superInterface));
+                                classYAMLO.addStringToMap(SUPER_INTERFACES, String.valueOf(superInterface));
                             }
                         }
-                    }
-                    else
-                    {
-                        if(keyP.contains("(") && keyP.contains(")"))
-                        {
+                    } else {
+                        if (keyP.contains("(") && keyP.contains(")")) {
                             YamlObject operationYAMLO = new YamlObject();
-                            parseOperation(keyP,valueP,operationYAMLO);
-                            classYAMLO.addYamlObjectToMap(OPERATION,operationYAMLO);
-                        }
-                        else
-                        {
+                            parseOperation(keyP, valueP, operationYAMLO);
+                            classYAMLO.addYamlObjectToMap(OPERATION, operationYAMLO);
+                        } else {
                             YamlObject attributeYAMLO = new YamlObject();
-                            parseAttribute(keyP,valueP,attributeYAMLO);
-                            classYAMLO.addYamlObjectToMap(ATTRIBUTE,attributeYAMLO);
+                            parseAttribute(keyP, valueP, attributeYAMLO);
+                            classYAMLO.addYamlObjectToMap(ATTRIBUTE, attributeYAMLO);
                         }
                     }
                 }
@@ -240,51 +198,39 @@
 
     public void parseInterface(String key, Object value, YamlObject interfaceYAMLO)//enlever superflu
     {
-        List<String> classPARSE = YamlUtil.charParseIgnore(key,' ','<','>');
-        if(classPARSE.contains(INTERFACE))
-        {
+        List<String> classPARSE = YamlUtil.charParseIgnore(key, ' ', '<', '>');
+        if (classPARSE.contains(INTERFACE)) {
             classPARSE.remove(classPARSE.indexOf(INTERFACE));
         }
-        if(classPARSE.contains(ABSTRACT))
-        {
+        if (classPARSE.contains(ABSTRACT)) {
             interfaceYAMLO.addStringToMap(ABSTRACT, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(ABSTRACT));
         }
-        if(classPARSE.contains(STATIC))
-        {
+        if (classPARSE.contains(STATIC)) {
             interfaceYAMLO.addStringToMap(STATIC, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(STATIC));
         }
-        if(classPARSE.contains(EXTERN))
-        {
+        if (classPARSE.contains(EXTERN)) {
             interfaceYAMLO.addStringToMap(EXTERN, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(EXTERN));
         }
-        if(classPARSE.contains(INNER))
-        {
+        if (classPARSE.contains(INNER)) {
             interfaceYAMLO.addStringToMap(INNER, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(INNER));
         }
-        if(classPARSE.contains(PUBLIC))
-        {
+        if (classPARSE.contains(PUBLIC)) {
             interfaceYAMLO.addStringToMap(VISIBILITY, PUBLIC);
             classPARSE.remove(classPARSE.indexOf(PUBLIC));
-        }
-        else if(classPARSE.contains(PRIVATE))
-        {
+        } else if (classPARSE.contains(PRIVATE)) {
             interfaceYAMLO.addStringToMap(VISIBILITY, PRIVATE);
             classPARSE.remove(classPARSE.indexOf(PRIVATE));
-        }
-        else if(classPARSE.contains(PROTECTED))
-        {
+        } else if (classPARSE.contains(PROTECTED)) {
             interfaceYAMLO.addStringToMap(VISIBILITY, PROTECTED);
             classPARSE.remove(classPARSE.indexOf(PROTECTED));
         }
 
-        for(String tmp1 : classPARSE)
-        {
-            if(tmp1.contains("<<") && tmp1.contains(">>"))
-            {
+        for (String tmp1 : classPARSE) {
+            if (tmp1.contains("<<") && tmp1.contains(">>")) {
                 List<Character> targets = new LinkedList<Character>();
                 targets.add('<');
                 targets.add('>');
@@ -293,62 +239,46 @@
                 targets.add(' ');
                 targets.add(',');
                 List<String> tmp3 = YamlUtil.multiCharParse(tmp2, targets);
-                for(String tmp4 : tmp3)
-                {
+                for (String tmp4 : tmp3) {
                     interfaceYAMLO.addStringToMap(STEREOTYPES, tmp4);
-                    log("stereotype="+tmp4);
+                    log("stereotype=" + tmp4);
                 }
             }
         }
-        if(classPARSE.size() > 0)//prend compte de l'ordre : nom avant stereotypes
+        if (classPARSE.size() > 0)//prend compte de l'ordre : nom avant stereotypes
         {
             interfaceYAMLO.addStringToMap(NAME, classPARSE.get(0));
-            log("name="+classPARSE.get(0));
+            log("name=" + classPARSE.get(0));
         }
 
-        if(value instanceof Map)
-        {
-            for(Object entry : ((Map) value).entrySet())
-            {
-                if(entry instanceof Map.Entry)
-                {
+        if (value instanceof Map) {
+            for (Object entry : ((Map) value).entrySet()) {
+                if (entry instanceof Map.Entry) {
                     String keyP = String.valueOf(((Map.Entry) entry).getKey());
                     Object valueP = ((Map.Entry) entry).getValue();
 
-                    if(keyP.equals(SUPER_CLASSES))
-                    {
-                        if(valueP instanceof List)
-                        {
-                            for(Object superClass : (List) valueP)
-                            {
+                    if (keyP.equals(SUPER_CLASSES)) {
+                        if (valueP instanceof List) {
+                            for (Object superClass : (List) valueP) {
                                 //TODO: superClasses sur une ligne
                                 interfaceYAMLO.addStringToMap(SUPER_CLASSES, String.valueOf(superClass));
                             }
                         }
-                    }
-                    else if(keyP.equals(SUPER_INTERFACES))
-                    {
-                        if(valueP instanceof List)
-                        {
-                            for(Object superInterface : (List) valueP)
-                            {
+                    } else if (keyP.equals(SUPER_INTERFACES)) {
+                        if (valueP instanceof List) {
+                            for (Object superInterface : (List) valueP) {
                                 //TODO: superInterfaces sur une ligne
                                 interfaceYAMLO.addStringToMap(SUPER_INTERFACES, String.valueOf(superInterface));
                             }
                         }
-                    }
-                    else
-                    {
-                        if(keyP.contains("(") && keyP.contains(")"))
-                        {
+                    } else {
+                        if (keyP.contains("(") && keyP.contains(")")) {
                             YamlObject operationYAMLO = new YamlObject();
-                            parseOperation(keyP,valueP,operationYAMLO);
+                            parseOperation(keyP, valueP, operationYAMLO);
                             interfaceYAMLO.addYamlObjectToMap(OPERATION, operationYAMLO);
-                        }
-                        else
-                        {
+                        } else {
                             YamlObject attributeYAMLO = new YamlObject();
-                            parseAttribute(keyP,valueP,attributeYAMLO);
+                            parseAttribute(keyP, valueP, attributeYAMLO);
                             interfaceYAMLO.addYamlObjectToMap(ATTRIBUTE, attributeYAMLO);
                         }
                     }
@@ -365,51 +295,39 @@
         /*
         FACTORISER LE CODE !
          */
-        List<String> classPARSE = YamlUtil.charParseIgnore(key,' ','<','>');
-        if(classPARSE.contains(ASSOCIATION_CLASS))
-        {
+        List<String> classPARSE = YamlUtil.charParseIgnore(key, ' ', '<', '>');
+        if (classPARSE.contains(ASSOCIATION_CLASS)) {
             classPARSE.remove(classPARSE.indexOf(ASSOCIATION_CLASS));
         }
-        if(classPARSE.contains(ABSTRACT))
-        {
+        if (classPARSE.contains(ABSTRACT)) {
             associationClassYAMLO.addStringToMap(ABSTRACT, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(ABSTRACT));
         }
-        if(classPARSE.contains(STATIC))
-        {
+        if (classPARSE.contains(STATIC)) {
             associationClassYAMLO.addStringToMap(STATIC, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(STATIC));
         }
-        if(classPARSE.contains(EXTERN))
-        {
+        if (classPARSE.contains(EXTERN)) {
             associationClassYAMLO.addStringToMap(EXTERN, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(EXTERN));
         }
-        if(classPARSE.contains(INNER))
-        {
+        if (classPARSE.contains(INNER)) {
             associationClassYAMLO.addStringToMap(INNER, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(INNER));
         }
-        if(classPARSE.contains(PUBLIC))
-        {
+        if (classPARSE.contains(PUBLIC)) {
             associationClassYAMLO.addStringToMap(VISIBILITY, PUBLIC);
             classPARSE.remove(classPARSE.indexOf(PUBLIC));
-        }
-        else if(classPARSE.contains(PRIVATE))
-        {
+        } else if (classPARSE.contains(PRIVATE)) {
             associationClassYAMLO.addStringToMap(VISIBILITY, PRIVATE);
             classPARSE.remove(classPARSE.indexOf(PRIVATE));
-        }
-        else if(classPARSE.contains(PROTECTED))
-        {
+        } else if (classPARSE.contains(PROTECTED)) {
             associationClassYAMLO.addStringToMap(VISIBILITY, PROTECTED);
             classPARSE.remove(classPARSE.indexOf(PROTECTED));
         }
 
-        for(String tmp1 : classPARSE)
-        {
-            if(tmp1.contains("<<") && tmp1.contains(">>"))
-            {
+        for (String tmp1 : classPARSE) {
+            if (tmp1.contains("<<") && tmp1.contains(">>")) {
                 List<Character> targets = new LinkedList<Character>();
                 targets.add('<');
                 targets.add('>');
@@ -418,52 +336,45 @@
                 targets.add(' ');
                 targets.add(',');
                 List<String> tmp3 = YamlUtil.multiCharParse(tmp2, targets);
-                for(String tmp4 : tmp3)
-                {
+                for (String tmp4 : tmp3) {
                     associationClassYAMLO.addStringToMap(STEREOTYPES, tmp4);
-                    log("stereotype="+tmp4);
+                    log("stereotype=" + tmp4);
                 }
             }
         }
-        if(classPARSE.size() > 0)//prend compte de l'ordre : nom avant stereotypes
+        if (classPARSE.size() > 0)//prend compte de l'ordre : nom avant stereotypes
         {
             associationClassYAMLO.addStringToMap(NAME, classPARSE.get(0));
-            log("name="+classPARSE.get(0));
+            log("name=" + classPARSE.get(0));
         }
 
         //participant
-        if(value instanceof Map)
-        {
-            if(((Map) value).containsKey(PARTICIPANT))
-            {
-                if(((Map) value).get(PARTICIPANT) instanceof Map)
-                {
-                    for(Object entry : ((Map) ((Map) value).get(PARTICIPANT)).entrySet())
-                    {
-                        if(entry instanceof Map.Entry)
-                        {
+        if (value instanceof Map) {
+            if (((Map) value).containsKey(PARTICIPANT)) {
+                if (((Map) value).get(PARTICIPANT) instanceof Map) {
+                    for (Object entry : ((Map) ((Map) value).get(PARTICIPANT)).entrySet()) {
+                        if (entry instanceof Map.Entry) {
                             //name attribute "value":
 
-                            List<String> participantPARSE = YamlUtil.charParse(String.valueOf(((Map.Entry) entry).getKey()),' ');
+                            List<String> participantPARSE = YamlUtil.charParse(String.valueOf(((Map.Entry) entry).getKey()), ' ');
                             YamlObject participantYAMLO = new YamlObject();
-                            if(participantPARSE.contains("\""+YamlUtil.extract('"',String.valueOf(((Map.Entry) entry).getKey()))+"\""))
-                            {
-                                String label = YamlUtil.extract('"',String.valueOf(((Map.Entry) entry).getKey()));
+                            if (participantPARSE.contains("\"" + YamlUtil.extract('"', String.valueOf(((Map.Entry) entry).getKey())) + "\"")) {
+                                String label = YamlUtil.extract('"', String.valueOf(((Map.Entry) entry).getKey()));
 
-                                participantYAMLO.addStringToMap(LABEL,label);
+                                participantYAMLO.addStringToMap(LABEL, label);
 
-                                participantPARSE.remove("\""+YamlUtil.extract('"',String.valueOf(((Map.Entry) entry).getKey()))+"\"");
+                                participantPARSE.remove("\"" + YamlUtil.extract('"', String.valueOf(((Map.Entry) entry).getKey())) + "\"");
                             }
 
-                            if(participantPARSE.size() > 0)//ajout type
+                            if (participantPARSE.size() > 0)//ajout type
                             {
-                                participantYAMLO.addStringToMap(NAME,participantPARSE.get(0));
+                                participantYAMLO.addStringToMap(NAME, participantPARSE.get(0));
                             }
-                            if(participantPARSE.size() > 1)//ajout name
+                            if (participantPARSE.size() > 1)//ajout name
                             {
-                                participantYAMLO.addStringToMap(ATTRIBUTE,participantPARSE.get(1));
+                                participantYAMLO.addStringToMap(ATTRIBUTE, participantPARSE.get(1));
                             }
-                            associationClassYAMLO.addYamlObjectToMap(PARTICIPANT,participantYAMLO);
+                            associationClassYAMLO.addYamlObjectToMap(PARTICIPANT, participantYAMLO);
 
                             /*YamlObject participantYAMLO = new YamlObject();
                             participantYAMLO.addStringToMap(NAME, String.valueOf(((Map.Entry) entry).getKey()));
@@ -480,49 +391,34 @@
         }
         //participant
 
-        if(value instanceof Map)
-        {
-            for(Object entry : ((Map) value).entrySet())
-            {
-                if(entry instanceof Map.Entry)
-                {
+        if (value instanceof Map) {
+            for (Object entry : ((Map) value).entrySet()) {
+                if (entry instanceof Map.Entry) {
                     String keyP = String.valueOf(((Map.Entry) entry).getKey());
                     Object valueP = ((Map.Entry) entry).getValue();
 
-                    if(keyP.equals(SUPER_CLASSES))
-                    {
-                        if(valueP instanceof List)
-                        {
-                            for(Object superClass : (List) valueP)
-                            {
+                    if (keyP.equals(SUPER_CLASSES)) {
+                        if (valueP instanceof List) {
+                            for (Object superClass : (List) valueP) {
                                 //TODO: superClasses sur une ligne
                                 associationClassYAMLO.addStringToMap(SUPER_CLASSES, String.valueOf(superClass));
                             }
                         }
-                    }
-                    else if(keyP.equals(SUPER_INTERFACES))
-                    {
-                        if(valueP instanceof List)
-                        {
-                            for(Object superInterface : (List) valueP)
-                            {
+                    } else if (keyP.equals(SUPER_INTERFACES)) {
+                        if (valueP instanceof List) {
+                            for (Object superInterface : (List) valueP) {
                                 //TODO: superInterfaces sur une ligne
                                 associationClassYAMLO.addStringToMap(SUPER_INTERFACES, String.valueOf(superInterface));
                             }
                         }
-                    }
-                    else
-                    {
-                        if(keyP.contains("(") && keyP.contains(")"))
-                        {
+                    } else {
+                        if (keyP.contains("(") && keyP.contains(")")) {
                             YamlObject operationYAMLO = new YamlObject();
-                            parseOperation(keyP,valueP,operationYAMLO);
+                            parseOperation(keyP, valueP, operationYAMLO);
                             associationClassYAMLO.addYamlObjectToMap(OPERATION, operationYAMLO);
-                        }
-                        else
-                        {
+                        } else {
                             YamlObject attributeYAMLO = new YamlObject();
-                            parseAttribute(keyP,valueP,attributeYAMLO);
+                            parseAttribute(keyP, valueP, attributeYAMLO);
                             associationClassYAMLO.addYamlObjectToMap(ATTRIBUTE, attributeYAMLO);
                         }
                     }
@@ -534,23 +430,18 @@
          */
     }
 
-    public void parseEnumeration(String key, Object value, YamlObject enumerationYAMLO)
-    {
-        List<String> enumerationPARSE = YamlUtil.charParseIgnore(key,' ','<','>');
-        if(enumerationPARSE.contains(ENUMERATION))
-        {
+    public void parseEnumeration(String key, Object value, YamlObject enumerationYAMLO) {
+        List<String> enumerationPARSE = YamlUtil.charParseIgnore(key, ' ', '<', '>');
+        if (enumerationPARSE.contains(ENUMERATION)) {
             enumerationPARSE.remove(enumerationPARSE.indexOf(ENUMERATION));
         }
-        if(enumerationPARSE.contains(STATIC))
-        {
-            enumerationYAMLO.addStringToMap(STATIC,String.valueOf(true));
+        if (enumerationPARSE.contains(STATIC)) {
+            enumerationYAMLO.addStringToMap(STATIC, String.valueOf(true));
             enumerationPARSE.remove(enumerationPARSE.indexOf(STATIC));
         }
 
-        for(String tmp1 : enumerationPARSE)
-        {
-            if(tmp1.contains("<<") && tmp1.contains(">>"))
-            {
+        for (String tmp1 : enumerationPARSE) {
+            if (tmp1.contains("<<") && tmp1.contains(">>")) {
                 List<Character> targets = new LinkedList<Character>();
                 targets.add('<');
                 targets.add('>');
@@ -559,16 +450,15 @@
                 targets.add(' ');
                 targets.add(',');
                 List<String> tmp3 = YamlUtil.multiCharParse(tmp2, targets);
-                for(String tmp4 : tmp3)
-                {
-                    enumerationYAMLO.addStringToMap(STEREOTYPES,tmp4);
-                    log("stereotype="+tmp4);
+                for (String tmp4 : tmp3) {
+                    enumerationYAMLO.addStringToMap(STEREOTYPES, tmp4);
+                    log("stereotype=" + tmp4);
                 }
             }
         }
-        if(enumerationPARSE.size() > 0)//prend compte de l'ordre : nom avant stereotypes
+        if (enumerationPARSE.size() > 0)//prend compte de l'ordre : nom avant stereotypes
         {
-            enumerationYAMLO.addStringToMap(NAME,enumerationPARSE.get(0));
+            enumerationYAMLO.addStringToMap(NAME, enumerationPARSE.get(0));
             log("name=" + enumerationPARSE.get(0));
         }
 
@@ -577,95 +467,74 @@
     }
 
     //~ok, fonctionnel
-    public void parseAttribute(String key, Object value, YamlObject attributeYAMLO)
-    {
+    public void parseAttribute(String key, Object value, YamlObject attributeYAMLO) {
         //TODO: defaultValue, multiplicity, associationType, reverse(multiplicity & attributeName)
-        List<String> attributePARSE = YamlUtil.charParseIgnore(key,' ','<','>');
-        log("key="+key);
-        log("keyPARSE="+attributePARSE);
-        if(attributePARSE.contains(STATIC))
-        {
-            attributeYAMLO.addStringToMap(STATIC,String.valueOf(true));
+        List<String> attributePARSE = YamlUtil.charParseIgnore(key, ' ', '<', '>');
+        log("key=" + key);
+        log("keyPARSE=" + attributePARSE);
+        if (attributePARSE.contains(STATIC)) {
+            attributeYAMLO.addStringToMap(STATIC, String.valueOf(true));
             attributePARSE.remove(attributePARSE.indexOf(STATIC));
         }
-        if(attributePARSE.contains(FINAL))
-        {
-            attributeYAMLO.addStringToMap(FINAL,String.valueOf(true));
+        if (attributePARSE.contains(FINAL)) {
+            attributeYAMLO.addStringToMap(FINAL, String.valueOf(true));
             attributePARSE.remove(attributePARSE.indexOf(FINAL));
         }
-        if(attributePARSE.contains(UNIQUE))
-        {
-            attributeYAMLO.addStringToMap(UNIQUE,String.valueOf(true));
+        if (attributePARSE.contains(UNIQUE)) {
+            attributeYAMLO.addStringToMap(UNIQUE, String.valueOf(true));
             attributePARSE.remove(attributePARSE.indexOf(UNIQUE));
         }
-        if(attributePARSE.contains(NAVIGABLE))
-        {
-            attributeYAMLO.addStringToMap(NAVIGABLE,String.valueOf(true));
+        if (attributePARSE.contains(NAVIGABLE)) {
+            attributeYAMLO.addStringToMap(NAVIGABLE, String.valueOf(true));
             attributePARSE.remove(attributePARSE.indexOf(NAVIGABLE));
         }
-        if(attributePARSE.contains(TRANSIENT))
-        {
-            attributeYAMLO.addStringToMap(TRANSIENT,String.valueOf(true));
+        if (attributePARSE.contains(TRANSIENT)) {
+            attributeYAMLO.addStringToMap(TRANSIENT, String.valueOf(true));
             attributePARSE.remove(attributePARSE.indexOf(TRANSIENT));
         }
-        if(attributePARSE.contains(PUBLIC))
-        {
-            attributeYAMLO.addStringToMap(VISIBILITY,PUBLIC);
+        if (attributePARSE.contains(PUBLIC)) {
+            attributeYAMLO.addStringToMap(VISIBILITY, PUBLIC);
             attributePARSE.remove(attributePARSE.indexOf(PUBLIC));
-        }
-        else if(attributePARSE.contains(PROTECTED))
-        {
-            attributeYAMLO.addStringToMap(VISIBILITY,PROTECTED);
+        } else if (attributePARSE.contains(PROTECTED)) {
+            attributeYAMLO.addStringToMap(VISIBILITY, PROTECTED);
             attributePARSE.remove(attributePARSE.indexOf(PUBLIC));
-        }
-        else if(attributePARSE.contains(PRIVATE))
-        {
-            attributeYAMLO.addStringToMap(VISIBILITY,PRIVATE);
+        } else if (attributePARSE.contains(PRIVATE)) {
+            attributeYAMLO.addStringToMap(VISIBILITY, PRIVATE);
             attributePARSE.remove(attributePARSE.indexOf(PUBLIC));
         }
 
-        if(attributePARSE.contains(ORDERED))
-        {
-            attributeYAMLO.addStringToMap(ORDERING,ORDERED);
+        if (attributePARSE.contains(ORDERED)) {
+            attributeYAMLO.addStringToMap(ORDERING, ORDERED);
             attributePARSE.remove(attributePARSE.indexOf(ORDERED));
-        }
-        else if(attributePARSE.contains(UNORDERED))
-        {
-            attributeYAMLO.addStringToMap(ORDERING,UNORDERED);
+        } else if (attributePARSE.contains(UNORDERED)) {
+            attributeYAMLO.addStringToMap(ORDERING, UNORDERED);
             attributePARSE.remove(attributePARSE.indexOf(UNORDERED));
         }
 
-        if(attributePARSE.contains("\""+YamlUtil.extract('"',key)+"\""))
-        {
-            String label = YamlUtil.extract('"',key);
-            attributeYAMLO.addStringToMap(LABEL,label);
-            attributePARSE.remove("\""+YamlUtil.extract('"',key)+"\"");
+        if (attributePARSE.contains("\"" + YamlUtil.extract('"', key) + "\"")) {
+            String label = YamlUtil.extract('"', key);
+            attributeYAMLO.addStringToMap(LABEL, label);
+            attributePARSE.remove("\"" + YamlUtil.extract('"', key) + "\"");
         }
 
-        if(attributePARSE.contains("["+YamlUtil.extract('[',']',key)+"]"))
-        {
-            String multiplicity = YamlUtil.extract('[',']',key);
-            if(multiplicity.equals("*"))
-            {
-                attributeYAMLO.addStringToMap(MIN_MULTIPLICITY,"0");
-                attributeYAMLO.addStringToMap(MAX_MULTIPLICITY,"-1");
-            }
-            else if(multiplicity.contains(".."))
-            {
-                String min = YamlUtil.beforeChar(multiplicity,'.');
+        if (attributePARSE.contains("[" + YamlUtil.extract('[', ']', key) + "]")) {
+            String multiplicity = YamlUtil.extract('[', ']', key);
+            if (multiplicity.equals("*")) {
+                attributeYAMLO.addStringToMap(MIN_MULTIPLICITY, "0");
+                attributeYAMLO.addStringToMap(MAX_MULTIPLICITY, "-1");
+            } else if (multiplicity.contains("..")) {
+                String min = YamlUtil.beforeChar(multiplicity, '.');
                 String max = YamlUtil.afterChar(multiplicity, '.');
-                if(min.equals("*"))
-                {
+                if (min.equals("*")) {
                     min = "-1";
                 }
-                if(max.equals("*"))
-                {
+                if (max.equals("*")) {
                     max = "-1";
                 }
-                attributeYAMLO.addStringToMap(MIN_MULTIPLICITY,min);
-                attributeYAMLO.addStringToMap(MAX_MULTIPLICITY,max);
+                attributeYAMLO.addStringToMap(MIN_MULTIPLICITY, min);
+                attributeYAMLO.addStringToMap(MAX_MULTIPLICITY, max);
             }
-            attributePARSE.remove("["+YamlUtil.extract('[',']',key)+"]");
+            attributePARSE.remove("[" + YamlUtil.extract('[', ']', key) + "]");
         }
 
         //extraire directement car pas de suppression
@@ -706,13 +575,13 @@
             }
         }*/
         //name: type ?
-        if(attributePARSE.size() > 0)//ajout type
+        if (attributePARSE.size() > 0)//ajout type
         {
-            attributeYAMLO.addStringToMap(TYPE,attributePARSE.get(0));
+            attributeYAMLO.addStringToMap(TYPE, attributePARSE.get(0));
         }
-        if(attributePARSE.size() > 1)//ajout name
+        if (attributePARSE.size() > 1)//ajout name
         {
-            attributeYAMLO.addStringToMap(NAME,attributePARSE.get(1));
+            attributeYAMLO.addStringToMap(NAME, attributePARSE.get(1));
         }
 
         /*if(value != null)//defaultValue
@@ -727,8 +596,7 @@
 
     //OK, fonctionnel : yeah ninja flex
     //TODO: return Parameter après les : (value) ? name: value
-    public void parseOperation(String key, Object value, YamlObject operationYAMLO)
-    {
+    public void parseOperation(String key, Object value, YamlObject operationYAMLO) {
         log("operation=" + key);
         List<Character> ignoreStart = new LinkedList<Character>();
         ignoreStart.add('(');
@@ -736,44 +604,33 @@
         List<Character> ignoreEnd = new LinkedList<Character>();
         ignoreEnd.add(')');
         ignoreEnd.add('>');
-        List<String> operationPARSE = YamlUtil.charParseMultiIgnore(key,' ',ignoreStart,ignoreEnd);
+        List<String> operationPARSE = YamlUtil.charParseMultiIgnore(key, ' ', ignoreStart, ignoreEnd);
 
-        if(operationPARSE.contains(STATIC))
-        {
-            operationYAMLO.addStringToMap(STATIC,String.valueOf(true));
+        if (operationPARSE.contains(STATIC)) {
+            operationYAMLO.addStringToMap(STATIC, String.valueOf(true));
             operationPARSE.remove(operationPARSE.indexOf(STATIC));
         }
-        if(operationPARSE.contains(ABSTRACT))
-        {
-            operationYAMLO.addStringToMap(ABSTRACT,String.valueOf(true));
+        if (operationPARSE.contains(ABSTRACT)) {
+            operationYAMLO.addStringToMap(ABSTRACT, String.valueOf(true));
             operationPARSE.remove(operationPARSE.indexOf(ABSTRACT));
         }
-        if(operationPARSE.contains(PUBLIC))
-        {
-            operationYAMLO.addStringToMap(VISIBILITY,PUBLIC);
+        if (operationPARSE.contains(PUBLIC)) {
+            operationYAMLO.addStringToMap(VISIBILITY, PUBLIC);
             operationPARSE.remove(operationPARSE.indexOf(PUBLIC));
-        }
-        else if(operationPARSE.contains(PROTECTED))
-        {
-            operationYAMLO.addStringToMap(VISIBILITY,PROTECTED);
+        } else if (operationPARSE.contains(PROTECTED)) {
+            operationYAMLO.addStringToMap(VISIBILITY, PROTECTED);
             operationPARSE.remove(operationPARSE.indexOf(PROTECTED));
-        }
-        else if(operationPARSE.contains(PRIVATE))
-        {
-            operationYAMLO.addStringToMap(VISIBILITY,PRIVATE);
+        } else if (operationPARSE.contains(PRIVATE)) {
+            operationYAMLO.addStringToMap(VISIBILITY, PRIVATE);
             operationPARSE.remove(operationPARSE.indexOf(PRIVATE));
         }
 
-        for(String tmp : operationPARSE)
-        {
-            if(tmp.contains("(") && tmp.contains(")"))
-            {
-                operationYAMLO.addStringToMap(NAME,YamlUtil.beforeChar(tmp,'('));
-                for(String tmp1 : YamlUtil.charParseIgnore(YamlUtil.extract('(', ')', tmp), ',', '<', '>'))
-                {
-                    List<String> tmp2 = YamlUtil.charParse(tmp1,' ');
-                    if(tmp2.size() == 2)
-                    {
+        for (String tmp : operationPARSE) {
+            if (tmp.contains("(") && tmp.contains(")")) {
+                operationYAMLO.addStringToMap(NAME, YamlUtil.beforeChar(tmp, '('));
+                for (String tmp1 : YamlUtil.charParseIgnore(YamlUtil.extract('(', ')', tmp), ',', '<', '>')) {
+                    List<String> tmp2 = YamlUtil.charParse(tmp1, ' ');
+                    if (tmp2.size() == 2) {
                         YamlObject parameterYAMLO = new YamlObject();
                         parameterYAMLO.addStringToMap(TYPE, tmp2.get(0));
                         parameterYAMLO.addStringToMap(NAME, tmp2.get(1));
@@ -791,129 +648,98 @@
             operationYAMLO.addYamlObjectToMap(RETURN_PARAMETER,returnParameterYAMLO);
         }*/
 
-        if(value != null)
-        {
+        if (value != null) {
             YamlObject returnParameterYAMLO = new YamlObject();
-            returnParameterYAMLO.addStringToMap(TYPE,String.valueOf(value));
-            operationYAMLO.addYamlObjectToMap(RETURN_PARAMETER,returnParameterYAMLO);
+            returnParameterYAMLO.addStringToMap(TYPE, String.valueOf(value));
+            operationYAMLO.addYamlObjectToMap(RETURN_PARAMETER, returnParameterYAMLO);
         }
     }
 
-    public static void resolveImports(YamlObject modelYAMLO)
-    {
+    public static void resolveImports(YamlObject modelYAMLO) {
         //List<String> imports = new LinkedList<String>();
-        Map<String,String> imports = new LinkedHashMap<String, String>();
-        if(modelYAMLO.containsKeyMapStringListString(IMPORTS))
-        {
-            for(String imp : modelYAMLO.getMapStringListString(IMPORTS))
-            {
-                imports.put(YamlUtil.afterChar(imp,'.'),imp);
+        Map<String, String> imports = new LinkedHashMap<String, String>();
+        if (modelYAMLO.containsKeyMapStringListString(IMPORTS)) {
+            for (String imp : modelYAMLO.getMapStringListString(IMPORTS)) {
+                imports.put(YamlUtil.afterChar(imp, '.'), imp);
             }
         }
         //Objects importés: Attribute.Type SuperClasses SuperInterfaces AssociationClass.Participant.Name Parameter.Type(Operation(Class, AssociationClass(Classifier))
         //recursivité pour Parameter et attribute ? Yeah
         String packageM = null;
-        if(modelYAMLO.containsKeyMapStringListString(PACKAGE))
-        {
+        if (modelYAMLO.containsKeyMapStringListString(PACKAGE)) {
             packageM = modelYAMLO.getFirstMapStringListString(PACKAGE);
         }
-        for(Map.Entry<String,List<YamlObject>> entry : modelYAMLO.getMapStringListYamlObject().entrySet())
-        {
-            for(YamlObject importable : entry.getValue())
-            {
-                if(importable.containsKeyMapStringListString(NAME))
-                {
+        for (Map.Entry<String, List<YamlObject>> entry : modelYAMLO.getMapStringListYamlObject().entrySet()) {
+            for (YamlObject importable : entry.getValue()) {
+                if (importable.containsKeyMapStringListString(NAME)) {
                     String name = importable.getFirstMapStringListString(NAME);
-                    if(importable.containsKeyMapStringListString(PACKAGE))
-                    {
-                        imports.put(name,importable.getFirstMapStringListString(PACKAGE)+"."+name);
+                    if (importable.containsKeyMapStringListString(PACKAGE)) {
+                        imports.put(name, importable.getFirstMapStringListString(PACKAGE) + "." + name);
+                    } else if (packageM != null) {
+                        imports.put(name, packageM + "." + name);
                     }
-                    else if(packageM != null)
-                    {
-                        imports.put(name,packageM+"."+name);
-                    }
                 }
             }
         }
-        for(Map.Entry<String,String> imp : imports.entrySet())
-        {
-            log("import="+imp.getKey()+":"+imp.getValue());
+        for (Map.Entry<String, String> imp : imports.entrySet()) {
+            log("import=" + imp.getKey() + ":" + imp.getValue());
         }
 
         //remplacer types par imports complets
-        for(Map.Entry<String,List<YamlObject>> entry : modelYAMLO.getMapStringListYamlObject().entrySet())
-        {
-            for(YamlObject importable : entry.getValue())
-            {
-                if(importable.containsKeyMapStringListString(SUPER_CLASSES))
-                {
-                    for(String value : importable.getMapStringListString(SUPER_CLASSES))
-                    {
-                        if(imports.containsKey(value))
-                        {
-                            importable.setMapStringListString(SUPER_CLASSES,value,imports.get(value));
-                            log("imported="+value+":"+imports.get(value));
+        for (Map.Entry<String, List<YamlObject>> entry : modelYAMLO.getMapStringListYamlObject().entrySet()) {
+            for (YamlObject importable : entry.getValue()) {
+                if (importable.containsKeyMapStringListString(SUPER_CLASSES)) {
+                    for (String value : importable.getMapStringListString(SUPER_CLASSES)) {
+                        if (imports.containsKey(value)) {
+                            importable.setMapStringListString(SUPER_CLASSES, value, imports.get(value));
+                            log("imported=" + value + ":" + imports.get(value));
                         }
                     }
                 }
-                if(importable.containsKeyMapStringListString(SUPER_INTERFACES))
-                {
-                    for(String value : importable.getMapStringListString(SUPER_INTERFACES))
-                    {
-                        if(imports.containsKey(value))
-                        {
-                            importable.setMapStringListString(SUPER_INTERFACES,value,imports.get(value));
-                            log("imported="+value+":"+imports.get(value));
+                if (importable.containsKeyMapStringListString(SUPER_INTERFACES)) {
+                    for (String value : importable.getMapStringListString(SUPER_INTERFACES)) {
+                        if (imports.containsKey(value)) {
+                            importable.setMapStringListString(SUPER_INTERFACES, value, imports.get(value));
+                            log("imported=" + value + ":" + imports.get(value));
                         }
                     }
                 }
-                if(importable.containsKeyYamlMapStringListYamlObject(ATTRIBUTE))
-                {
+                if (importable.containsKeyYamlMapStringListYamlObject(ATTRIBUTE)) {
                     log("   contains attributes");
-                    for(YamlObject attributeYAMLO : importable.getMapStringListYamlObject(ATTRIBUTE))
-                    {
+                    for (YamlObject attributeYAMLO : importable.getMapStringListYamlObject(ATTRIBUTE)) {
                         log("       browse attributes");
-                        if(attributeYAMLO.containsKeyMapStringListString(TYPE))
-                        {
+                        if (attributeYAMLO.containsKeyMapStringListString(TYPE)) {
                             log("           contains type");
                             //if(imports.containsKey(attributeYAMLO.getFirstMapStringListString(TYPE)))
                             {
                                 //attributeYAMLO.setMapStringListString(TYPE,attributeYAMLO.getFirstMapStringListString(TYPE),resolveType(imports.get(attributeYAMLO.getFirstMapStringListString(TYPE)),imports));
-                                attributeYAMLO.setMapStringListString(TYPE,attributeYAMLO.getFirstMapStringListString(TYPE),resolveType(attributeYAMLO.getFirstMapStringListString(TYPE),imports));
+                                attributeYAMLO.setMapStringListString(TYPE, attributeYAMLO.getFirstMapStringListString(TYPE), resolveType(attributeYAMLO.getFirstMapStringListString(TYPE), imports));
                                 log("imported=" + attributeYAMLO.getFirstMapStringListString(TYPE) + ":" + imports.get(attributeYAMLO.getFirstMapStringListString(TYPE)));//retourne null car la clef vient juste d'etre modifiee
                             }
                         }
                     }
                 }
-                if(importable.containsKeyYamlMapStringListYamlObject(OPERATION))
-                {
-                    for(YamlObject operationYAMLO : importable.getMapStringListYamlObject(OPERATION))
-                    {
-                        if(operationYAMLO.containsKeyYamlMapStringListYamlObject(PARAMETER))
-                        {
-                            for(YamlObject parameterYAMLO : operationYAMLO.getMapStringListYamlObject(PARAMETER))
-                            {
-                                if(parameterYAMLO.containsKeyMapStringListString(TYPE))
-                                {
+                if (importable.containsKeyYamlMapStringListYamlObject(OPERATION)) {
+                    for (YamlObject operationYAMLO : importable.getMapStringListYamlObject(OPERATION)) {
+                        if (operationYAMLO.containsKeyYamlMapStringListYamlObject(PARAMETER)) {
+                            for (YamlObject parameterYAMLO : operationYAMLO.getMapStringListYamlObject(PARAMETER)) {
+                                if (parameterYAMLO.containsKeyMapStringListString(TYPE)) {
                                     //if(imports.containsKey(parameterYAMLO.getFirstMapStringListString(TYPE)))
                                     {
                                         //parameterYAMLO.setMapStringListString(TYPE,parameterYAMLO.getFirstMapStringListString(TYPE),resolveType(imports.get(parameterYAMLO.getFirstMapStringListString(TYPE)),imports));
-                                        parameterYAMLO.setMapStringListString(TYPE,parameterYAMLO.getFirstMapStringListString(TYPE),resolveType(parameterYAMLO.getFirstMapStringListString(TYPE),imports));
+                                        parameterYAMLO.setMapStringListString(TYPE, parameterYAMLO.getFirstMapStringListString(TYPE), resolveType(parameterYAMLO.getFirstMapStringListString(TYPE), imports));
 
                                     }
                                 }
                             }
                         }
-                        if(operationYAMLO.containsKeyYamlMapStringListYamlObject(RETURN_PARAMETER))
-                        {
-                            for(YamlObject parameterYAMLO : operationYAMLO.getMapStringListYamlObject(RETURN_PARAMETER))
-                            {
-                                if(parameterYAMLO.containsKeyMapStringListString(TYPE))
-                                {
+                        if (operationYAMLO.containsKeyYamlMapStringListYamlObject(RETURN_PARAMETER)) {
+                            for (YamlObject parameterYAMLO : operationYAMLO.getMapStringListYamlObject(RETURN_PARAMETER)) {
+                                if (parameterYAMLO.containsKeyMapStringListString(TYPE)) {
                                     //if(imports.containsKey(parameterYAMLO.getFirstMapStringListString(TYPE)))
                                     {
                                         //parameterYAMLO.setMapStringListString(TYPE,parameterYAMLO.getFirstMapStringListString(TYPE),resolveType(imports.get(parameterYAMLO.getFirstMapStringListString(TYPE)),imports));
-                                        parameterYAMLO.setMapStringListString(TYPE,parameterYAMLO.getFirstMapStringListString(TYPE),resolveType(parameterYAMLO.getFirstMapStringListString(TYPE),imports));
+                                        parameterYAMLO.setMapStringListString(TYPE, parameterYAMLO.getFirstMapStringListString(TYPE), resolveType(parameterYAMLO.getFirstMapStringListString(TYPE), imports));
 
                                     }
                                 }
@@ -921,16 +747,13 @@
                         }
                     }
                 }
-                if(importable.containsKeyYamlMapStringListYamlObject(PARTICIPANT))
-                {
+                if (importable.containsKeyYamlMapStringListYamlObject(PARTICIPANT)) {
                     log("0");
-                    for(YamlObject participantYAMLO : importable.getMapStringListYamlObject(PARTICIPANT))
-                    {
+                    for (YamlObject participantYAMLO : importable.getMapStringListYamlObject(PARTICIPANT)) {
                         log("1");
-                        if(participantYAMLO.containsKeyMapStringListString(NAME))
-                        {
+                        if (participantYAMLO.containsKeyMapStringListString(NAME)) {
                             log("2");
-                            participantYAMLO.setMapStringListString(NAME,participantYAMLO.getFirstMapStringListString(NAME),resolveType(participantYAMLO.getFirstMapStringListString(NAME),imports));
+                            participantYAMLO.setMapStringListString(NAME, participantYAMLO.getFirstMapStringListString(NAME), resolveType(participantYAMLO.getFirstMapStringListString(NAME), imports));
                         }
                     }
                 }
@@ -939,86 +762,66 @@
     }
 
     //OK
-    public static String browseType(String type, Map<String,String> imports)
-    {
-            StringBuilder res =  new StringBuilder();
-            boolean first = true;
-            for(String tmp : YamlUtil.charParseIgnore(type,',','<','>'))
+    public static String browseType(String type, Map<String, String> imports) {
+        StringBuilder res = new StringBuilder();
+        boolean first = true;
+        for (String tmp : YamlUtil.charParseIgnore(type, ',', '<', '>')) {
+            if (first)//String || List<>
             {
-                if(first)//String || List<>
-                {
-                    first = false;
+                first = false;
+            } else {
+                res.append(",");
+            }
+            if (tmp.contains("<") && tmp.contains(">")) {
+                String ninja = YamlUtil.beforeChar(tmp, '<');
+                if (imports.containsKey(ninja)) {
+                    res.append(imports.get(ninja));
+                } else {
+                    res.append(tmp);
                 }
-                else
-                {
-                    res.append(",");
+                res.append("<");
+                res.append(browseType(YamlUtil.extract('<', '>', tmp), imports));
+                res.append(">");
+            } else {
+                if (imports.containsKey(tmp)) {
+                    res.append(imports.get(tmp));
+                } else {
+                    res.append(tmp);
                 }
-                if(tmp.contains("<") && tmp.contains(">"))
-                {
-                    String ninja = YamlUtil.beforeChar(tmp,'<');
-                    if(imports.containsKey(ninja))
-                    {
-                        res.append(imports.get(ninja));
-                    }
-                    else
-                    {
-                        res.append(tmp);
-                    }
-                    res.append("<");
-                    res.append(browseType(YamlUtil.extract('<','>',tmp),imports));
-                    res.append(">");
-                }
-                else
-                {
-                    if(imports.containsKey(tmp))
-                    {
-                        res.append(imports.get(tmp));
-                    }
-                    else
-                    {
-                        res.append(tmp);
-                    }
-                }
             }
-            return res.toString();
+        }
+        return res.toString();
             /*String ninja = YamlUtil.beforeChar(type,'<');
             String flex = browseType(YamlUtil.extract('<','>',type),imports);
             return ninja+flex;//gerer ',' multi parse fuck yeah*/
     }
+
     //OK
-    public static String resolveType(String type, Map<String,String> imports)
-    {
+    public static String resolveType(String type, Map<String, String> imports) {
         List<Character> ignore = new LinkedList<Character>();
         ignore.add(' ');
-        String typePARSE = YamlUtil.removeMultiChar(type,ignore);
-        return browseType(typePARSE,imports);
+        String typePARSE = YamlUtil.removeMultiChar(type, ignore);
+        return browseType(typePARSE, imports);
     }
 
     //recuperer toyus les attributs dans une seule liste au lieu d'aller les chercher a chaque fois
     public static void resolveLabels(YamlObject modelYAMLO)//reverseAttribute + Labels
     {
         //test variable global
-        Map<String,String> imports = new LinkedHashMap<String, String>();
+        Map<String, String> imports = new LinkedHashMap<String, String>();
         String packageM = null;
-        if(modelYAMLO.containsKeyMapStringListString(PACKAGE))
-        {
+        if (modelYAMLO.containsKeyMapStringListString(PACKAGE)) {
             packageM = modelYAMLO.getFirstMapStringListString(PACKAGE);
         }
-        for(Map.Entry<String,List<YamlObject>> entry : modelYAMLO.getMapStringListYamlObject().entrySet())
-        {
-            for(YamlObject importable : entry.getValue())
-            {
-                if(importable.containsKeyMapStringListString(NAME))
-                {
+        for (Map.Entry<String, List<YamlObject>> entry : modelYAMLO.getMapStringListYamlObject().entrySet()) {
+            for (YamlObject importable : entry.getValue()) {
+                if (importable.containsKeyMapStringListString(NAME)) {
                     String name = importable.getFirstMapStringListString(NAME);
-                    if(importable.containsKeyMapStringListString(PACKAGE))
-                    {
-                        imports.put(name,importable.getFirstMapStringListString(PACKAGE)+"."+name);
+                    if (importable.containsKeyMapStringListString(PACKAGE)) {
+                        imports.put(name, importable.getFirstMapStringListString(PACKAGE) + "." + name);
+                    } else if (packageM != null) {
+                        imports.put(name, packageM + "." + name);
                     }
-                    else if(packageM != null)
-                    {
-                        imports.put(name,packageM+"."+name);
-                    }
                 }
             }
         }
@@ -1027,25 +830,18 @@
 
         List<String> importsI = new LinkedList<String>();
         //String packageM = null;
-        if(modelYAMLO.containsKeyMapStringListString(PACKAGE))
-        {
+        if (modelYAMLO.containsKeyMapStringListString(PACKAGE)) {
             packageM = modelYAMLO.getFirstMapStringListString(PACKAGE);
         }
-        for(Map.Entry<String,List<YamlObject>> entry : modelYAMLO.getMapStringListYamlObject().entrySet())
-        {
-            for(YamlObject importable : entry.getValue())
-            {
-                if(importable.containsKeyMapStringListString(NAME))
-                {
+        for (Map.Entry<String, List<YamlObject>> entry : modelYAMLO.getMapStringListYamlObject().entrySet()) {
+            for (YamlObject importable : entry.getValue()) {
+                if (importable.containsKeyMapStringListString(NAME)) {
                     String name = importable.getFirstMapStringListString(NAME);
-                    if(importable.containsKeyMapStringListString(PACKAGE))
-                    {
-                        importsI.add(importable.getFirstMapStringListString(PACKAGE)+"."+name);
+                    if (importable.containsKeyMapStringListString(PACKAGE)) {
+                        importsI.add(importable.getFirstMapStringListString(PACKAGE) + "." + name);
+                    } else if (packageM != null) {
+                        importsI.add(packageM + "." + name);
                     }
-                    else if(packageM != null)
-                    {
-                        importsI.add(packageM+"."+name);
-                    }
                 }
             }
         }
@@ -1055,89 +851,69 @@
         //if label -> chercher reverse attribute
         //else ajouter attribut navigable=false
         //+ bricoler nom
-        for(List<YamlObject> objectYAMLO : modelYAMLO.getMapStringListYamlObject().values())
-        {
-            for(YamlObject labelisable : objectYAMLO)
-            {
-                if(labelisable.containsKeyYamlMapStringListYamlObject(ATTRIBUTE))
-                {
-                    for(YamlObject attribute : labelisable.getMapStringListYamlObject(ATTRIBUTE))
-                    {
-                        if(attribute.containsKeyMapStringListString(TYPE))
-                        {
+        for (List<YamlObject> objectYAMLO : modelYAMLO.getMapStringListYamlObject().values()) {
+            for (YamlObject labelisable : objectYAMLO) {
+                if (labelisable.containsKeyYamlMapStringListYamlObject(ATTRIBUTE)) {
+                    for (YamlObject attribute : labelisable.getMapStringListYamlObject(ATTRIBUTE)) {
+                        if (attribute.containsKeyMapStringListString(TYPE)) {
                             String type = attribute.getFirstMapStringListString(TYPE);
-                            log("type="+type);
-                            if(importsI.contains(type))//refClassifier
+                            log("type=" + type);
+                            if (importsI.contains(type))//refClassifier
                             {
                                 //pas encore passé par la//osef composite
-                                if(!attribute.containsKeyMapStringListString(NAVIGABLE))
-                                {
-                                    if(attribute.containsKeyMapStringListString(LABEL))//bidirectionnel, recup reverse maxMultiplicity, reverseAttributeName et setNavigable(true)
+                                if (!attribute.containsKeyMapStringListString(NAVIGABLE)) {
+                                    if (attribute.containsKeyMapStringListString(LABEL))//bidirectionnel, recup reverse maxMultiplicity, reverseAttributeName et setNavigable(true)
                                     {
                                         String label = attribute.getFirstMapStringListString(LABEL);
-                                        log("label="+label);
-                                        YamlObject reverseAttribute = getReverseAttribute(modelYAMLO,YamlUtil.afterChar(type,'.'),label);
-                                        if(reverseAttribute != null)
-                                        {
-                                            attribute.addStringToMap(NAVIGABLE,String.valueOf(true));
-                                            reverseAttribute.addStringToMap(NAVIGABLE,String.valueOf(true));
-                                            if(attribute.containsKeyMapStringListString(MAX_MULTIPLICITY))
-                                            {
-                                                reverseAttribute.addStringToMap(REVERSE_MAX_MULTIPLICITY,attribute.getFirstMapStringListString(MAX_MULTIPLICITY));
+                                        log("label=" + label);
+                                        YamlObject reverseAttribute = getReverseAttribute(modelYAMLO, YamlUtil.afterChar(type, '.'), label);
+                                        if (reverseAttribute != null) {
+                                            attribute.addStringToMap(NAVIGABLE, String.valueOf(true));
+                                            reverseAttribute.addStringToMap(NAVIGABLE, String.valueOf(true));
+                                            if (attribute.containsKeyMapStringListString(MAX_MULTIPLICITY)) {
+                                                reverseAttribute.addStringToMap(REVERSE_MAX_MULTIPLICITY, attribute.getFirstMapStringListString(MAX_MULTIPLICITY));
                                             }
-                                            if(reverseAttribute.containsKeyMapStringListString(MAX_MULTIPLICITY))
-                                            {
-                                                attribute.addStringToMap(REVERSE_MAX_MULTIPLICITY,reverseAttribute.getFirstMapStringListString(MAX_MULTIPLICITY));
+                                            if (reverseAttribute.containsKeyMapStringListString(MAX_MULTIPLICITY)) {
+                                                attribute.addStringToMap(REVERSE_MAX_MULTIPLICITY, reverseAttribute.getFirstMapStringListString(MAX_MULTIPLICITY));
                                             }
-                                            if(attribute.containsKeyMapStringListString(NAME))
-                                            {
-                                                reverseAttribute.addStringToMap(REVERSE_ATTRIBUTE_NAME,attribute.getFirstMapStringListString(NAME));
+                                            if (attribute.containsKeyMapStringListString(NAME)) {
+                                                reverseAttribute.addStringToMap(REVERSE_ATTRIBUTE_NAME, attribute.getFirstMapStringListString(NAME));
                                             }
-                                            if(reverseAttribute.containsKeyMapStringListString(NAME))
-                                            {
-                                                attribute.addStringToMap(REVERSE_ATTRIBUTE_NAME,reverseAttribute.getFirstMapStringListString(NAME));
+                                            if (reverseAttribute.containsKeyMapStringListString(NAME)) {
+                                                attribute.addStringToMap(REVERSE_ATTRIBUTE_NAME, reverseAttribute.getFirstMapStringListString(NAME));
                                             }
                                         }
-                                    }
-                                    else//unidirectionnel
+                                    } else//unidirectionnel
                                     {
                                         log("unidirectionnel");
-                                        YamlObject reverseObject = getReverseObject(modelYAMLO,YamlUtil.afterChar(type,'.'));
-                                        if(reverseObject != null)
-                                        {
+                                        YamlObject reverseObject = getReverseObject(modelYAMLO, YamlUtil.afterChar(type, '.'));
+                                        if (reverseObject != null) {
                                             log("reverseObject != null");
                                             YamlObject reverseAttribute = new YamlObject();
-                                            reverseAttribute.addStringToMap(NAVIGABLE,String.valueOf(false));
-                                            reverseAttribute.addStringToMap(TYPE,imports.get(labelisable.getFirstMapStringListString(NAME)));
-                                            if(attribute.containsKeyMapStringListString(MAX_MULTIPLICITY))
-                                            {
-                                                reverseAttribute.addStringToMap(REVERSE_MAX_MULTIPLICITY,attribute.getFirstMapStringListString(MAX_MULTIPLICITY));
+                                            reverseAttribute.addStringToMap(NAVIGABLE, String.valueOf(false));
+                                            reverseAttribute.addStringToMap(TYPE, imports.get(labelisable.getFirstMapStringListString(NAME)));
+                                            if (attribute.containsKeyMapStringListString(MAX_MULTIPLICITY)) {
+                                                reverseAttribute.addStringToMap(REVERSE_MAX_MULTIPLICITY, attribute.getFirstMapStringListString(MAX_MULTIPLICITY));
                                             }
-                                            if(attribute.containsKeyMapStringListString(NAME))
-                                            {
-                                                reverseAttribute.addStringToMap(REVERSE_ATTRIBUTE_NAME,attribute.getFirstMapStringListString(NAME));
+                                            if (attribute.containsKeyMapStringListString(NAME)) {
+                                                reverseAttribute.addStringToMap(REVERSE_ATTRIBUTE_NAME, attribute.getFirstMapStringListString(NAME));
                                             }
                                             //test
-                                            if(attribute.containsKeyMapStringListString(ORDERING))
-                                            {
-                                                if(attribute.getFirstMapStringListString(ORDERING).equals(ORDERED))
-                                                {
-                                                    reverseAttribute.addStringToMap(ORDERING,UNORDERED);
+                                            if (attribute.containsKeyMapStringListString(ORDERING)) {
+                                                if (attribute.getFirstMapStringListString(ORDERING).equals(ORDERED)) {
+                                                    reverseAttribute.addStringToMap(ORDERING, UNORDERED);
+                                                } else if (attribute.getFirstMapStringListString(ORDERING).equals(UNORDERED)) {
+                                                    reverseAttribute.addStringToMap(ORDERING, ORDERED);
                                                 }
-                                                else if(attribute.getFirstMapStringListString(ORDERING).equals(UNORDERED))
-                                                {
-                                                    reverseAttribute.addStringToMap(ORDERING,ORDERED);
-                                                }
                                             }
                                             //test
-                                            reverseObject.addYamlObjectToMap(ATTRIBUTE,reverseAttribute);
+                                            reverseObject.addYamlObjectToMap(ATTRIBUTE, reverseAttribute);
 
-                                            attribute.addStringToMap(NAVIGABLE,String.valueOf(true));
+                                            attribute.addStringToMap(NAVIGABLE, String.valueOf(true));
                                         }
                                     }
                                 }
-                            }
-                            else//simple attribut
+                            } else//simple attribut
                             {
                                 ;//ou gerer par valeurs par defaut ?
                                 //associationType="composite"//default eugene
@@ -1147,31 +923,25 @@
                         }
                     }
                 }
-                if(labelisable.containsKeyYamlMapStringListYamlObject(PARTICIPANT))
-                {
+                if (labelisable.containsKeyYamlMapStringListYamlObject(PARTICIPANT)) {
                     log("0");
-                    for(YamlObject participant : labelisable.getMapStringListYamlObject(PARTICIPANT))
-                    {
-                        if(participant.containsKeyMapStringListString(NAME))
-                        {
+                    for (YamlObject participant : labelisable.getMapStringListYamlObject(PARTICIPANT)) {
+                        if (participant.containsKeyMapStringListString(NAME)) {
                             log("1");
                             String name = participant.getFirstMapStringListString(NAME);
-                            if(importsI.contains(name))//refClassifier
+                            if (importsI.contains(name))//refClassifier
                             {
                                 log("2");
-                                if(participant.containsKeyMapStringListString(LABEL))
-                                {
+                                if (participant.containsKeyMapStringListString(LABEL)) {
                                     log("3");
                                     String label = participant.getFirstMapStringListString(LABEL);
-                                    YamlObject reverseAttribute = getReverseAttribute(modelYAMLO,YamlUtil.afterChar(name,'.'),label);
-                                    if(reverseAttribute != null)
-                                    {
+                                    YamlObject reverseAttribute = getReverseAttribute(modelYAMLO, YamlUtil.afterChar(name, '.'), label);
+                                    if (reverseAttribute != null) {
                                         log("4");
-                                        if(labelisable.containsKeyMapStringListString(NAME))
-                                        {
+                                        if (labelisable.containsKeyMapStringListString(NAME)) {
                                             log("5");
                                             //tester package
-                                            reverseAttribute.addStringToMap(ASSOCIATION_CLASS_NAME,modelYAMLO.getFirstMapStringListString(PACKAGE)+"."+labelisable.getFirstMapStringListString(NAME));
+                                            reverseAttribute.addStringToMap(ASSOCIATION_CLASS_NAME, modelYAMLO.getFirstMapStringListString(PACKAGE) + "." + labelisable.getFirstMapStringListString(NAME));
                                         }
                                     }
                                 }
@@ -1183,26 +953,17 @@
         }
     }
 
-    public static YamlObject getReverseAttribute(YamlObject model, String type, String label)
-    {
-        for(List<YamlObject> objectsYAMLO : model.getMapStringListYamlObject().values())
-        {
-            for(YamlObject objectYAMLO : objectsYAMLO)
-            {
-                if(objectYAMLO.containsKeyMapStringListString(NAME))
-                {
+    public static YamlObject getReverseAttribute(YamlObject model, String type, String label) {
+        for (List<YamlObject> objectsYAMLO : model.getMapStringListYamlObject().values()) {
+            for (YamlObject objectYAMLO : objectsYAMLO) {
+                if (objectYAMLO.containsKeyMapStringListString(NAME)) {
                     String name = objectYAMLO.getFirstMapStringListString(NAME);
-                    if(name.equals(type))
-                    {
-                        if(objectYAMLO.containsKeyYamlMapStringListYamlObject(ATTRIBUTE))
-                        {
-                            for(YamlObject attributeYAMLO : objectYAMLO.getMapStringListYamlObject(ATTRIBUTE))
-                            {
-                                if(attributeYAMLO.containsKeyMapStringListString(LABEL))
-                                {
+                    if (name.equals(type)) {
+                        if (objectYAMLO.containsKeyYamlMapStringListYamlObject(ATTRIBUTE)) {
+                            for (YamlObject attributeYAMLO : objectYAMLO.getMapStringListYamlObject(ATTRIBUTE)) {
+                                if (attributeYAMLO.containsKeyMapStringListString(LABEL)) {
                                     String reverseLabel = attributeYAMLO.getFirstMapStringListString(LABEL);
-                                    if(reverseLabel.equals(label))
-                                    {
+                                    if (reverseLabel.equals(label)) {
                                         return attributeYAMLO;
                                     }
                                 }
@@ -1215,17 +976,12 @@
         return null;
     }
 
-    public static YamlObject getReverseObject(YamlObject model, String type)
-    {
-        for(List<YamlObject> objectsYAMLO : model.getMapStringListYamlObject().values())
-        {
-            for(YamlObject objectYAMLO : objectsYAMLO)
-            {
-                if(objectYAMLO.containsKeyMapStringListString(NAME))
-                {
+    public static YamlObject getReverseObject(YamlObject model, String type) {
+        for (List<YamlObject> objectsYAMLO : model.getMapStringListYamlObject().values()) {
+            for (YamlObject objectYAMLO : objectsYAMLO) {
+                if (objectYAMLO.containsKeyMapStringListString(NAME)) {
                     String name = objectYAMLO.getFirstMapStringListString(NAME);
-                    if(name.equals(type))
-                    {
+                    if (name.equals(type)) {
                         return objectYAMLO;
                     }
                 }

Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/ParserPureYaml.java
===================================================================
--- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/ParserPureYaml.java	2013-06-11 10:11:42 UTC (rev 1271)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/ParserPureYaml.java	2013-06-11 12:16:35 UTC (rev 1272)
@@ -10,27 +10,18 @@
  */
 public class ParserPureYaml {
 
-    public static void parseModel(Object modelYAML, YamlObject modelYAMLO)
-    {
-        if(modelYAML instanceof List)
-        {
-            for(Object tmp1 : (List) modelYAML)
-            {
+    public static void parseModel(Object modelYAML, YamlObject modelYAMLO) {
+        if (modelYAML instanceof List) {
+            for (Object tmp1 : (List) modelYAML) {
                 parseModel(tmp1, modelYAMLO);
             }
-        }
-        else if(modelYAML instanceof Map)
-        {
-            for(Object tmp1 : ((Map) modelYAML).entrySet())
-            {
-                if(((Map.Entry) tmp1).getValue() instanceof List || ((Map.Entry) tmp1).getValue() instanceof Map)
-                {
+        } else if (modelYAML instanceof Map) {
+            for (Object tmp1 : ((Map) modelYAML).entrySet()) {
+                if (((Map.Entry) tmp1).getValue() instanceof List || ((Map.Entry) tmp1).getValue() instanceof Map) {
                     YamlObject tmp2 = new YamlObject();
-                    parseModel(((Map.Entry) tmp1).getValue(),tmp2);
+                    parseModel(((Map.Entry) tmp1).getValue(), tmp2);
                     modelYAMLO.addYamlObjectToMap(String.valueOf(((Map.Entry) tmp1).getKey()).toLowerCase(), tmp2);
-                }
-                else
-                {
+                } else {
                     modelYAMLO.addStringToMap(String.valueOf(((Map.Entry) tmp1).getKey()).toLowerCase(), String.valueOf(((Map.Entry) tmp1).getValue()));
                 }
             }

Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/ParserUserFriendly.java
===================================================================
--- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/ParserUserFriendly.java	2013-06-11 10:11:42 UTC (rev 1271)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/ParserUserFriendly.java	2013-06-11 12:16:35 UTC (rev 1272)
@@ -11,15 +11,14 @@
  * Time: 16:48
  */
 public class ParserUserFriendly extends KeyWords {
-    protected Map<String,String> imports;
-    protected Map<String,String> importsI;
-    protected Map<String,String> importsE;
+    protected Map<String, String> imports;
+    protected Map<String, String> importsI;
+    protected Map<String, String> importsE;
     protected String packageM;
     protected Object modelYAML;
     protected YamlObject modelYAMLO;
 
-    public ParserUserFriendly(Object modelYAML, YamlObject modelYAMLO)
-    {
+    public ParserUserFriendly(Object modelYAML, YamlObject modelYAMLO) {
         this.imports = new LinkedHashMap<String, String>();
         this.importsI = new LinkedHashMap<String, String>();
         this.importsE = new LinkedHashMap<String, String>();
@@ -28,120 +27,91 @@
         this.modelYAMLO = modelYAMLO;
     }
 
-    public void parseModel()
-    {
-        if(modelYAML instanceof Map)
-        {
-            for(Object entry : ((Map) modelYAML).entrySet())
-            {
-                if(entry instanceof Map.Entry)
-                {
+    public void parseModel() {
+        if (modelYAML instanceof Map) {
+            for (Object entry : ((Map) modelYAML).entrySet()) {
+                if (entry instanceof Map.Entry) {
                     String key = String.valueOf(((Map.Entry) entry).getKey());
                     Object value = ((Map.Entry) entry).getValue();
-                    if(key.equals(PACKAGE))
-                    {
-                        modelYAMLO.addStringToMap(PACKAGE,String.valueOf(value));
-                        packageM =  String.valueOf(value);
+                    if (key.equals(PACKAGE)) {
+                        modelYAMLO.addStringToMap(PACKAGE, String.valueOf(value));
+                        packageM = String.valueOf(value);
                     }
 
-                    if(key.equals(NAME))
-                    {
-                        modelYAMLO.addStringToMap(NAME,String.valueOf(value));
+                    if (key.equals(NAME)) {
+                        modelYAMLO.addStringToMap(NAME, String.valueOf(value));
                     }
 
-                    if(key.equals(VERSION))
-                    {
-                        modelYAMLO.addStringToMap(VERSION,String.valueOf(value));
+                    if (key.equals(VERSION)) {
+                        modelYAMLO.addStringToMap(VERSION, String.valueOf(value));
                     }
 
-                    if(key.equals(IMPORTS))
-                    {
-                        if(value instanceof List)
-                        {
-                            for(Object imp : (List) value)
-                            {
+                    if (key.equals(IMPORTS)) {
+                        if (value instanceof List) {
+                            for (Object imp : (List) value) {
                                 //modelYAMLO.addStringToMap(IMPORTS,String.valueOf(imp));
-                                importsE.put(YamlUtil.afterChar(String.valueOf(imp),'.'),String.valueOf(imp));
+                                importsE.put(YamlUtil.afterChar(String.valueOf(imp), '.'), String.valueOf(imp));
                             }
                         }
                     }
 
-                    List<String> tmp = YamlUtil.charParseIgnore(key,' ','<','>');
-                    if(tmp.contains(CLASS))
-                    {   YamlObject classYAMLO = new YamlObject();
-                        parseClass(key,value,classYAMLO);
-                        modelYAMLO.addYamlObjectToMap(CLASS,classYAMLO);
-                    }
-                    else if(tmp.contains(INTERFACE))
-                    {
+                    List<String> tmp = YamlUtil.charParseIgnore(key, ' ', '<', '>');
+                    if (tmp.contains(CLASS)) {
+                        YamlObject classYAMLO = new YamlObject();
+                        parseClass(key, value, classYAMLO);
+                        modelYAMLO.addYamlObjectToMap(CLASS, classYAMLO);
+                    } else if (tmp.contains(INTERFACE)) {
                         YamlObject interfaceYAMLO = new YamlObject();
-                        parseInterface(key,value,interfaceYAMLO);
-                        modelYAMLO.addYamlObjectToMap(INTERFACE,interfaceYAMLO);
-                    }
-                    else if(tmp.contains(ASSOCIATION_CLASS))
-                    {
+                        parseInterface(key, value, interfaceYAMLO);
+                        modelYAMLO.addYamlObjectToMap(INTERFACE, interfaceYAMLO);
+                    } else if (tmp.contains(ASSOCIATION_CLASS)) {
                         YamlObject associationClassYAMLO = new YamlObject();
-                        parseAssociationClass(key,value,associationClassYAMLO);
-                        modelYAMLO.addYamlObjectToMap(ASSOCIATION_CLASS,associationClassYAMLO);
-                    }
-                    else if(tmp.contains(ENUMERATION))
-                    {
+                        parseAssociationClass(key, value, associationClassYAMLO);
+                        modelYAMLO.addYamlObjectToMap(ASSOCIATION_CLASS, associationClassYAMLO);
+                    } else if (tmp.contains(ENUMERATION)) {
                         YamlObject enumerationYAMLO = new YamlObject();
-                        parseEnumeration(key,value,enumerationYAMLO);
-                        modelYAMLO.addYamlObjectToMap(ENUMERATION,enumerationYAMLO);
+                        parseEnumeration(key, value, enumerationYAMLO);
+                        modelYAMLO.addYamlObjectToMap(ENUMERATION, enumerationYAMLO);
                     }
                 }
             }
         }
     }
 
-    public void parseClass(String key, Object value, YamlObject classYAMLO)
-    {
-        List<String> classPARSE = YamlUtil.charParseIgnore(key,' ','<','>');
-        if(classPARSE.contains(CLASS))
-        {
+    public void parseClass(String key, Object value, YamlObject classYAMLO) {
+        List<String> classPARSE = YamlUtil.charParseIgnore(key, ' ', '<', '>');
+        if (classPARSE.contains(CLASS)) {
             classPARSE.remove(classPARSE.indexOf(CLASS));
         }
-        if(classPARSE.contains(ABSTRACT))
-        {
-            classYAMLO.addStringToMap(ABSTRACT,String.valueOf(true));
+        if (classPARSE.contains(ABSTRACT)) {
+            classYAMLO.addStringToMap(ABSTRACT, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(ABSTRACT));
         }
-        if(classPARSE.contains(STATIC))
-        {
-            classYAMLO.addStringToMap(STATIC,String.valueOf(true));
+        if (classPARSE.contains(STATIC)) {
+            classYAMLO.addStringToMap(STATIC, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(STATIC));
         }
-        if(classPARSE.contains(EXTERN))
-        {
-            classYAMLO.addStringToMap(EXTERN,String.valueOf(true));
+        if (classPARSE.contains(EXTERN)) {
+            classYAMLO.addStringToMap(EXTERN, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(EXTERN));
         }
-        if(classPARSE.contains(INNER))
-        {
-            classYAMLO.addStringToMap(INNER,String.valueOf(true));
+        if (classPARSE.contains(INNER)) {
+            classYAMLO.addStringToMap(INNER, String.valueOf(true));
             classPARSE.remove(classPARSE.indexOf(INNER));
         }
-        if(classPARSE.contains(PUBLIC))
-        {
-            classYAMLO.addStringToMap(VISIBILITY,PUBLIC);
+        if (classPARSE.contains(PUBLIC)) {
+            classYAMLO.addStringToMap(VISIBILITY, PUBLIC);
             classPARSE.remove(classPARSE.indexOf(PUBLIC));
-        }
-        else if(classPARSE.contains(PRIVATE))
-        {
-            classYAMLO.addStringToMap(VISIBILITY,PRIVATE);
+        } else if (classPARSE.contains(PRIVATE)) {
+            classYAMLO.addStringToMap(VISIBILITY, PRIVATE);
             classPARSE.remove(classPARSE.indexOf(PRIVATE));
-        }
-        else if(classPARSE.contains(PROTECTED))
-        {
-            classYAMLO.addStringToMap(VISIBILITY,PROTECTED);
+        } else if (classPARSE.contains(PROTECTED)) {
+            classYAMLO.addStringToMap(VISIBILITY, PROTECTED);
             classPARSE.remove(classPARSE.indexOf(PROTECTED));
         }
 
-        for(String str1 : classPARSE)
-        {
-            if(str1.contains("<<") && str1.contains(">>"))
-            {
+        for (String str1 : classPARSE) {
+            if (str1.contains("<<") && str1.contains(">>")) {
                 List<Character> targets = new LinkedList<Character>();
                 targets.add('<');
                 targets.add('>');
@@ -150,62 +120,45 @@
                 targets.add(' ');
                 targets.add(',');
                 List<String> list = YamlUtil.multiCharParse(str2, targets);
-                for(String str3 : list)
-                {
+                for (String str3 : list) {
                     classYAMLO.addStringToMap(STEREOTYPES, str3);
                 }
             }
         }
 
-        if(classPARSE.size() > 0)
-        {
+        if (classPARSE.size() > 0) {
             String name = classPARSE.get(0);
             classYAMLO.addStringToMap(NAME, name);
-            importsI.put(name,packageM+"."+name);
+            importsI.put(name, packageM + "." + name);
         }
 
-        if(value instanceof Map)
-        {
-            for(Object entry : ((Map) value).entrySet())
-            {
-                if(entry instanceof Map.Entry)
-                {
+        if (value instanceof Map) {
+            for (Object entry : ((Map) value).entrySet()) {
+                if (entry instanceof Map.Entry) {
                     String keyP = String.valueOf(((Map.Entry) entry).getKey());
                     Object valueP = ((Map.Entry) entry).getValue();
 
-                    if(keyP.equals(SUPER_CLASSES))
-                    {
-                        if(valueP instanceof List)
-                        {
-                            for(Object superClass : (List) valueP)
-                            {
-                                classYAMLO.addStringToMap(SUPER_CLASSES,String.valueOf(superClass));
+                    if (keyP.equals(SUPER_CLASSES)) {
+                        if (valueP instanceof List) {
+                            for (Object superClass : (List) valueP) {
+                                classYAMLO.addStringToMap(SUPER_CLASSES, String.valueOf(superClass));
                             }
                         }
-                    }
-                    else if(keyP.equals(SUPER_INTERFACES))
-                    {
-                        if(valueP instanceof List)
-                        {
-                            for(Object superInterface : (List) valueP)
-                            {
-                                classYAMLO.addStringToMap(SUPER_INTERFACES,String.valueOf(superInterface));
+                    } else if (keyP.equals(SUPER_INTERFACES)) {
+                        if (valueP instanceof List) {
+                            for (Object superInterface : (List) valueP) {
+                                classYAMLO.addStringToMap(SUPER_INTERFACES, String.valueOf(superInterface));
                             }
                         }
-                    }
-                    else
-                    {
-                        if(keyP.contains("(") && keyP.contains(")"))
-                        {
+                    } else {
+                        if (keyP.contains("(") && keyP.contains(")")) {
                             YamlObject operationYAMLO = new YamlObject();
-                            parseOperation(keyP,valueP,operationYAMLO);
-                            classYAMLO.addYamlObjectToMap(OPERATION,operationYAMLO);
-                        }
-                        else
-                        {
+                            parseOperation(keyP, valueP, operationYAMLO);
+                            classYAMLO.addYamlObjectToMap(OPERATION, operationYAMLO);
+                        } else {
                             YamlObject attributeYAMLO = new YamlObject();
-                            parseAttribute(keyP,valueP,attributeYAMLO);
-                            classYAMLO.addYamlObjectToMap(ATTRIBUTE,attributeYAMLO);
+                            parseAttribute(keyP, valueP, attributeYAMLO);
+                            classYAMLO.addYamlObjectToMap(ATTRIBUTE, attributeYAMLO);
                         }
                     }
                 }
@@ -214,53 +167,40 @@
     }
 
     //TODO: factoriser le code (classifier)
-    public void parseInterface(String key, Object value, YamlObject interfaceYAMLO)
-    {
-        List<String> interfacePARSE = YamlUtil.charParseIgnore(key,' ','<','>');
-        if(interfacePARSE.contains(INTERFACE))
-        {
+    public void parseInterface(String key, Object value, YamlObject interfaceYAMLO) {
+        List<String> interfacePARSE = YamlUtil.charParseIgnore(key, ' ', '<', '>');
+        if (interfacePARSE.contains(INTERFACE)) {
             interfacePARSE.remove(interfacePARSE.indexOf(INTERFACE));
         }
-        if(interfacePARSE.contains(ABSTRACT))
-        {
+        if (interfacePARSE.contains(ABSTRACT)) {
             interfaceYAMLO.addStringToMap(ABSTRACT, String.valueOf(true));
             interfacePARSE.remove(interfacePARSE.indexOf(ABSTRACT));
         }
-        if(interfacePARSE.contains(STATIC))
-        {
+        if (interfacePARSE.contains(STATIC)) {
             interfaceYAMLO.addStringToMap(STATIC, String.valueOf(true));
             interfacePARSE.remove(interfacePARSE.indexOf(STATIC));
         }
-        if(interfacePARSE.contains(EXTERN))
-        {
+        if (interfacePARSE.contains(EXTERN)) {
             interfaceYAMLO.addStringToMap(EXTERN, String.valueOf(true));
             interfacePARSE.remove(interfacePARSE.indexOf(EXTERN));
         }
-        if(interfacePARSE.contains(INNER))
-        {
+        if (interfacePARSE.contains(INNER)) {
             interfaceYAMLO.addStringToMap(INNER, String.valueOf(true));
             interfacePARSE.remove(interfacePARSE.indexOf(INNER));
         }
-        if(interfacePARSE.contains(PUBLIC))
-        {
+        if (interfacePARSE.contains(PUBLIC)) {
             interfaceYAMLO.addStringToMap(VISIBILITY, PUBLIC);
             interfacePARSE.remove(interfacePARSE.indexOf(PUBLIC));
-        }
-        else if(interfacePARSE.contains(PRIVATE))
-        {
+        } else if (interfacePARSE.contains(PRIVATE)) {
             interfaceYAMLO.addStringToMap(VISIBILITY, PRIVATE);
             interfacePARSE.remove(interfacePARSE.indexOf(PRIVATE));
-        }
-        else if(interfacePARSE.contains(PROTECTED))
-        {
+        } else if (interfacePARSE.contains(PROTECTED)) {
             interfaceYAMLO.addStringToMap(VISIBILITY, PROTECTED);
             interfacePARSE.remove(interfacePARSE.indexOf(PROTECTED));
         }
 
-        for(String str1 : interfacePARSE)
-        {
-            if(str1.contains("<<") && str1.contains(">>"))
-            {
+        for (String str1 : interfacePARSE) {
+            if (str1.contains("<<") && str1.contains(">>")) {
                 List<Character> targets = new LinkedList<Character>();
                 targets.add('<');
                 targets.add('>');
@@ -269,61 +209,44 @@
                 targets.add(' ');
                 targets.add(',');
                 List<String> list = YamlUtil.multiCharParse(str2, targets);
-                for(String str3 : list)
-                {
+                for (String str3 : list) {
                     interfaceYAMLO.addStringToMap(STEREOTYPES, str3);
                 }
             }
         }
 
-        if(interfacePARSE.size() > 0)
-        {
+        if (interfacePARSE.size() > 0) {
             String name = interfacePARSE.get(0);
             interfaceYAMLO.addStringToMap(NAME, name);
-            importsI.put(name,packageM+"."+name);
+            importsI.put(name, packageM + "." + name);
         }
 
-        if(value instanceof Map)
-        {
-            for(Object entry : ((Map) value).entrySet())
-            {
-                if(entry instanceof Map.Entry)
-                {
+        if (value instanceof Map) {
+            for (Object entry : ((Map) value).entrySet()) {
+                if (entry instanceof Map.Entry) {
                     String keyP = String.valueOf(((Map.Entry) entry).getKey());
                     Object valueP = ((Map.Entry) entry).getValue();
 
-                    if(keyP.equals(SUPER_CLASSES))
-                    {
-                        if(valueP instanceof List)
-                        {
-                            for(Object superClass : (List) valueP)
-                            {
+                    if (keyP.equals(SUPER_CLASSES)) {
+                        if (valueP instanceof List) {
+                            for (Object superClass : (List) valueP) {
                                 interfaceYAMLO.addStringToMap(SUPER_CLASSES, String.valueOf(superClass));
                             }
                         }
-                    }
-                    else if(keyP.equals(SUPER_INTERFACES))
-                    {
-                        if(valueP instanceof List)
-                        {
-                            for(Object superInterface : (List) valueP)
-                            {
+                    } else if (keyP.equals(SUPER_INTERFACES)) {
+                        if (valueP instanceof List) {
+                            for (Object superInterface : (List) valueP) {
                                 interfaceYAMLO.addStringToMap(SUPER_INTERFACES, String.valueOf(superInterface));
                             }
                         }
-                    }
-                    else
-                    {
-                        if(keyP.contains("(") && keyP.contains(")"))
-                        {
+                    } else {
+                        if (keyP.contains("(") && keyP.contains(")")) {
                             YamlObject operationYAMLO = new YamlObject();
-                            parseOperation(keyP,valueP,operationYAMLO);
+                            parseOperation(keyP, valueP, operationYAMLO);
                             interfaceYAMLO.addYamlObjectToMap(OPERATION, operationYAMLO);
-                        }
-                        else
-                        {
+                        } else {
                             YamlObject attributeYAMLO = new YamlObject();
-                            parseAttribute(keyP,valueP,attributeYAMLO);
+                            parseAttribute(keyP, valueP, attributeYAMLO);
                             interfaceYAMLO.addYamlObjectToMap(ATTRIBUTE, attributeYAMLO);
                         }
                     }
@@ -332,53 +255,40 @@
         }
     }
 
-    public void parseAssociationClass(String key, Object value, YamlObject associationClassYAMLO)
-    {
-        List<String> associationClassPARSE = YamlUtil.charParseIgnore(key,' ','<','>');
-        if(associationClassPARSE.contains(ASSOCIATION_CLASS))
-        {
+    public void parseAssociationClass(String key, Object value, YamlObject associationClassYAMLO) {
+        List<String> associationClassPARSE = YamlUtil.charParseIgnore(key, ' ', '<', '>');
+        if (associationClassPARSE.contains(ASSOCIATION_CLASS)) {
             associationClassPARSE.remove(associationClassPARSE.indexOf(ASSOCIATION_CLASS));
         }
-        if(associationClassPARSE.contains(ABSTRACT))
-        {
+        if (associationClassPARSE.contains(ABSTRACT)) {
             associationClassYAMLO.addStringToMap(ABSTRACT, String.valueOf(true));
             associationClassPARSE.remove(associationClassPARSE.indexOf(ABSTRACT));
         }
-        if(associationClassPARSE.contains(STATIC))
-        {
+        if (associationClassPARSE.contains(STATIC)) {
             associationClassYAMLO.addStringToMap(STATIC, String.valueOf(true));
             associationClassPARSE.remove(associationClassPARSE.indexOf(STATIC));
         }
-        if(associationClassPARSE.contains(EXTERN))
-        {
+        if (associationClassPARSE.contains(EXTERN)) {
             associationClassYAMLO.addStringToMap(EXTERN, String.valueOf(true));
             associationClassPARSE.remove(associationClassPARSE.indexOf(EXTERN));
         }
-        if(associationClassPARSE.contains(INNER))
-        {
+        if (associationClassPARSE.contains(INNER)) {
             associationClassYAMLO.addStringToMap(INNER, String.valueOf(true));
             associationClassPARSE.remove(associationClassPARSE.indexOf(INNER));
         }
-        if(associationClassPARSE.contains(PUBLIC))
-        {
+        if (associationClassPARSE.contains(PUBLIC)) {
             associationClassYAMLO.addStringToMap(VISIBILITY, PUBLIC);
             associationClassPARSE.remove(associationClassPARSE.indexOf(PUBLIC));
-        }
-        else if(associationClassPARSE.contains(PRIVATE))
-        {
+        } else if (associationClassPARSE.contains(PRIVATE)) {
             associationClassYAMLO.addStringToMap(VISIBILITY, PRIVATE);
             associationClassPARSE.remove(associationClassPARSE.indexOf(PRIVATE));
-        }
-        else if(associationClassPARSE.contains(PROTECTED))
-        {
+        } else if (associationClassPARSE.contains(PROTECTED)) {
             associationClassYAMLO.addStringToMap(VISIBILITY, PROTECTED);
             associationClassPARSE.remove(associationClassPARSE.indexOf(PROTECTED));
         }
 
-        for(String str1 : associationClassPARSE)
-        {
-            if(str1.contains("<<") && str1.contains(">>"))
-            {
+        for (String str1 : associationClassPARSE) {
+            if (str1.contains("<<") && str1.contains(">>")) {
                 List<Character> targets = new LinkedList<Character>();
                 targets.add('<');
                 targets.add('>');
@@ -387,96 +297,74 @@
                 targets.add(' ');
                 targets.add(',');
                 List<String> list = YamlUtil.multiCharParse(str2, targets);
-                for(String str3 : list)
-                {
+                for (String str3 : list) {
                     associationClassYAMLO.addStringToMap(STEREOTYPES, str3);
                 }
             }
         }
 
-        if(associationClassPARSE.size() > 0)
-        {
+        if (associationClassPARSE.size() > 0) {
             String name = associationClassPARSE.get(0);
             associationClassYAMLO.addStringToMap(NAME, name);
-            importsI.put(name,packageM+"."+name);
+            importsI.put(name, packageM + "." + name);
         }
 
-        if(value instanceof Map)
-        {
+        if (value instanceof Map) {
             //TODO: utiliser variable locales pour plus de clartee
-            if(((Map) value).containsKey(PARTICIPANT))
-            {
-                if(((Map) value).get(PARTICIPANT) instanceof Map)
-                {
-                    for(Object entry : ((Map) ((Map) value).get(PARTICIPANT)).entrySet())
-                    {
-                        if(entry instanceof Map.Entry)
-                        {
-                            List<String> participantPARSE = YamlUtil.charParse(String.valueOf(((Map.Entry) entry).getKey()),' ');
+            if (((Map) value).containsKey(PARTICIPANT)) {
+                if (((Map) value).get(PARTICIPANT) instanceof Map) {
+                    for (Object entry : ((Map) ((Map) value).get(PARTICIPANT)).entrySet()) {
+                        if (entry instanceof Map.Entry) {
+                            List<String> participantPARSE = YamlUtil.charParse(String.valueOf(((Map.Entry) entry).getKey()), ' ');
                             YamlObject participantYAMLO = new YamlObject();
-                            if(participantPARSE.contains("\""+YamlUtil.extract('"',String.valueOf(((Map.Entry) entry).getKey()))+"\""))
-                            {
-                                String label = YamlUtil.extract('"',String.valueOf(((Map.Entry) entry).getKey()));
+                            if (participantPARSE.contains("\"" + YamlUtil.extract('"', String.valueOf(((Map.Entry) entry).getKey())) + "\"")) {
+                                String label = YamlUtil.extract('"', String.valueOf(((Map.Entry) entry).getKey()));
 
-                                participantYAMLO.addStringToMap(LABEL,label);
+                                participantYAMLO.addStringToMap(LABEL, label);
 
-                                participantPARSE.remove("\""+YamlUtil.extract('"',String.valueOf(((Map.Entry) entry).getKey()))+"\"");
+                                participantPARSE.remove("\"" + YamlUtil.extract('"', String.valueOf(((Map.Entry) entry).getKey())) + "\"");
                             }
 
-                            if(participantPARSE.size() > 0)//ajout type
+                            if (participantPARSE.size() > 0)//ajout type
                             {
-                                participantYAMLO.addStringToMap(NAME,participantPARSE.get(0));
+                                participantYAMLO.addStringToMap(NAME, participantPARSE.get(0));
                             }
-                            if(participantPARSE.size() > 1)//ajout name
+                            if (participantPARSE.size() > 1)//ajout name
                             {
-                                participantYAMLO.addStringToMap(ATTRIBUTE,participantPARSE.get(1));
+                                participantYAMLO.addStringToMap(ATTRIBUTE, participantPARSE.get(1));
                             }
-                            associationClassYAMLO.addYamlObjectToMap(PARTICIPANT,participantYAMLO);
+                            associationClassYAMLO.addYamlObjectToMap(PARTICIPANT, participantYAMLO);
                         }
                     }
                 }
                 ((Map) value).remove(PARTICIPANT);
             }
 
-            for(Object entry : ((Map) value).entrySet())
-            {
-                if(entry instanceof Map.Entry)
-                {
+            for (Object entry : ((Map) value).entrySet()) {
+                if (entry instanceof Map.Entry) {
                     String keyP = String.valueOf(((Map.Entry) entry).getKey());
                     Object valueP = ((Map.Entry) entry).getValue();
 
-                    if(keyP.equals(SUPER_CLASSES))
-                    {
-                        if(valueP instanceof List)
-                        {
-                            for(Object superClass : (List) valueP)
-                            {
+                    if (keyP.equals(SUPER_CLASSES)) {
+                        if (valueP instanceof List) {
+                            for (Object superClass : (List) valueP) {
                                 associationClassYAMLO.addStringToMap(SUPER_CLASSES, String.valueOf(superClass));
                             }
                         }
-                    }
-                    else if(keyP.equals(SUPER_INTERFACES))
-                    {
-                        if(valueP instanceof List)
-                        {
-                            for(Object superInterface : (List) valueP)
-                            {
+                    } else if (keyP.equals(SUPER_INTERFACES)) {
+                        if (valueP instanceof List) {
+                            for (Object superInterface : (List) valueP) {
                                 associationClassYAMLO.addStringToMap(SUPER_INTERFACES, String.valueOf(superInterface));
                             }
                         }
-                    }
-                    else
-                    {
-                        if(keyP.contains("(") && keyP.contains(")"))
-                        {
+                    } else {
+                        if (keyP.contains("(") && keyP.contains(")")) {
                             YamlObject operationYAMLO = new YamlObject();
-                            parseOperation(keyP,valueP,operationYAMLO);
+                            parseOperation(keyP, valueP, operationYAMLO);
                             associationClassYAMLO.addYamlObjectToMap(OPERATION, operationYAMLO);
-                        }
-                        else
-                        {
+                        } else {
                             YamlObject attributeYAMLO = new YamlObject();
-                            parseAttribute(keyP,valueP,attributeYAMLO);
+                            parseAttribute(keyP, valueP, attributeYAMLO);
                             associationClassYAMLO.addYamlObjectToMap(ATTRIBUTE, attributeYAMLO);
                         }
                     }
@@ -485,23 +373,18 @@
         }
     }
 
-    public void parseEnumeration(String key, Object value, YamlObject enumerationYAMLO)
-    {
-        List<String> enumerationPARSE = YamlUtil.charParseIgnore(key,' ','<','>');
-        if(enumerationPARSE.contains(ENUMERATION))
-        {
+    public void parseEnumeration(String key, Object value, YamlObject enumerationYAMLO) {
+        List<String> enumerationPARSE = YamlUtil.charParseIgnore(key, ' ', '<', '>');
+        if (enumerationPARSE.contains(ENUMERATION)) {
             enumerationPARSE.remove(enumerationPARSE.indexOf(ENUMERATION));
         }
-        if(enumerationPARSE.contains(STATIC))
-        {
-            enumerationYAMLO.addStringToMap(STATIC,String.valueOf(true));
+        if (enumerationPARSE.contains(STATIC)) {
+            enumerationYAMLO.addStringToMap(STATIC, String.valueOf(true));
             enumerationPARSE.remove(enumerationPARSE.indexOf(STATIC));
         }
 
-        for(String str1 : enumerationPARSE)
-        {
-            if(str1.contains("<<") && str1.contains(">>"))
-            {
+        for (String str1 : enumerationPARSE) {
+            if (str1.contains("<<") && str1.contains(">>")) {
                 List<Character> targets = new LinkedList<Character>();
                 targets.add('<');
                 targets.add('>');
@@ -510,17 +393,15 @@
                 targets.add(' ');
                 targets.add(',');
                 List<String> list = YamlUtil.multiCharParse(str2, targets);
-                for(String str3 : list)
-                {
+                for (String str3 : list) {
                     enumerationYAMLO.addStringToMap(STEREOTYPES, str3);
                 }
             }
         }
-        if(enumerationPARSE.size() > 0)
-        {
+        if (enumerationPARSE.size() > 0) {
             String name = enumerationPARSE.get(0);
             enumerationYAMLO.addStringToMap(NAME, name);
-            importsI.put(name,packageM+"."+name);
+            importsI.put(name, packageM + "." + name);
         }
         //TODO: parser literals
     }
@@ -531,151 +412,116 @@
         ;
     }*/
 
-    public void parseAttribute(String key, Object value, YamlObject attributeYAMLO)
-    {
-        List<String> attributePARSE = YamlUtil.charParseIgnore(key,' ','<','>');
-        if(attributePARSE.contains(STATIC))
-        {
-            attributeYAMLO.addStringToMap(STATIC,String.valueOf(true));
+    public void parseAttribute(String key, Object value, YamlObject attributeYAMLO) {
+        List<String> attributePARSE = YamlUtil.charParseIgnore(key, ' ', '<', '>');
+        if (attributePARSE.contains(STATIC)) {
+            attributeYAMLO.addStringToMap(STATIC, String.valueOf(true));
             attributePARSE.remove(attributePARSE.indexOf(STATIC));
         }
-        if(attributePARSE.contains(FINAL))
-        {
-            attributeYAMLO.addStringToMap(FINAL,String.valueOf(true));
+        if (attributePARSE.contains(FINAL)) {
+            attributeYAMLO.addStringToMap(FINAL, String.valueOf(true));
             attributePARSE.remove(attributePARSE.indexOf(FINAL));
         }
-        if(attributePARSE.contains(UNIQUE))
-        {
-            attributeYAMLO.addStringToMap(UNIQUE,String.valueOf(true));
+        if (attributePARSE.contains(UNIQUE)) {
+            attributeYAMLO.addStringToMap(UNIQUE, String.valueOf(true));
             attributePARSE.remove(attributePARSE.indexOf(UNIQUE));
         }
-        if(attributePARSE.contains(NAVIGABLE))
-        {
-            attributeYAMLO.addStringToMap(NAVIGABLE,String.valueOf(true));
+        if (attributePARSE.contains(NAVIGABLE)) {
+            attributeYAMLO.addStringToMap(NAVIGABLE, String.valueOf(true));
             attributePARSE.remove(attributePARSE.indexOf(NAVIGABLE));
         }
-        if(attributePARSE.contains(TRANSIENT))
-        {
-            attributeYAMLO.addStringToMap(TRANSIENT,String.valueOf(true));
+        if (attributePARSE.contains(TRANSIENT)) {
+            attributeYAMLO.addStringToMap(TRANSIENT, String.valueOf(true));
             attributePARSE.remove(attributePARSE.indexOf(TRANSIENT));
         }
-        if(attributePARSE.contains(PUBLIC))
-        {
-            attributeYAMLO.addStringToMap(VISIBILITY,PUBLIC);
+        if (attributePARSE.contains(PUBLIC)) {
+            attributeYAMLO.addStringToMap(VISIBILITY, PUBLIC);
             attributePARSE.remove(attributePARSE.indexOf(PUBLIC));
-        }
-        else if(attributePARSE.contains(PROTECTED))
-        {
-            attributeYAMLO.addStringToMap(VISIBILITY,PROTECTED);
+        } else if (attributePARSE.contains(PROTECTED)) {
+            attributeYAMLO.addStringToMap(VISIBILITY, PROTECTED);
             attributePARSE.remove(attributePARSE.indexOf(PUBLIC));
-        }
-        else if(attributePARSE.contains(PRIVATE))
-        {
-            attributeYAMLO.addStringToMap(VISIBILITY,PRIVATE);
+        } else if (attributePARSE.contains(PRIVATE)) {
+            attributeYAMLO.addStringToMap(VISIBILITY, PRIVATE);
             attributePARSE.remove(attributePARSE.indexOf(PUBLIC));
         }
 
-        if(attributePARSE.contains(ORDERED))
-        {
-            attributeYAMLO.addStringToMap(ORDERING,ORDERED);
+        if (attributePARSE.contains(ORDERED)) {
+            attributeYAMLO.addStringToMap(ORDERING, ORDERED);
             attributePARSE.remove(attributePARSE.indexOf(ORDERED));
-        }
-        else if(attributePARSE.contains(UNORDERED))
-        {
-            attributeYAMLO.addStringToMap(ORDERING,UNORDERED);
+        } else if (attributePARSE.contains(UNORDERED)) {
+            attributeYAMLO.addStringToMap(ORDERING, UNORDERED);
             attributePARSE.remove(attributePARSE.indexOf(UNORDERED));
         }
 
         //TODO: utiliser variables locales
-        if(attributePARSE.contains("\""+YamlUtil.extract('"',key)+"\""))
-        {
-            String label = YamlUtil.extract('"',key);
-            attributeYAMLO.addStringToMap(LABEL,label);
-            attributePARSE.remove("\""+YamlUtil.extract('"',key)+"\"");
+        if (attributePARSE.contains("\"" + YamlUtil.extract('"', key) + "\"")) {
+            String label = YamlUtil.extract('"', key);
+            attributeYAMLO.addStringToMap(LABEL, label);
+            attributePARSE.remove("\"" + YamlUtil.extract('"', key) + "\"");
         }
 
-        if(attributePARSE.contains("["+YamlUtil.extract('[',']',key)+"]"))
-        {
-            String multiplicity = YamlUtil.extract('[',']',key);
-            if(multiplicity.equals("*"))
-            {
-                attributeYAMLO.addStringToMap(MIN_MULTIPLICITY,"0");
-                attributeYAMLO.addStringToMap(MAX_MULTIPLICITY,"-1");
-            }
-            else if(multiplicity.contains(".."))
-            {
-                String min = YamlUtil.beforeChar(multiplicity,'.');
+        if (attributePARSE.contains("[" + YamlUtil.extract('[', ']', key) + "]")) {
+            String multiplicity = YamlUtil.extract('[', ']', key);
+            if (multiplicity.equals("*")) {
+                attributeYAMLO.addStringToMap(MIN_MULTIPLICITY, "0");
+                attributeYAMLO.addStringToMap(MAX_MULTIPLICITY, "-1");
+            } else if (multiplicity.contains("..")) {
+                String min = YamlUtil.beforeChar(multiplicity, '.');
                 String max = YamlUtil.afterChar(multiplicity, '.');
-                if(min.equals("*"))
-                {
+                if (min.equals("*")) {
                     min = "-1";
                 }
-                if(max.equals("*"))
-                {
+                if (max.equals("*")) {
                     max = "-1";
                 }
-                attributeYAMLO.addStringToMap(MIN_MULTIPLICITY,min);
-                attributeYAMLO.addStringToMap(MAX_MULTIPLICITY,max);
+                attributeYAMLO.addStringToMap(MIN_MULTIPLICITY, min);
+                attributeYAMLO.addStringToMap(MAX_MULTIPLICITY, max);
             }
-            attributePARSE.remove("["+YamlUtil.extract('[',']',key)+"]");
+            attributePARSE.remove("[" + YamlUtil.extract('[', ']', key) + "]");
         }
 
-        if(attributePARSE.size() > 0)
-        {
-            attributeYAMLO.addStringToMap(TYPE,attributePARSE.get(0));
+        if (attributePARSE.size() > 0) {
+            attributeYAMLO.addStringToMap(TYPE, attributePARSE.get(0));
         }
-        if(attributePARSE.size() > 1)
-        {
-            attributeYAMLO.addStringToMap(NAME,attributePARSE.get(1));
+        if (attributePARSE.size() > 1) {
+            attributeYAMLO.addStringToMap(NAME, attributePARSE.get(1));
         }
     }
 
-    public void parseOperation(String key, Object value, YamlObject operationYAMLO)
-    {
+    public void parseOperation(String key, Object value, YamlObject operationYAMLO) {
         List<Character> ignoreStart = new LinkedList<Character>();
         ignoreStart.add('(');
         ignoreStart.add('<');
         List<Character> ignoreEnd = new LinkedList<Character>();
         ignoreEnd.add(')');
         ignoreEnd.add('>');
-        List<String> operationPARSE = YamlUtil.charParseMultiIgnore(key,' ',ignoreStart,ignoreEnd);
+        List<String> operationPARSE = YamlUtil.charParseMultiIgnore(key, ' ', ignoreStart, ignoreEnd);
 
-        if(operationPARSE.contains(STATIC))
-        {
-            operationYAMLO.addStringToMap(STATIC,String.valueOf(true));
+        if (operationPARSE.contains(STATIC)) {
+            operationYAMLO.addStringToMap(STATIC, String.valueOf(true));
             operationPARSE.remove(operationPARSE.indexOf(STATIC));
         }
-        if(operationPARSE.contains(ABSTRACT))
-        {
-            operationYAMLO.addStringToMap(ABSTRACT,String.valueOf(true));
+        if (operationPARSE.contains(ABSTRACT)) {
+            operationYAMLO.addStringToMap(ABSTRACT, String.valueOf(true));
             operationPARSE.remove(operationPARSE.indexOf(ABSTRACT));
         }
-        if(operationPARSE.contains(PUBLIC))
-        {
-            operationYAMLO.addStringToMap(VISIBILITY,PUBLIC);
+        if (operationPARSE.contains(PUBLIC)) {
+            operationYAMLO.addStringToMap(VISIBILITY, PUBLIC);
             operationPARSE.remove(operationPARSE.indexOf(PUBLIC));
-        }
-        else if(operationPARSE.contains(PROTECTED))
-        {
-            operationYAMLO.addStringToMap(VISIBILITY,PROTECTED);
+        } else if (operationPARSE.contains(PROTECTED)) {
+            operationYAMLO.addStringToMap(VISIBILITY, PROTECTED);
             operationPARSE.remove(operationPARSE.indexOf(PROTECTED));
-        }
-        else if(operationPARSE.contains(PRIVATE))
-        {
-            operationYAMLO.addStringToMap(VISIBILITY,PRIVATE);
+        } else if (operationPARSE.contains(PRIVATE)) {
+            operationYAMLO.addStringToMap(VISIBILITY, PRIVATE);
             operationPARSE.remove(operationPARSE.indexOf(PRIVATE));
         }
 
-        for(String str1 : operationPARSE)
-        {
-            if(str1.contains("(") && str1.contains(")"))
-            {
-                operationYAMLO.addStringToMap(NAME,YamlUtil.beforeChar(str1,'('));
-                for(String str2 : YamlUtil.charParseIgnore(YamlUtil.extract('(', ')', str1), ',', '<', '>'))
-                {
-                    List<String> list = YamlUtil.charParse(str2,' ');
-                    if(list.size() == 2)
-                    {
+        for (String str1 : operationPARSE) {
+            if (str1.contains("(") && str1.contains(")")) {
+                operationYAMLO.addStringToMap(NAME, YamlUtil.beforeChar(str1, '('));
+                for (String str2 : YamlUtil.charParseIgnore(YamlUtil.extract('(', ')', str1), ',', '<', '>')) {
+                    List<String> list = YamlUtil.charParse(str2, ' ');
+                    if (list.size() == 2) {
                         YamlObject parameterYAMLO = new YamlObject();
                         parameterYAMLO.addStringToMap(TYPE, list.get(0));
                         parameterYAMLO.addStringToMap(NAME, list.get(1));
@@ -685,85 +531,61 @@
             }
         }
 
-        if(value != null)
-        {
+        if (value != null) {
             YamlObject returnParameterYAMLO = new YamlObject();
-            returnParameterYAMLO.addStringToMap(TYPE,String.valueOf(value));
-            operationYAMLO.addYamlObjectToMap(RETURN_PARAMETER,returnParameterYAMLO);
+            returnParameterYAMLO.addStringToMap(TYPE, String.valueOf(value));
+            operationYAMLO.addYamlObjectToMap(RETURN_PARAMETER, returnParameterYAMLO);
         }
     }
 
-    public void resolveImports()
-    {
+    public void resolveImports() {
         imports.putAll(importsE);
         imports.putAll(importsI);
-        for(Map.Entry<String,List<YamlObject>> entry : modelYAMLO.getMapStringListYamlObject().entrySet())
-        {
-            for(YamlObject importable : entry.getValue())
-            {
-                if(importable.containsKeyMapStringListString(SUPER_CLASSES))
-                {
-                    for(String value : importable.getMapStringListString(SUPER_CLASSES))
-                    {
-                        if(imports.containsKey(value))
-                        {
-                            importable.setMapStringListString(SUPER_CLASSES,value,imports.get(value));
+        for (Map.Entry<String, List<YamlObject>> entry : modelYAMLO.getMapStringListYamlObject().entrySet()) {
+            for (YamlObject importable : entry.getValue()) {
+                if (importable.containsKeyMapStringListString(SUPER_CLASSES)) {
+                    for (String value : importable.getMapStringListString(SUPER_CLASSES)) {
+                        if (imports.containsKey(value)) {
+                            importable.setMapStringListString(SUPER_CLASSES, value, imports.get(value));
                         }
                     }
                 }
-                if(importable.containsKeyMapStringListString(SUPER_INTERFACES))
-                {
-                    for(String value : importable.getMapStringListString(SUPER_INTERFACES))
-                    {
-                        if(imports.containsKey(value))
-                        {
-                            importable.setMapStringListString(SUPER_INTERFACES,value,imports.get(value));
+                if (importable.containsKeyMapStringListString(SUPER_INTERFACES)) {
+                    for (String value : importable.getMapStringListString(SUPER_INTERFACES)) {
+                        if (imports.containsKey(value)) {
+                            importable.setMapStringListString(SUPER_INTERFACES, value, imports.get(value));
                         }
                     }
                 }
-                if(importable.containsKeyYamlMapStringListYamlObject(ATTRIBUTE))
-                {
-                    for(YamlObject attributeYAMLO : importable.getMapStringListYamlObject(ATTRIBUTE))
-                    {
-                        if(attributeYAMLO.containsKeyMapStringListString(TYPE))
-                        {
-                                attributeYAMLO.setMapStringListString(TYPE,attributeYAMLO.getFirstMapStringListString(TYPE),resolveType(attributeYAMLO.getFirstMapStringListString(TYPE)));
+                if (importable.containsKeyYamlMapStringListYamlObject(ATTRIBUTE)) {
+                    for (YamlObject attributeYAMLO : importable.getMapStringListYamlObject(ATTRIBUTE)) {
+                        if (attributeYAMLO.containsKeyMapStringListString(TYPE)) {
+                            attributeYAMLO.setMapStringListString(TYPE, attributeYAMLO.getFirstMapStringListString(TYPE), resolveType(attributeYAMLO.getFirstMapStringListString(TYPE)));
                         }
                     }
                 }
-                if(importable.containsKeyYamlMapStringListYamlObject(OPERATION))
-                {
-                    for(YamlObject operationYAMLO : importable.getMapStringListYamlObject(OPERATION))
-                    {
-                        if(operationYAMLO.containsKeyYamlMapStringListYamlObject(PARAMETER))
-                        {
-                            for(YamlObject parameterYAMLO : operationYAMLO.getMapStringListYamlObject(PARAMETER))
-                            {
-                                if(parameterYAMLO.containsKeyMapStringListString(TYPE))
-                                {
-                                        parameterYAMLO.setMapStringListString(TYPE,parameterYAMLO.getFirstMapStringListString(TYPE),resolveType(parameterYAMLO.getFirstMapStringListString(TYPE)));
+                if (importable.containsKeyYamlMapStringListYamlObject(OPERATION)) {
+                    for (YamlObject operationYAMLO : importable.getMapStringListYamlObject(OPERATION)) {
+                        if (operationYAMLO.containsKeyYamlMapStringListYamlObject(PARAMETER)) {
+                            for (YamlObject parameterYAMLO : operationYAMLO.getMapStringListYamlObject(PARAMETER)) {
+                                if (parameterYAMLO.containsKeyMapStringListString(TYPE)) {
+                                    parameterYAMLO.setMapStringListString(TYPE, parameterYAMLO.getFirstMapStringListString(TYPE), resolveType(parameterYAMLO.getFirstMapStringListString(TYPE)));
                                 }
                             }
                         }
-                        if(operationYAMLO.containsKeyYamlMapStringListYamlObject(RETURN_PARAMETER))
-                        {
-                            for(YamlObject parameterYAMLO : operationYAMLO.getMapStringListYamlObject(RETURN_PARAMETER))
-                            {
-                                if(parameterYAMLO.containsKeyMapStringListString(TYPE))
-                                {
-                                        parameterYAMLO.setMapStringListString(TYPE,parameterYAMLO.getFirstMapStringListString(TYPE),resolveType(parameterYAMLO.getFirstMapStringListString(TYPE)));
+                        if (operationYAMLO.containsKeyYamlMapStringListYamlObject(RETURN_PARAMETER)) {
+                            for (YamlObject parameterYAMLO : operationYAMLO.getMapStringListYamlObject(RETURN_PARAMETER)) {
+                                if (parameterYAMLO.containsKeyMapStringListString(TYPE)) {
+                                    parameterYAMLO.setMapStringListString(TYPE, parameterYAMLO.getFirstMapStringListString(TYPE), resolveType(parameterYAMLO.getFirstMapStringListString(TYPE)));
                                 }
                             }
                         }
                     }
                 }
-                if(importable.containsKeyYamlMapStringListYamlObject(PARTICIPANT))
-                {
-                    for(YamlObject participantYAMLO : importable.getMapStringListYamlObject(PARTICIPANT))
-                    {
-                        if(participantYAMLO.containsKeyMapStringListString(NAME))
-                        {
-                            participantYAMLO.setMapStringListString(NAME,participantYAMLO.getFirstMapStringListString(NAME),resolveType(participantYAMLO.getFirstMapStringListString(NAME)));
+                if (importable.containsKeyYamlMapStringListYamlObject(PARTICIPANT)) {
+                    for (YamlObject participantYAMLO : importable.getMapStringListYamlObject(PARTICIPANT)) {
+                        if (participantYAMLO.containsKeyMapStringListString(NAME)) {
+                            participantYAMLO.setMapStringListString(NAME, participantYAMLO.getFirstMapStringListString(NAME), resolveType(participantYAMLO.getFirstMapStringListString(NAME)));
                         }
                     }
                 }
@@ -771,43 +593,29 @@
         }
     }
 
-    public String browseType(String type)
-    {
-        StringBuilder res =  new StringBuilder();
+    public String browseType(String type) {
+        StringBuilder res = new StringBuilder();
         boolean first = true;
-        for(String tmp : YamlUtil.charParseIgnore(type,',','<','>'))
-        {
-            if(first)
-            {
+        for (String tmp : YamlUtil.charParseIgnore(type, ',', '<', '>')) {
+            if (first) {
                 first = false;
-            }
-            else
-            {
+            } else {
                 res.append(",");
             }
-            if(tmp.contains("<") && tmp.contains(">"))
-            {
-                String ninja = YamlUtil.beforeChar(tmp,'<');
-                if(imports.containsKey(ninja))
-                {
+            if (tmp.contains("<") && tmp.contains(">")) {
+                String ninja = YamlUtil.beforeChar(tmp, '<');
+                if (imports.containsKey(ninja)) {
                     res.append(imports.get(ninja));
-                }
-                else
-                {
+                } else {
                     res.append(tmp);
                 }
                 res.append("<");
-                res.append(browseType(YamlUtil.extract('<','>',tmp)));
+                res.append(browseType(YamlUtil.extract('<', '>', tmp)));
                 res.append(">");
-            }
-            else
-            {
-                if(imports.containsKey(tmp))
-                {
+            } else {
+                if (imports.containsKey(tmp)) {
                     res.append(imports.get(tmp));
-                }
-                else
-                {
+                } else {
                     res.append(tmp);
                 }
             }
@@ -815,87 +623,63 @@
         return res.toString();
     }
 
-    public String resolveType(String type)
-    {
+    public String resolveType(String type) {
         List<Character> ignore = new LinkedList<Character>();
         ignore.add(' ');
-        String typePARSE = YamlUtil.removeMultiChar(type,ignore);
+        String typePARSE = YamlUtil.removeMultiChar(type, ignore);
         return browseType(typePARSE);
     }
 
-    public void resolveLabels()
-    {
-        for(List<YamlObject> objectYAMLO : modelYAMLO.getMapStringListYamlObject().values())
-        {
-            for(YamlObject labelisable : objectYAMLO)
-            {
-                if(labelisable.containsKeyYamlMapStringListYamlObject(ATTRIBUTE))
-                {
-                    for(YamlObject attribute : labelisable.getMapStringListYamlObject(ATTRIBUTE))
-                    {
-                        if(attribute.containsKeyMapStringListString(TYPE))
-                        {
+    public void resolveLabels() {
+        for (List<YamlObject> objectYAMLO : modelYAMLO.getMapStringListYamlObject().values()) {
+            for (YamlObject labelisable : objectYAMLO) {
+                if (labelisable.containsKeyYamlMapStringListYamlObject(ATTRIBUTE)) {
+                    for (YamlObject attribute : labelisable.getMapStringListYamlObject(ATTRIBUTE)) {
+                        if (attribute.containsKeyMapStringListString(TYPE)) {
                             String type = attribute.getFirstMapStringListString(TYPE);
-                            if(importsI.containsValue(type))
-                            {
-                                if(!attribute.containsKeyMapStringListString(NAVIGABLE))
-                                {
-                                    if(attribute.containsKeyMapStringListString(LABEL))
-                                    {
+                            if (importsI.containsValue(type)) {
+                                if (!attribute.containsKeyMapStringListString(NAVIGABLE)) {
+                                    if (attribute.containsKeyMapStringListString(LABEL)) {
                                         String label = attribute.getFirstMapStringListString(LABEL);
-                                        YamlObject reverseAttribute = getReverseAttribute(YamlUtil.afterChar(type,'.'),label);
-                                        if(reverseAttribute != null)
-                                        {
-                                            attribute.addStringToMap(NAVIGABLE,String.valueOf(true));
-                                            reverseAttribute.addStringToMap(NAVIGABLE,String.valueOf(true));
-                                            if(attribute.containsKeyMapStringListString(MAX_MULTIPLICITY))
-                                            {
-                                                reverseAttribute.addStringToMap(REVERSE_MAX_MULTIPLICITY,attribute.getFirstMapStringListString(MAX_MULTIPLICITY));
+                                        YamlObject reverseAttribute = getReverseAttribute(YamlUtil.afterChar(type, '.'), label);
+                                        if (reverseAttribute != null) {
+                                            attribute.addStringToMap(NAVIGABLE, String.valueOf(true));
+                                            reverseAttribute.addStringToMap(NAVIGABLE, String.valueOf(true));
+                                            if (attribute.containsKeyMapStringListString(MAX_MULTIPLICITY)) {
+                                                reverseAttribute.addStringToMap(REVERSE_MAX_MULTIPLICITY, attribute.getFirstMapStringListString(MAX_MULTIPLICITY));
                                             }
-                                            if(reverseAttribute.containsKeyMapStringListString(MAX_MULTIPLICITY))
-                                            {
-                                                attribute.addStringToMap(REVERSE_MAX_MULTIPLICITY,reverseAttribute.getFirstMapStringListString(MAX_MULTIPLICITY));
+                                            if (reverseAttribute.containsKeyMapStringListString(MAX_MULTIPLICITY)) {
+                                                attribute.addStringToMap(REVERSE_MAX_MULTIPLICITY, reverseAttribute.getFirstMapStringListString(MAX_MULTIPLICITY));
                                             }
-                                            if(attribute.containsKeyMapStringListString(NAME))
-                                            {
-                                                reverseAttribute.addStringToMap(REVERSE_ATTRIBUTE_NAME,attribute.getFirstMapStringListString(NAME));
+                                            if (attribute.containsKeyMapStringListString(NAME)) {
+                                                reverseAttribute.addStringToMap(REVERSE_ATTRIBUTE_NAME, attribute.getFirstMapStringListString(NAME));
                                             }
-                                            if(reverseAttribute.containsKeyMapStringListString(NAME))
-                                            {
-                                                attribute.addStringToMap(REVERSE_ATTRIBUTE_NAME,reverseAttribute.getFirstMapStringListString(NAME));
+                                            if (reverseAttribute.containsKeyMapStringListString(NAME)) {
+                                                attribute.addStringToMap(REVERSE_ATTRIBUTE_NAME, reverseAttribute.getFirstMapStringListString(NAME));
                                             }
                                         }
-                                    }
-                                    else
-                                    {
-                                        YamlObject reverseObject = getReverseObject(YamlUtil.afterChar(type,'.'));
-                                        if(reverseObject != null)
-                                        {
+                                    } else {
+                                        YamlObject reverseObject = getReverseObject(YamlUtil.afterChar(type, '.'));
+                                        if (reverseObject != null) {
                                             YamlObject reverseAttribute = new YamlObject();
-                                            reverseAttribute.addStringToMap(NAVIGABLE,String.valueOf(false));
-                                            reverseAttribute.addStringToMap(TYPE,imports.get(labelisable.getFirstMapStringListString(NAME)));
-                                            if(attribute.containsKeyMapStringListString(MAX_MULTIPLICITY))
-                                            {
-                                                reverseAttribute.addStringToMap(REVERSE_MAX_MULTIPLICITY,attribute.getFirstMapStringListString(MAX_MULTIPLICITY));
+                                            reverseAttribute.addStringToMap(NAVIGABLE, String.valueOf(false));
+                                            reverseAttribute.addStringToMap(TYPE, imports.get(labelisable.getFirstMapStringListString(NAME)));
+                                            if (attribute.containsKeyMapStringListString(MAX_MULTIPLICITY)) {
+                                                reverseAttribute.addStringToMap(REVERSE_MAX_MULTIPLICITY, attribute.getFirstMapStringListString(MAX_MULTIPLICITY));
                                             }
-                                            if(attribute.containsKeyMapStringListString(NAME))
-                                            {
-                                                reverseAttribute.addStringToMap(REVERSE_ATTRIBUTE_NAME,attribute.getFirstMapStringListString(NAME));
+                                            if (attribute.containsKeyMapStringListString(NAME)) {
+                                                reverseAttribute.addStringToMap(REVERSE_ATTRIBUTE_NAME, attribute.getFirstMapStringListString(NAME));
                                             }
-                                            if(attribute.containsKeyMapStringListString(ORDERING))
-                                            {
-                                                if(attribute.getFirstMapStringListString(ORDERING).equals(ORDERED))
-                                                {
-                                                    reverseAttribute.addStringToMap(ORDERING,UNORDERED);
+                                            if (attribute.containsKeyMapStringListString(ORDERING)) {
+                                                if (attribute.getFirstMapStringListString(ORDERING).equals(ORDERED)) {
+                                                    reverseAttribute.addStringToMap(ORDERING, UNORDERED);
+                                                } else if (attribute.getFirstMapStringListString(ORDERING).equals(UNORDERED)) {
+                                                    reverseAttribute.addStringToMap(ORDERING, ORDERED);
                                                 }
-                                                else if(attribute.getFirstMapStringListString(ORDERING).equals(UNORDERED))
-                                                {
-                                                    reverseAttribute.addStringToMap(ORDERING,ORDERED);
-                                                }
                                             }
-                                            reverseObject.addYamlObjectToMap(ATTRIBUTE,reverseAttribute);
+                                            reverseObject.addYamlObjectToMap(ATTRIBUTE, reverseAttribute);
 
-                                            attribute.addStringToMap(NAVIGABLE,String.valueOf(true));
+                                            attribute.addStringToMap(NAVIGABLE, String.valueOf(true));
                                         }
                                     }
                                 }
@@ -907,24 +691,18 @@
                         }
                     }
                 }
-                if(labelisable.containsKeyYamlMapStringListYamlObject(PARTICIPANT))
-                {
-                    for(YamlObject participant : labelisable.getMapStringListYamlObject(PARTICIPANT))
-                    {
-                        if(participant.containsKeyMapStringListString(NAME))
-                        {
+                if (labelisable.containsKeyYamlMapStringListYamlObject(PARTICIPANT)) {
+                    for (YamlObject participant : labelisable.getMapStringListYamlObject(PARTICIPANT)) {
+                        if (participant.containsKeyMapStringListString(NAME)) {
                             String name = participant.getFirstMapStringListString(NAME);
-                            if(importsI.containsValue(name))//refClassifier
+                            if (importsI.containsValue(name))//refClassifier
                             {
-                                if(participant.containsKeyMapStringListString(LABEL))
-                                {
+                                if (participant.containsKeyMapStringListString(LABEL)) {
                                     String label = participant.getFirstMapStringListString(LABEL);
-                                    YamlObject reverseAttribute = getReverseAttribute(YamlUtil.afterChar(name,'.'),label);
-                                    if(reverseAttribute != null)
-                                    {
-                                        if(labelisable.containsKeyMapStringListString(NAME))
-                                        {
-                                            reverseAttribute.addStringToMap(ASSOCIATION_CLASS_NAME,packageM+"."+labelisable.getFirstMapStringListString(NAME));
+                                    YamlObject reverseAttribute = getReverseAttribute(YamlUtil.afterChar(name, '.'), label);
+                                    if (reverseAttribute != null) {
+                                        if (labelisable.containsKeyMapStringListString(NAME)) {
+                                            reverseAttribute.addStringToMap(ASSOCIATION_CLASS_NAME, packageM + "." + labelisable.getFirstMapStringListString(NAME));
                                         }
                                     }
                                 }
@@ -936,26 +714,17 @@
         }
     }
 
-    public YamlObject getReverseAttribute(String type, String label)
-    {
-        for(List<YamlObject> objectsYAMLO : modelYAMLO.getMapStringListYamlObject().values())
-        {
-            for(YamlObject objectYAMLO : objectsYAMLO)
-            {
-                if(objectYAMLO.containsKeyMapStringListString(NAME))
-                {
+    public YamlObject getReverseAttribute(String type, String label) {
+        for (List<YamlObject> objectsYAMLO : modelYAMLO.getMapStringListYamlObject().values()) {
+            for (YamlObject objectYAMLO : objectsYAMLO) {
+                if (objectYAMLO.containsKeyMapStringListString(NAME)) {
                     String name = objectYAMLO.getFirstMapStringListString(NAME);
-                    if(name.equals(type))
-                    {
-                        if(objectYAMLO.containsKeyYamlMapStringListYamlObject(ATTRIBUTE))
-                        {
-                            for(YamlObject attributeYAMLO : objectYAMLO.getMapStringListYamlObject(ATTRIBUTE))
-                            {
-                                if(attributeYAMLO.containsKeyMapStringListString(LABEL))
-                                {
+                    if (name.equals(type)) {
+                        if (objectYAMLO.containsKeyYamlMapStringListYamlObject(ATTRIBUTE)) {
+                            for (YamlObject attributeYAMLO : objectYAMLO.getMapStringListYamlObject(ATTRIBUTE)) {
+                                if (attributeYAMLO.containsKeyMapStringListString(LABEL)) {
                                     String reverseLabel = attributeYAMLO.getFirstMapStringListString(LABEL);
-                                    if(reverseLabel.equals(label))
-                                    {
+                                    if (reverseLabel.equals(label)) {
                                         return attributeYAMLO;
                                     }
                                 }
@@ -968,17 +737,12 @@
         return null;
     }
 
-    public YamlObject getReverseObject(String type)
-    {
-        for(List<YamlObject> objectsYAMLO : modelYAMLO.getMapStringListYamlObject().values())
-        {
-            for(YamlObject objectYAMLO : objectsYAMLO)
-            {
-                if(objectYAMLO.containsKeyMapStringListString(NAME))
-                {
+    public YamlObject getReverseObject(String type) {
+        for (List<YamlObject> objectsYAMLO : modelYAMLO.getMapStringListYamlObject().values()) {
+            for (YamlObject objectYAMLO : objectsYAMLO) {
+                if (objectYAMLO.containsKeyMapStringListString(NAME)) {
                     String name = objectYAMLO.getFirstMapStringListString(NAME);
-                    if(name.equals(type))
-                    {
+                    if (name.equals(type)) {
                         return objectYAMLO;
                     }
                 }

Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxePureYaml.java
===================================================================
--- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxePureYaml.java	2013-06-11 10:11:42 UTC (rev 1271)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxePureYaml.java	2013-06-11 12:16:35 UTC (rev 1272)
@@ -7,8 +7,7 @@
  */
 public class SyntaxePureYaml {
 
-    public static void loadYamlObject(Object modelYAML, YamlObject modelYAMLO)
-    {
-        ParserPureYaml.parseModel(modelYAML,modelYAMLO);
+    public static void loadYamlObject(Object modelYAML, YamlObject modelYAMLO) {
+        ParserPureYaml.parseModel(modelYAML, modelYAMLO);
     }
 }

Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxeUserFriendly.java
===================================================================
--- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxeUserFriendly.java	2013-06-11 10:11:42 UTC (rev 1271)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxeUserFriendly.java	2013-06-11 12:16:35 UTC (rev 1272)
@@ -8,9 +8,8 @@
 //TODO: interface Syntaxe pour futures syntaxes
 public class SyntaxeUserFriendly {
 
-    public static void loadYamlObject(Object modelYAML, YamlObject modelYAMLO)
-    {
-        ParserUserFriendly parser = new ParserUserFriendly(modelYAML,modelYAMLO);
+    public static void loadYamlObject(Object modelYAML, YamlObject modelYAMLO) {
+        ParserUserFriendly parser = new ParserUserFriendly(modelYAML, modelYAMLO);
         parser.parseModel();
         parser.resolveImports();
         parser.resolveLabels();

Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadObjectModel.java
===================================================================
--- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadObjectModel.java	2013-06-11 10:11:42 UTC (rev 1271)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadObjectModel.java	2013-06-11 12:16:35 UTC (rev 1272)
@@ -1,11 +1,11 @@
 package org.nuiton.eugene.models.object.reader.yaml;
 
-import org.nuiton.eugene.models.object.*;
 import org.nuiton.eugene.models.object.xml.*;
 
 import java.io.FileWriter;
 import java.io.IOException;
-import java.util.*;
+import java.util.List;
+import java.util.Map;
 
 /**
  * User: agiraudet
@@ -18,6 +18,7 @@
     String packageL;//package local
 
     private boolean _loginit = true;
+
     private void log(String str) {
         try {
             FileWriter log;
@@ -31,13 +32,14 @@
             log = new FileWriter(path, true);
             log.write("[LOG] " + str + "\n");
             log.close();
-        } catch (IOException e) {;}
+        } catch (IOException e) {
+            ;
+        }
     }
 
     //precondition: labels et imports resolus
     //TODO: valeurs par defaut
-    public TestLoadObjectModel(/*YamlObject modelYAMLO, ObjectModelImpl modelOM*/)
-    {
+    public TestLoadObjectModel(/*YamlObject modelYAMLO, ObjectModelImpl modelOM*/) {
         ;//loadModel(modelYAMLO,modelOM);
     }
 
@@ -49,561 +51,435 @@
         //log
 
         String packageYAMLO = modelYAMLO.getFirstMapStringListString(PACKAGE);
-        if(packageYAMLO == null)
-        {
+        if (packageYAMLO == null) {
             packageL = "";
-        }
-        else
-        {
+        } else {
             packageL = packageYAMLO;
         }
-        log("package="+packageL);
+        log("package=" + packageL);
 
         String nameYAMLO = modelYAMLO.getFirstMapStringListString(NAME);
-        if(nameYAMLO == null)
-        {
+        if (nameYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             modelOM.setName(nameYAMLO);
-            log("name="+modelOM.getName());
+            log("name=" + modelOM.getName());
         }
 
         String versionYAMLO = modelYAMLO.getFirstMapStringListString(VERSION);
-        if(versionYAMLO == null)
-        {
+        if (versionYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             modelOM.setVersion(versionYAMLO);
-            log("version="+modelOM.getVersion());
+            log("version=" + modelOM.getVersion());
         }
 
         //tagvalues
         YamlObject tagValues = modelYAMLO.getFirstMapStringListYamlObject(TAG_VALUES);
-        if(tagValues != null)
-        {
-            for(Map.Entry<String,List<String>> tagValue :tagValues.getMapStringListString().entrySet())
-            {
-                if(!tagValue.getValue().isEmpty())//taille strictement = 1
+        if (tagValues != null) {
+            for (Map.Entry<String, List<String>> tagValue : tagValues.getMapStringListString().entrySet()) {
+                if (!tagValue.getValue().isEmpty())//taille strictement = 1
                 {
-                    modelOM.addTagValue(tagValue.getKey(),tagValue.getValue().get(0));
+                    modelOM.addTagValue(tagValue.getKey(), tagValue.getValue().get(0));
                 }
             }
-            log("tagValues="+modelOM.getTagValues());
+            log("tagValues=" + modelOM.getTagValues());
         }
 
         //classes
-        for(YamlObject classYAMLO : modelYAMLO.getMapStringListYamlObject(CLASS))
-        {
+        for (YamlObject classYAMLO : modelYAMLO.getMapStringListYamlObject(CLASS)) {
             log("   CLASS");
             ObjectModelClassImpl classOM = new ObjectModelClassImpl();
-            loadClass(classYAMLO,classOM);
+            loadClass(classYAMLO, classOM);
             modelOM.addClass(classOM);
         }
         //interfaces
-        for(YamlObject interfaceYAMLO : modelYAMLO.getMapStringListYamlObject(INTERFACE))
-        {
+        for (YamlObject interfaceYAMLO : modelYAMLO.getMapStringListYamlObject(INTERFACE)) {
             log("   INTERFACE");
             ObjectModelInterfaceImpl interfaceOM = new ObjectModelInterfaceImpl();
-            loadInterface(interfaceYAMLO,interfaceOM);
+            loadInterface(interfaceYAMLO, interfaceOM);
             modelOM.addInterface(interfaceOM);
         }
         //classes d'association
-        for(YamlObject associationClassYAMLO : modelYAMLO.getMapStringListYamlObject(ASSOCIATION_CLASS))
-        {
+        for (YamlObject associationClassYAMLO : modelYAMLO.getMapStringListYamlObject(ASSOCIATION_CLASS)) {
             log("   ASSOCIATION_CLASS");
             ObjectModelAssociationClassImpl associationClassOM = new ObjectModelAssociationClassImpl();
-            loadAssociationClass(associationClassYAMLO,associationClassOM);
+            loadAssociationClass(associationClassYAMLO, associationClassOM);
             modelOM.addAssociationClass(associationClassOM);
         }
         //enumerations
-        for(YamlObject enumerationYAMLO : modelYAMLO.getMapStringListYamlObject(ENUMERATION))
-        {
+        for (YamlObject enumerationYAMLO : modelYAMLO.getMapStringListYamlObject(ENUMERATION)) {
             log("   ENUMERATION");
             ObjectModelEnumerationImpl enumerationOM = new ObjectModelEnumerationImpl();
-            loadEnumeration(enumerationYAMLO,enumerationOM);
+            loadEnumeration(enumerationYAMLO, enumerationOM);
             modelOM.addEnumeration(enumerationOM);
         }
     }
 
-    public void loadElement(YamlObject elementYAMLO, ObjectModelElementImpl elementOM)
-    {
+    public void loadElement(YamlObject elementYAMLO, ObjectModelElementImpl elementOM) {
         String nameYAMLO = elementYAMLO.getFirstMapStringListString(NAME);
-        if(nameYAMLO == null)
-        {
+        if (nameYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             elementOM.setName(nameYAMLO);
-            log("name="+elementOM.getName());
+            log("name=" + elementOM.getName());
         }
 
         String staticYAMLO = elementYAMLO.getFirstMapStringListString(STATIC);
-        if(staticYAMLO == null)
-        {
+        if (staticYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             elementOM.setStatic(Boolean.valueOf(staticYAMLO));
-            log("static="+elementOM.isStatic());
+            log("static=" + elementOM.isStatic());
         }
 
         String documentationYAMLO = elementYAMLO.getFirstMapStringListString(DOCUMENTATION);
-        if(documentationYAMLO == null)
-        {
+        if (documentationYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             elementOM.setDocumentation(documentationYAMLO);
-            log("documentation="+elementOM.getDocumentation());
+            log("documentation=" + elementOM.getDocumentation());
         }
 
         YamlObject tagValues = elementYAMLO.getFirstMapStringListYamlObject(TAG_VALUES);
-        if(tagValues != null)
-        {
-            for(Map.Entry<String,List<String>> tagValue :tagValues.getMapStringListString().entrySet())
-            {
-                if(!tagValue.getValue().isEmpty())//taille strictement = 1
+        if (tagValues != null) {
+            for (Map.Entry<String, List<String>> tagValue : tagValues.getMapStringListString().entrySet()) {
+                if (!tagValue.getValue().isEmpty())//taille strictement = 1
                 {
-                    elementOM.addTagValue(tagValue.getKey(),tagValue.getValue().get(0));
+                    elementOM.addTagValue(tagValue.getKey(), tagValue.getValue().get(0));
                 }
             }
-            log("tagValues="+elementOM.getTagValues());
+            log("tagValues=" + elementOM.getTagValues());
         }
 
         List<String> comments = elementYAMLO.getMapStringListString(COMMENTS);
-        for(String comment : comments)
-        {
+        for (String comment : comments) {
             elementOM.addComment(comment);
-            log("comments="+elementOM.getComments());
+            log("comments=" + elementOM.getComments());
         }
 
         List<String> stereotypes = elementYAMLO.getMapStringListString(STEREOTYPES);
-        for(String stereotype : stereotypes)
-        {
+        for (String stereotype : stereotypes) {
             ObjectModelImplRef stereotypeOM = new ObjectModelImplRef();
             stereotypeOM.setName(stereotype);
             elementOM.addStereotype(stereotypeOM);
-            log("stereotype="+elementOM.getStereotypes());
+            log("stereotype=" + elementOM.getStereotypes());
         }
     }
 
-    public void loadClassifier(YamlObject classifierYAMLO, ObjectModelClassifierImpl classifierOM)
-    {
+    public void loadClassifier(YamlObject classifierYAMLO, ObjectModelClassifierImpl classifierOM) {
         loadElement(classifierYAMLO, classifierOM);
 
-        String  packageYAMLO = classifierYAMLO.getFirstMapStringListString(PACKAGE);
-        if(packageYAMLO == null)
-        {
+        String packageYAMLO = classifierYAMLO.getFirstMapStringListString(PACKAGE);
+        if (packageYAMLO == null) {
             //TODO: tester packageL == null
             classifierOM.setPackage(packageL);
-        }
-        else
-        {
+        } else {
             classifierOM.setPackage(packageYAMLO);
         }
-        log("package="+classifierOM.getPackageName());
+        log("package=" + classifierOM.getPackageName());
 
 
         String externYAMLO = classifierYAMLO.getFirstMapStringListString(EXTERN);
-        if(externYAMLO == null)
-        {
+        if (externYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             classifierOM.setExtern(Boolean.valueOf(externYAMLO));
-            log("extern="+classifierOM.isExtern());
+            log("extern=" + classifierOM.isExtern());
 
         }
 
         String innerYAMLO = classifierYAMLO.getFirstMapStringListString(INNER);
-        if(innerYAMLO == null)
-        {
+        if (innerYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             classifierOM.setInner(Boolean.valueOf(innerYAMLO));
-            log("inner="+classifierOM.isInner());
+            log("inner=" + classifierOM.isInner());
         }
 
         String typeYAMLO = classifierYAMLO.getFirstMapStringListString(TYPE);
-        if(typeYAMLO == null)
-        {
+        if (typeYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             classifierOM.setType(typeYAMLO);
-            log("type="+typeYAMLO);//getType ?
+            log("type=" + typeYAMLO);//getType ?
         }
 
-        for(YamlObject attributeYAMLO : classifierYAMLO.getMapStringListYamlObject(ATTRIBUTE))
-        {
+        for (YamlObject attributeYAMLO : classifierYAMLO.getMapStringListYamlObject(ATTRIBUTE)) {
             log("   ATTRIBUTE");
             ObjectModelAttributeImpl attributeOM = new ObjectModelAttributeImpl();
-            loadAttribute(attributeYAMLO,attributeOM);
+            loadAttribute(attributeYAMLO, attributeOM);
             classifierOM.addAttribute(attributeOM);
         }
 
-        for(YamlObject operationYAMLO : classifierYAMLO.getMapStringListYamlObject(OPERATION))
-        {
+        for (YamlObject operationYAMLO : classifierYAMLO.getMapStringListYamlObject(OPERATION)) {
             log("   OPERATION");
             ObjectModelOperationImpl operationOM = new ObjectModelOperationImpl();
-            loadOperation(operationYAMLO,operationOM);
+            loadOperation(operationYAMLO, operationOM);
             classifierOM.addOperation(operationOM);
         }
 
         List<String> superInterfacesYAMLO = classifierYAMLO.getMapStringListString(SUPER_INTERFACES);
-        for(String superInterfaceYAMLO : superInterfacesYAMLO)
-        {
+        for (String superInterfaceYAMLO : superInterfacesYAMLO) {
             ObjectModelImplRef superInterfaceOM = new ObjectModelImplRef();
             superInterfaceOM.setName(superInterfaceYAMLO);
             classifierOM.addInterface(superInterfaceOM);
-            log("superInterface="+superInterfaceYAMLO);
+            log("superInterface=" + superInterfaceYAMLO);
         }
     }
 
-    public void loadClass(YamlObject classYAMLO, ObjectModelClassImpl classOM)
-    {
+    public void loadClass(YamlObject classYAMLO, ObjectModelClassImpl classOM) {
         loadClassifier(classYAMLO, classOM);
 
         String abstractYAMLO = classYAMLO.getFirstMapStringListString(ABSTRACT);
-        if(abstractYAMLO == null)
-        {
+        if (abstractYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             classOM.setAbstract(Boolean.valueOf(abstractYAMLO));
-            log("abstract="+classOM.isAbstract());
+            log("abstract=" + classOM.isAbstract());
         }
 
         List<String> superClassesYAMLO = classYAMLO.getMapStringListString(SUPER_CLASSES);
-        for(String superClassYAMLO : superClassesYAMLO)
-        {
+        for (String superClassYAMLO : superClassesYAMLO) {
             ObjectModelImplSuperClassRef superClassOM = new ObjectModelImplSuperClassRef();
             superClassOM.setName(superClassYAMLO);
             classOM.addSuperclass(superClassOM);
-            log("superClasses="+superClassYAMLO);
+            log("superClasses=" + superClassYAMLO);
         }
     }
 
-    public void loadInterface(YamlObject interfaceYAMLO, ObjectModelInterfaceImpl interfaceOM)
-    {
-        loadClassifier(interfaceYAMLO,interfaceOM);
+    public void loadInterface(YamlObject interfaceYAMLO, ObjectModelInterfaceImpl interfaceOM) {
+        loadClassifier(interfaceYAMLO, interfaceOM);
     }
 
-    public void loadAssociationClass(YamlObject associationClassYAML, ObjectModelAssociationClassImpl associationClassOM)
-    {
+    public void loadAssociationClass(YamlObject associationClassYAML, ObjectModelAssociationClassImpl associationClassOM) {
         loadClass(associationClassYAML, associationClassOM);
 
         //TODO: remplacer name par type et attribute par name ?
-        for(YamlObject participantYAMLO : associationClassYAML.getMapStringListYamlObject(PARTICIPANT))
-        {
+        for (YamlObject participantYAMLO : associationClassYAML.getMapStringListYamlObject(PARTICIPANT)) {
             log("   PARTICIPANT");
             ObjectModeImplAssociationClassParticipant participantOM = new ObjectModeImplAssociationClassParticipant();
             participantOM.setAssociationClass(associationClassOM);
 
             String nameYAMLO = participantYAMLO.getFirstMapStringListString(NAME);
-            if(nameYAMLO == null)
-            {
+            if (nameYAMLO == null) {
                 ;//valeur par defaut
-            }
-            else
-            {
+            } else {
                 participantOM.setName(nameYAMLO);
-                log("name="+participantOM.getName());
+                log("name=" + participantOM.getName());
             }
 
             String attributeYAMLO = participantYAMLO.getFirstMapStringListString(ATTRIBUTE);
-            if(attributeYAMLO == null)
-            {
+            if (attributeYAMLO == null) {
                 ;//valeur par defaut
-            }
-            else
-            {
+            } else {
                 participantOM.setAttribute(attributeYAMLO);
-                log("attribute="+participantOM.getAttributeName());
+                log("attribute=" + participantOM.getAttributeName());
             }
 
             associationClassOM.addParticipant(participantOM);
         }
     }
 
-    public void loadEnumeration(YamlObject enumerationYAMLO, ObjectModelEnumerationImpl enumerationOM)
-    {
+    public void loadEnumeration(YamlObject enumerationYAMLO, ObjectModelEnumerationImpl enumerationOM) {
         loadElement(enumerationYAMLO, enumerationOM);
 
         //TODO: remplacer LITERAL par LITERALS (List)
         List<String> literalsYAMLO = enumerationYAMLO.getMapStringListString(LITERAL);
-        for(String literalYAMLO : literalsYAMLO)
-        {
+        for (String literalYAMLO : literalsYAMLO) {
             ObjectModelImplRef literalOM = new ObjectModelImplRef();
             literalOM.setName(literalYAMLO);
             enumerationOM.addLiteral(literalOM);
-            log("literals="+enumerationOM.getLiterals());
+            log("literals=" + enumerationOM.getLiterals());
         }
 
         String packageYAMLO = enumerationYAMLO.getFirstMapStringListString(PACKAGE);
-        if(packageYAMLO == null)
-        {
+        if (packageYAMLO == null) {
             enumerationOM.setPackage(packageL);
-        }
-        else
-        {
+        } else {
             enumerationOM.setPackage(packageYAMLO);
         }
-        log("package="+enumerationOM.getPackageName());
+        log("package=" + enumerationOM.getPackageName());
     }
 
-    public void loadParameter(YamlObject parameterYAMLO, ObjectModelParameterImpl parameterOM)
-    {
-        loadElement(parameterYAMLO,parameterOM);
+    public void loadParameter(YamlObject parameterYAMLO, ObjectModelParameterImpl parameterOM) {
+        loadElement(parameterYAMLO, parameterOM);
 
         String orderingYAMLO = parameterYAMLO.getFirstMapStringListString(ORDERING);
-        if(orderingYAMLO == null)
-        {
+        if (orderingYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             parameterOM.setOrdering(orderingYAMLO);
-            log("ordering="+orderingYAMLO);//getOrdering ?
+            log("ordering=" + orderingYAMLO);//getOrdering ?
         }
 
         String typeYAMLO = parameterYAMLO.getFirstMapStringListString(TYPE);
-        if(typeYAMLO == null)
-        {
+        if (typeYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             parameterOM.setType(typeYAMLO);
-            log("type="+parameterOM.getType());
+            log("type=" + parameterOM.getType());
         }
 
         String defaultValueYAMLO = parameterYAMLO.getFirstMapStringListString(DEFAULT_VALUE);
-        if(defaultValueYAMLO == null)
-        {
+        if (defaultValueYAMLO == null) {
             ;//default
-        }
-        else
-        {
+        } else {
             parameterOM.setDefaultValue(defaultValueYAMLO);
-            log("defaultValue="+parameterOM.getDefaultValue());
+            log("defaultValue=" + parameterOM.getDefaultValue());
         }
 
         String minMultiplicityYAMLO = parameterYAMLO.getFirstMapStringListString(MIN_MULTIPLICITY);
-        if(minMultiplicityYAMLO == null)
-        {
+        if (minMultiplicityYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             parameterOM.setMinMultiplicity(Integer.valueOf(minMultiplicityYAMLO));
-            log("minMultiplicity="+parameterOM.getMinMultiplicity());
+            log("minMultiplicity=" + parameterOM.getMinMultiplicity());
         }
 
         String maxMultiplicityYAMLO = parameterYAMLO.getFirstMapStringListString(MAX_MULTIPLICITY);
-        if(maxMultiplicityYAMLO == null)
-        {
+        if (maxMultiplicityYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             parameterOM.setMaxMultiplicity(Integer.valueOf(maxMultiplicityYAMLO));
-            log("maxMultiplicity="+parameterOM.getMaxMultiplicity());
+            log("maxMultiplicity=" + parameterOM.getMaxMultiplicity());
 
         }
 
         String orderedYAMLO = parameterYAMLO.getFirstMapStringListString(ORDERED);
-        if(orderedYAMLO == null)
-        {
+        if (orderedYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             parameterOM.setOrdered(Boolean.valueOf(orderedYAMLO));
-            log("ordered="+parameterOM.isOrdered());
+            log("ordered=" + parameterOM.isOrdered());
         }
 
         String uniqueYAMLO = parameterYAMLO.getFirstMapStringListString(UNIQUE);
-        if(uniqueYAMLO == null)
-        {
+        if (uniqueYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             parameterOM.setUnique(Boolean.valueOf(uniqueYAMLO));
-            log("unique="+parameterOM.isUnique());
+            log("unique=" + parameterOM.isUnique());
         }
     }
 
-    public void loadAttribute(YamlObject attributeYAMLO, ObjectModelAttributeImpl attributeOM)
-    {
-        loadParameter(attributeYAMLO,attributeOM);
+    public void loadAttribute(YamlObject attributeYAMLO, ObjectModelAttributeImpl attributeOM) {
+        loadParameter(attributeYAMLO, attributeOM);
 
         String navigableYAMLO = attributeYAMLO.getFirstMapStringListString(NAVIGABLE);
-        if(navigableYAMLO == null)
-        {
+        if (navigableYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setNavigable(Boolean.valueOf(navigableYAMLO));
-            log("navigable="+attributeOM.isNavigable());
+            log("navigable=" + attributeOM.isNavigable());
         }
 
         String associationTypeYAMLO = attributeYAMLO.getFirstMapStringListString(ASSOCIATION_TYPE);
-        if(associationTypeYAMLO == null)
-        {
+        if (associationTypeYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setAssociationType(associationTypeYAMLO);
-            log("associationType="+associationTypeYAMLO);//getAssociationType ?
+            log("associationType=" + associationTypeYAMLO);//getAssociationType ?
         }
 
         String finalYAMLO = attributeYAMLO.getFirstMapStringListString(FINAL);
-        if(finalYAMLO == null)
-        {
+        if (finalYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setFinal(Boolean.valueOf(finalYAMLO));
-            log("final="+attributeOM.isFinal());
+            log("final=" + attributeOM.isFinal());
         }
 
         String staticYAMLO = attributeYAMLO.getFirstMapStringListString(STATIC);
-        if(staticYAMLO == null)
-        {
+        if (staticYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setStatic(Boolean.valueOf(staticYAMLO));
-            log("static="+attributeOM.isStatic());
+            log("static=" + attributeOM.isStatic());
         }
 
         String associationClassNameYAMLO = attributeYAMLO.getFirstMapStringListString(ASSOCIATION_CLASS_NAME);
-        if(associationClassNameYAMLO == null)
-        {
+        if (associationClassNameYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setAssociationClassName(associationClassNameYAMLO);
-            log("associationClassName="+associationClassNameYAMLO);
+            log("associationClassName=" + associationClassNameYAMLO);
         }
 
         String reverseAttributeNameYAMLO = attributeYAMLO.getFirstMapStringListString(REVERSE_ATTRIBUTE_NAME);
-        if(reverseAttributeNameYAMLO == null)
-        {
+        if (reverseAttributeNameYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setReverseAttributeName(reverseAttributeNameYAMLO);
-            log("reverseAttributeName="+attributeOM.getReverseAttributeName());
+            log("reverseAttributeName=" + attributeOM.getReverseAttributeName());
         }
 
         String reverseMaxMultiplicityYAMLO = attributeYAMLO.getFirstMapStringListString(REVERSE_MAX_MULTIPLICITY);
-        if(reverseMaxMultiplicityYAMLO == null)
-        {
+        if (reverseMaxMultiplicityYAMLO == null) {
             //test
             attributeOM.setReverseMaxMultiplicity(1);//valeur par defaut
             //test
-        }
-        else
-        {
+        } else {
             attributeOM.setReverseMaxMultiplicity(Integer.valueOf(reverseMaxMultiplicityYAMLO));
-            log("reverseMaxMultiplicity="+attributeOM.getReverseMaxMultiplicity());
+            log("reverseMaxMultiplicity=" + attributeOM.getReverseMaxMultiplicity());
         }
 
         String transientYAMLO = attributeYAMLO.getFirstMapStringListString(TRANSIENT);
-        if(transientYAMLO == null)
-        {
+        if (transientYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setTransient(Boolean.valueOf(transientYAMLO));
-            log("transient="+attributeOM.isTransient());
+            log("transient=" + attributeOM.isTransient());
         }
 
         String visibilityYAMLO = attributeYAMLO.getFirstMapStringListString(VISIBILITY);
-        if(visibilityYAMLO == null)
-        {
+        if (visibilityYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             attributeOM.setVisibility(visibilityYAMLO);
-            log("visibility="+attributeOM.getVisibility());
+            log("visibility=" + attributeOM.getVisibility());
         }
     }
 
-    public void loadOperation(YamlObject operationYAMLO, ObjectModelOperationImpl operationOM)
-    {
-        loadElement(operationYAMLO,operationOM);
+    public void loadOperation(YamlObject operationYAMLO, ObjectModelOperationImpl operationOM) {
+        loadElement(operationYAMLO, operationOM);
 
         String abstractYAMLO = operationYAMLO.getFirstMapStringListString(ABSTRACT);
-        if(abstractYAMLO == null)
-        {
+        if (abstractYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             operationOM.setAbstract(Boolean.valueOf(abstractYAMLO));
-            log("abstract="+operationOM.isAbstract());
+            log("abstract=" + operationOM.isAbstract());
         }
 
         String visibilityYAMLO = operationYAMLO.getFirstMapStringListString(VISIBILITY);
-        if(visibilityYAMLO == null)
-        {
+        if (visibilityYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             operationOM.setVisibility(visibilityYAMLO);
-            log("visibility="+operationOM.getVisibility());
+            log("visibility=" + operationOM.getVisibility());
         }
 
-        for(YamlObject returnParameterYAMLO : operationYAMLO.getMapStringListYamlObject(RETURN_PARAMETER))
-        {
+        for (YamlObject returnParameterYAMLO : operationYAMLO.getMapStringListYamlObject(RETURN_PARAMETER)) {
             log("   RETURN_PARAMETER");
             ObjectModelParameterImpl returnParameterOM = new ObjectModelAttributeImpl();
-            loadParameter(returnParameterYAMLO,returnParameterOM);
+            loadParameter(returnParameterYAMLO, returnParameterOM);
             operationOM.setReturnParameter(returnParameterOM);
         }
 
-        for(YamlObject parameterYAMLO : operationYAMLO.getMapStringListYamlObject(PARAMETER))
-        {
+        for (YamlObject parameterYAMLO : operationYAMLO.getMapStringListYamlObject(PARAMETER)) {
             log("   PARAMETER");
             ObjectModelParameterImpl parameterOM = new ObjectModelAttributeImpl();
-            loadParameter(parameterYAMLO,parameterOM);
+            loadParameter(parameterYAMLO, parameterOM);
             operationOM.addParameter(parameterOM);
         }
 
         String bodyCodeYAMLO = operationYAMLO.getFirstMapStringListString(BODY_CODE);
-        if(bodyCodeYAMLO == null)
-        {
+        if (bodyCodeYAMLO == null) {
             ;//valeur par defaut
-        }
-        else
-        {
+        } else {
             operationOM.setBodyCode(bodyCodeYAMLO);
-            log("bodyCode="+operationOM.getBodyCode());
+            log("bodyCode=" + operationOM.getBodyCode());
         }
     }
 }

Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadYamlFile.java
===================================================================
--- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadYamlFile.java	2013-06-11 10:11:42 UTC (rev 1271)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadYamlFile.java	2013-06-11 12:16:35 UTC (rev 1272)
@@ -5,17 +5,18 @@
 import org.yaml.snakeyaml.Yaml;
 
 import java.io.*;
-import java.util.*;
+import java.util.List;
+import java.util.Map;
 
 /**
  * User: agiraudet
  * Date: 28/05/13
  * Time: 16:35
- *
+ * <p/>
  * Rôle: parser le fichier YAML et le transformer en YAMLobject
- *
+ * <p/>
  * parser si besoin et charger le YAMLobject
- *     parse en fonction de la version
+ * parse en fonction de la version
  */
 @Deprecated
 public class TestLoadYamlFile extends KeyWords {
@@ -27,6 +28,7 @@
     String defaultVersion;//version des valeurs par defaut
 
     private boolean _loginit = true;
+
     private void log(String str) {
         try {
             FileWriter log;
@@ -40,11 +42,12 @@
             log = new FileWriter(path, true);
             log.write("[LOG] " + str + "\n");
             log.close();
-        } catch (IOException e) {;}
+        } catch (IOException e) {
+            ;
+        }
     }
 
-    public TestLoadYamlFile()
-    {
+    public TestLoadYamlFile() {
         yaml = new Yaml();
     }
 
@@ -57,55 +60,45 @@
 
         //chercher version et charger en conséquent
         Object version = null;
-        if(modelYAML instanceof List)
-        {
+        if (modelYAML instanceof List) {
             version = YamlUtil.collectElementList((List) modelYAML, SYNTAXE);
             syntaxeVersion = "1";
             defaultVersion = "0";
             log("modelYAML instanceof List");
         }
-        if(modelYAML instanceof Map)
-        {
+        if (modelYAML instanceof Map) {
             version = YamlUtil.collectElementMap((Map) modelYAML, SYNTAXE);
             syntaxeVersion = "2";
             defaultVersion = "0";
             log("modelYAML instanceof Map");
-        }
-        else
-        {
+        } else {
             syntaxeVersion = "0";
             defaultVersion = "0";
             log("modelYAML instanceof unknow");
         }
-        if(version != null)
-        {
-            syntaxeVersion = YamlUtil.beforeChar(String.valueOf(version),'.');
-            defaultVersion = YamlUtil.afterChar(String.valueOf(version),'.');
-            log("version="+syntaxeVersion+"."+defaultVersion);
+        if (version != null) {
+            syntaxeVersion = YamlUtil.beforeChar(String.valueOf(version), '.');
+            defaultVersion = YamlUtil.afterChar(String.valueOf(version), '.');
+            log("version=" + syntaxeVersion + "." + defaultVersion);
         }
 
-        if(syntaxeVersion.equals("1"))
-        {
+        if (syntaxeVersion.equals("1")) {
             SyntaxePureYaml.loadYamlObject(modelYAML, modelYAMLO);
             log("load SyntaxePureYaml");
-        }
-        else if(syntaxeVersion.equals("2"))
-        {
+        } else if (syntaxeVersion.equals("2")) {
             //syntaxe user firendly : coming soon
             Parser test = new Parser();
             test.parseModel(modelYAML, modelYAMLO);
             Parser.resolveImports(modelYAMLO);
             Parser.resolveLabels(modelYAMLO);
             log("load SyntaxeUserFriendly");
-        }
-        else
-        {
+        } else {
             ;//syntaxe par defaut, si version syntaxe non reconnue
             SyntaxePureYaml.loadYamlObject(modelYAML, modelYAMLO);
         }
 
         TestLoadObjectModel test = new TestLoadObjectModel();
-        test.loadModel(modelYAMLO,modelOM);
+        test.loadModel(modelYAMLO, modelOM);
         log("END");
         //TODO: charger ObjectModel avec les valeurs par defaut en fonction de la version (ajouter parametre à loadModel)
     }

Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlObject.java
===================================================================
--- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlObject.java	2013-06-11 10:11:42 UTC (rev 1271)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlObject.java	2013-06-11 12:16:35 UTC (rev 1272)
@@ -11,93 +11,72 @@
  * Time: 16:41
  */
 public class YamlObject {
-    protected Map<String,List<String>> mapStringListString;
+    protected Map<String, List<String>> mapStringListString;
     protected Map<String, List<YamlObject>> mapStringListYamlObject;
     //TODO: améliorer nom méthodes
 
-    public YamlObject()
-    {
+    public YamlObject() {
         mapStringListString = new LinkedHashMap<String, List<String>>();
         mapStringListYamlObject = new LinkedHashMap<String, List<YamlObject>>();
     }
 
-    public void addYamlObjectToMap(String key, YamlObject value)
-    {
-        if(mapStringListYamlObject.containsKey(key))
-        {
+    public void addYamlObjectToMap(String key, YamlObject value) {
+        if (mapStringListYamlObject.containsKey(key)) {
             mapStringListYamlObject.get(key).add(value);
-        }
-        else
-        {
+        } else {
             List<YamlObject> tmp = new LinkedList<YamlObject>();
             tmp.add(value);
-            mapStringListYamlObject.put(key,tmp);
+            mapStringListYamlObject.put(key, tmp);
         }
     }
 
-    public void addStringToMap(String key, String value)
-    {
-        if(mapStringListString.containsKey(key))
-        {
+    public void addStringToMap(String key, String value) {
+        if (mapStringListString.containsKey(key)) {
             mapStringListString.get(key).add(value);
-        }
-        else
-        {
+        } else {
             List<String> tmp = new LinkedList<String>();
             tmp.add(value);
-            mapStringListString.put(key,tmp);
+            mapStringListString.put(key, tmp);
         }
     }
 
-    public YamlObject getFirstMapStringListYamlObject(String key)
-    {
-        if(mapStringListYamlObject.containsKey(key))
-        {
-            if(!mapStringListYamlObject.isEmpty())
-            {
+    public YamlObject getFirstMapStringListYamlObject(String key) {
+        if (mapStringListYamlObject.containsKey(key)) {
+            if (!mapStringListYamlObject.isEmpty()) {
                 return mapStringListYamlObject.get(key).get(0);
             }
         }
-        return null;    }
+        return null;
+    }
 
-    public String getFirstMapStringListString(String key)
-    {
-        if( mapStringListString.containsKey(key))
-        {
-            if(! mapStringListString.isEmpty())
-            {
-                return  mapStringListString.get(key).get(0);
+    public String getFirstMapStringListString(String key) {
+        if (mapStringListString.containsKey(key)) {
+            if (!mapStringListString.isEmpty()) {
+                return mapStringListString.get(key).get(0);
             }
         }
         return null;
     }
 
-    public boolean isUniqueMapStringListYamlObject(String key)
-    {
+    public boolean isUniqueMapStringListYamlObject(String key) {
         return (sizeOfMapStringListYamlObject(key) == 1);
     }
 
-    public boolean isUniqueMapStringListString(String key)
-    {
+    public boolean isUniqueMapStringListString(String key) {
         return (sizeOfMapStringListString(key) == 1);
     }
 
-    public boolean containsKeyYamlMapStringListYamlObject(String key)
-    {
+    public boolean containsKeyYamlMapStringListYamlObject(String key) {
         return mapStringListYamlObject.containsKey(key);
     }
 
-    public boolean containsKeyMapStringListString(String key)
-    {
+    public boolean containsKeyMapStringListString(String key) {
         return mapStringListString.containsKey(key);
     }
 
-    public List<YamlObject> getMapStringListYamlObject(String key)
-    {
-        if(mapStringListYamlObject.containsKey(key))
-        {
-            if(!mapStringListYamlObject.isEmpty())
-            {
+    public List<YamlObject> getMapStringListYamlObject(String key) {
+        if (mapStringListYamlObject.containsKey(key)) {
+            if (!mapStringListYamlObject.isEmpty()) {
                 return mapStringListYamlObject.get(key);
             }
         }
@@ -105,12 +84,9 @@
         return new LinkedList<YamlObject>();
     }
 
-    public List<String> getMapStringListString(String key)
-    {
-        if(mapStringListString.containsKey(key))
-        {
-            if(!mapStringListString.isEmpty())
-            {
+    public List<String> getMapStringListString(String key) {
+        if (mapStringListString.containsKey(key)) {
+            if (!mapStringListString.isEmpty()) {
                 return mapStringListString.get(key);
             }
         }
@@ -118,92 +94,72 @@
         return new LinkedList<String>();
     }
 
-    public int sizeOfMapStringListYamlObject(String key)
-    {
-        if(mapStringListYamlObject.containsKey(key))
-        {
+    public int sizeOfMapStringListYamlObject(String key) {
+        if (mapStringListYamlObject.containsKey(key)) {
             return mapStringListYamlObject.get(key).size();
         }
         return 0;//-1
     }
 
-    public int sizeOfMapStringListString(String key)
-    {
-        if(mapStringListString.containsKey(key))
-        {
+    public int sizeOfMapStringListString(String key) {
+        if (mapStringListString.containsKey(key)) {
             return mapStringListString.get(key).size();
         }
         return 0;//-1
     }
 
-    public Map<String, List<YamlObject>> getMapStringListYamlObject()
-    {
+    public Map<String, List<YamlObject>> getMapStringListYamlObject() {
         return mapStringListYamlObject;
     }
 
-    public Map<String, List<String>> getMapStringListString()
-    {
+    public Map<String, List<String>> getMapStringListString() {
         return mapStringListString;
     }
 
-    public boolean setMapStringListString(String key, String value, String element)
-    {
-        if(mapStringListString.containsKey(key))
-        {
-            if(mapStringListString.get(key).contains(value))
-            {
-                mapStringListString.get(key).set(mapStringListString.get(key).indexOf(value),element);
+    public boolean setMapStringListString(String key, String value, String element) {
+        if (mapStringListString.containsKey(key)) {
+            if (mapStringListString.get(key).contains(value)) {
+                mapStringListString.get(key).set(mapStringListString.get(key).indexOf(value), element);
                 return true;
             }
         }
         return false;
     }
 
-    public boolean setMapStringListYamlObject(String key, YamlObject value, YamlObject element)
-    {
-        if(mapStringListYamlObject.containsKey(key))
-        {
-            if(mapStringListYamlObject.get(key).contains(value))
-            {
-                mapStringListYamlObject.get(key).set(mapStringListYamlObject.get(key).indexOf(value),element);
+    public boolean setMapStringListYamlObject(String key, YamlObject value, YamlObject element) {
+        if (mapStringListYamlObject.containsKey(key)) {
+            if (mapStringListYamlObject.get(key).contains(value)) {
+                mapStringListYamlObject.get(key).set(mapStringListYamlObject.get(key).indexOf(value), element);
                 return true;
             }
         }
         return false;
     }
 
-    public boolean removeMapStringListString(String key, String value)
-    {
-        if(mapStringListString.containsKey(key))
-        {
+    public boolean removeMapStringListString(String key, String value) {
+        if (mapStringListString.containsKey(key)) {
             return mapStringListString.get(key).remove(value);
         }
         return false;
     }
 
-    public boolean removeMapStringString(String key)
-    {
-        if(mapStringListString.containsKey(key))
-        {
+    public boolean removeMapStringString(String key) {
+        if (mapStringListString.containsKey(key)) {
             mapStringListString.remove(key);
             return true;
         }
         return false;
     }
 
-    public boolean removeMapStringListYamlObject(String key, YamlObject value)
-    {
-        if(mapStringListYamlObject.containsKey(key))
-        {
+    public boolean removeMapStringListYamlObject(String key, YamlObject value) {
+        if (mapStringListYamlObject.containsKey(key)) {
             return mapStringListYamlObject.get(key).remove(value);
         }
         return false;
     }
 
-    public boolean removeMapStringListYamlObject(String key)
-    {
-        if(mapStringListYamlObject.containsKey(key))
-        {
+    public boolean removeMapStringListYamlObject(String key) {
+        if (mapStringListYamlObject.containsKey(key)) {
             mapStringListYamlObject.remove(key);
             return true;
         }
@@ -212,38 +168,30 @@
 
     @Override
     public boolean equals(Object o) {
-        if(o instanceof YamlObject)
-        {
+        if (o instanceof YamlObject) {
             return (mapStringListYamlObject.equals(((YamlObject) o).getMapStringListYamlObject()) && mapStringListString.equals(((YamlObject) o).getMapStringListString()));
         }
         return false;
     }
 
     @Override
-    public String toString()
-    {
+    public String toString() {
         return toString("- ");
     }
 
-    public String toString(String indentation)
-    {
+    public String toString(String indentation) {
         StringBuilder res = new StringBuilder();
 
-        for(Map.Entry<String,List<String>> entry : mapStringListString.entrySet())
-        {
-            for(String str : entry.getValue())
-            {
+        for (Map.Entry<String, List<String>> entry : mapStringListString.entrySet()) {
+            for (String str : entry.getValue()) {
                 res.append(indentation).append(entry.getKey()).append(": ").append(str).append("\n");
             }
         }
-        for(Map.Entry<String,List<YamlObject>> entry : mapStringListYamlObject.entrySet())
-        {
-            for(YamlObject yobj : entry.getValue())
-            {
+        for (Map.Entry<String, List<YamlObject>> entry : mapStringListYamlObject.entrySet()) {
+            for (YamlObject yobj : entry.getValue()) {
                 //test temporaire
-                if(yobj != null)
-                {
-                    res.append(indentation).append(entry.getKey()).append(":\n").append(yobj.toString( "  "+indentation)).append("\n");
+                if (yobj != null) {
+                    res.append(indentation).append(entry.getKey()).append(":\n").append(yobj.toString("  " + indentation)).append("\n");
                 }
                 //test
             }

Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlToObjectModel.java
===================================================================
--- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlToObjectModel.java	2013-06-11 10:11:42 UTC (rev 1271)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlToObjectModel.java	2013-06-11 12:16:35 UTC (rev 1272)
@@ -1,11 +1,14 @@
 package org.nuiton.eugene.models.object.reader.yaml;
 
-import org.nuiton.eugene.models.object.*;
+import org.nuiton.eugene.models.object.ObjectModel;
 import org.nuiton.eugene.models.object.xml.*;
 import org.yaml.snakeyaml.Yaml;
 
 import java.io.*;
-import java.util.*;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
 
 import static org.nuiton.eugene.models.object.reader.yaml.YamlUtil.afterChar;
 import static org.nuiton.eugene.models.object.reader.yaml.YamlUtil.browseKeySetToLowerCase;
@@ -15,7 +18,7 @@
  * Date: 15/05/13
  * Time: 11:15
  */
- @Deprecated
+@Deprecated
 public class YamlToObjectModel {
     protected Yaml yaml;
     protected String packageOM;
@@ -66,6 +69,7 @@
     public static final String ELEMENT = "element";
 
     private boolean _loginit = true;
+
     private void log(String str) {
         try {
             FileWriter log;
@@ -79,7 +83,9 @@
             log = new FileWriter(path, true);
             log.write("[LOG] " + str + "\n");
             log.close();
-        } catch (IOException e) {;}
+        } catch (IOException e) {
+            ;
+        }
     }
 
     public YamlToObjectModel() {
@@ -142,12 +148,10 @@
             //load imports
             imports = new LinkedHashMap<String, String>();
             Object importsYAML = collectElement((List) modelYAML, IMPORTS);
-            if(importsYAML instanceof List)
-            {
-                for(Object importYAML : (List) importsYAML)
-                {
-                    imports.put(afterChar(String.valueOf(importYAML),'.'),String.valueOf(importYAML));
-                    log("import="+String.valueOf(importYAML));
+            if (importsYAML instanceof List) {
+                for (Object importYAML : (List) importsYAML) {
+                    imports.put(afterChar(String.valueOf(importYAML), '.'), String.valueOf(importYAML));
+                    log("import=" + String.valueOf(importYAML));
                 }
             }
 
@@ -158,14 +162,14 @@
             } else {
                 packageOM = String.valueOf(packageYAML);
             }
-            log("package="+packageOM);
+            log("package=" + packageOM);
 
             Object nameYAML = collectElement((List) modelYAML, NAME);
             if (nameYAML == null) {
                 ;
             } else {
                 modelOM.setName(String.valueOf(nameYAML));
-                log("name="+String.valueOf(nameYAML));
+                log("name=" + String.valueOf(nameYAML));
             }
 
             Object versionYAML = collectElement((List) modelYAML, VERSION);
@@ -173,7 +177,7 @@
                 ;
             } else {
                 modelOM.setVersion(String.valueOf(versionYAML));
-                log("version="+String.valueOf(versionYAML));
+                log("version=" + String.valueOf(versionYAML));
             }
 
             Object tagValuesYAML = collectElement((List) modelYAML, TAG_VALUES);
@@ -181,7 +185,7 @@
                 for (Object entry : ((Map) tagValuesYAML).entrySet()) {
                     if (entry instanceof Map.Entry) {
                         modelOM.addTagValue(String.valueOf(((Map.Entry) entry).getKey()), String.valueOf(((Map.Entry) entry).getValue()));
-                        log("tagValue=[key="+String.valueOf(((Map.Entry) entry).getKey())+" value="+String.valueOf(((Map.Entry) entry).getValue())+"]");
+                        log("tagValue=[key=" + String.valueOf(((Map.Entry) entry).getKey()) + " value=" + String.valueOf(((Map.Entry) entry).getValue()) + "]");
                     }
                 }
             }
@@ -209,7 +213,7 @@
                 ObjectModelClassImpl classOM = new ObjectModelClassImpl();
                 loadClass(classYAML, classOM);
                 modelOM.addClass(classOM);
-                log("class="+classOM.getName()+" loaded");
+                log("class=" + classOM.getName() + " loaded");
             }
 
             List interfacesYAML = collectAllElements((List) modelYAML, INTERFACE);
@@ -217,7 +221,7 @@
                 ObjectModelInterfaceImpl interfaceOM = new ObjectModelInterfaceImpl();
                 loadInterface(interfaceYAML, interfaceOM);
                 modelOM.addInterface(interfaceOM);
-                log("interface="+interfaceOM.getName()+" loaded");
+                log("interface=" + interfaceOM.getName() + " loaded");
             }
 
             List classesAssociationYAML = collectAllElements((List) modelYAML, CLASS_ASSOCIATION);
@@ -225,7 +229,7 @@
                 ObjectModelAssociationClassImpl classAssociationOM = new ObjectModelAssociationClassImpl();
                 loadAssociationClass(classAssociationYAML, classAssociationOM);
                 modelOM.addAssociationClass(classAssociationOM);
-                log("classAssociation="+classAssociationOM.getName()+" loaded");
+                log("classAssociation=" + classAssociationOM.getName() + " loaded");
             }
 
             List enumerationsYAML = collectAllElements((List) modelYAML, ENUMERATION);
@@ -233,7 +237,7 @@
                 ObjectModelEnumerationImpl enumerationOM = new ObjectModelEnumerationImpl();
                 loadEnumeration(enumerationYAML, enumerationOM);
                 modelOM.addEnumeration(enumerationOM);
-                log("enumeration="+enumerationOM.getName()+" loaded");
+                log("enumeration=" + enumerationOM.getName() + " loaded");
             }
         }
     }
@@ -249,7 +253,7 @@
                 ;
             } else {
                 elementOM.setName(String.valueOf(nameYAML));
-                log("name="+String.valueOf(nameYAML));
+                log("name=" + String.valueOf(nameYAML));
             }
 
             Object staticYAML = collectElement((List) elementYAML, STATIC);
@@ -257,7 +261,7 @@
                 ;
             } else {
                 elementOM.setStatic(Boolean.valueOf(String.valueOf(staticYAML)));
-                log("static="+(Boolean.valueOf(String.valueOf(staticYAML))));
+                log("static=" + (Boolean.valueOf(String.valueOf(staticYAML))));
             }
 
             Object documentationYAML = collectElement((List) elementYAML, DOCUMENTATION);
@@ -265,7 +269,7 @@
                 ;
             } else {
                 elementOM.setDocumentation(String.valueOf(documentationYAML));
-                log("documentation="+String.valueOf(documentationYAML));
+                log("documentation=" + String.valueOf(documentationYAML));
             }
 
             Object tagValuesYAML = collectElement((List) elementYAML, TAG_VALUES);
@@ -273,7 +277,7 @@
                 for (Object entry : ((Map) tagValuesYAML).entrySet()) {
                     if (entry instanceof Map.Entry) {
                         elementOM.addTagValue(String.valueOf(((Map.Entry) entry).getKey()), String.valueOf(((Map.Entry) entry).getValue()));
-                        log("tagValue=[key="+String.valueOf(((Map.Entry) entry).getKey())+" value="+String.valueOf(((Map.Entry) entry).getValue())+"]");
+                        log("tagValue=[key=" + String.valueOf(((Map.Entry) entry).getKey()) + " value=" + String.valueOf(((Map.Entry) entry).getValue()) + "]");
                     }
                 }
             }
@@ -282,7 +286,7 @@
             if (commentsYAML instanceof List) {
                 for (Object comment : (List) commentsYAML) {
                     elementOM.addComment(String.valueOf(comment));
-                    log("comment="+String.valueOf(comment));
+                    log("comment=" + String.valueOf(comment));
                 }
             }
 
@@ -293,7 +297,7 @@
                         ObjectModelImplRef stereotypeOM = new ObjectModelImplRef();
                         stereotypeOM.setName(String.valueOf(stereotype));
                         elementOM.addStereotype(stereotypeOM);
-                        log("stereotype="+String.valueOf(stereotype));
+                        log("stereotype=" + String.valueOf(stereotype));
                     }
                 }
             }
@@ -311,7 +315,7 @@
                 classifierOM.setPackage(packageOM);
             } else {
                 classifierOM.setPackage(String.valueOf(packageYAML));
-                log("package="+String.valueOf(packageYAML));
+                log("package=" + String.valueOf(packageYAML));
             }
 
             Object externYAML = collectElement((List) classifierYAML, EXTERN);
@@ -319,7 +323,7 @@
                 ;
             } else {
                 classifierOM.setExtern(Boolean.valueOf(String.valueOf(externYAML)));
-                log("extern="+String.valueOf(externYAML));
+                log("extern=" + String.valueOf(externYAML));
             }
 
             Object innerYAML = collectElement((List) classifierYAML, INNER);
@@ -327,7 +331,7 @@
                 ;
             } else {
                 classifierOM.setInner(Boolean.valueOf(String.valueOf(innerYAML)));
-                log("inner="+String.valueOf(innerYAML));
+                log("inner=" + String.valueOf(innerYAML));
             }
 
             Object typeYAML = collectElement((List) classifierYAML, TYPE);
@@ -335,7 +339,7 @@
                 ;
             } else {
                 classifierOM.setType(String.valueOf(typeYAML));
-                log("type="+String.valueOf(typeYAML));
+                log("type=" + String.valueOf(typeYAML));
             }
 
             List attributesYAML = collectAllElements((List) classifierYAML, ATTRIBUTE);
@@ -343,7 +347,7 @@
                 ObjectModelAttributeImpl attributeOM = new ObjectModelAttributeImpl();
                 loadAttribute(attributeYAML, attributeOM);
                 classifierOM.addAttribute(attributeOM);
-                log("attribute="+attributeOM.getType()+" loaded");
+                log("attribute=" + attributeOM.getType() + " loaded");
             }
 
             List operationsYAML = collectAllElements((List) classifierYAML, OPERATION);
@@ -351,7 +355,7 @@
                 ObjectModelOperationImpl operationOM = new ObjectModelOperationImpl();
                 loadOperation(operationYAML, operationOM);
                 classifierOM.addOperation(operationOM);
-                log("operation="+operationOM.getName()+" loaded");
+                log("operation=" + operationOM.getName() + " loaded");
             }
 
             Object superInterfacesYAML = collectElement((List) classifierYAML, SUPER_INTERFACES);
@@ -360,7 +364,7 @@
                     ObjectModelImplRef superInterfaceOM = new ObjectModelImplRef();
                     superInterfaceOM.setName(String.valueOf(superInterface));
                     classifierOM.addInterface(superInterfaceOM);
-                    log("superInterface="+String.valueOf(superInterface));
+                    log("superInterface=" + String.valueOf(superInterface));
                 }
             }
         }
@@ -377,7 +381,7 @@
                 ;
             } else {
                 classOM.setAbstract(Boolean.valueOf(String.valueOf(abstractYAML)));
-                log("abstract="+String.valueOf(abstractYAML));
+                log("abstract=" + String.valueOf(abstractYAML));
             }
 
             Object superClassesYAML = collectElement((List) classYAML, SUPER_CLASSES);
@@ -387,7 +391,7 @@
                     //ObjectModelImplRef superClassOM = new ObjectModelImplRef();
                     superClassOM.setName(String.valueOf(superClass));
                     classOM.addSuperclass(superClassOM);
-                    log("superClass="+String.valueOf(superClass));
+                    log("superClass=" + String.valueOf(superClass));
                 }
             }
         }
@@ -422,7 +426,7 @@
                         } else {
                             participantOM.setName(name);
                         }
-                        log("name="+name);
+                        log("name=" + name);
                     }
 
                     Object attributeYAML = collectElement((List) participantYAML, ATTRIBUTE);
@@ -430,9 +434,9 @@
                         ;
                     } else {
                         participantOM.setAttribute(String.valueOf(attributeYAML));
-                        log("attribute="+String.valueOf(attributeYAML));
+                        log("attribute=" + String.valueOf(attributeYAML));
                     }
-                    log("participant="+String.valueOf(nameYAML)+" loaded");
+                    log("participant=" + String.valueOf(nameYAML) + " loaded");
                     associationClassOM.addParticipant(participantOM);
                 }
             }
@@ -449,7 +453,7 @@
                     ObjectModelImplRef literalOM = new ObjectModelImplRef();
                     literalOM.setName(String.valueOf(literalYAML));
                     enumerationOM.addLiteral(literalOM);
-                    log("literal="+String.valueOf(literalsYAML));
+                    log("literal=" + String.valueOf(literalsYAML));
                 }
             }
 
@@ -458,7 +462,7 @@
                 enumerationOM.setPackage(packageOM);
             } else {
                 enumerationOM.setPackage(String.valueOf(packageYAML));
-                log("package="+String.valueOf(packageYAML));
+                log("package=" + String.valueOf(packageYAML));
             }
         }
     }
@@ -472,7 +476,7 @@
                 ;
             } else {
                 parameterOM.setOrdering(String.valueOf(orderingYAML));
-                log("ordering="+String.valueOf(orderingYAML));
+                log("ordering=" + String.valueOf(orderingYAML));
             }
 
             Object typeYAML = collectElement((List) parameterYAML, TYPE);
@@ -485,7 +489,7 @@
                 } else {
                     parameterOM.setType(type);
                 }
-                log("type="+parameterOM.getType());
+                log("type=" + parameterOM.getType());
             }
 
             Object defaultValueYAML = collectElement((List) parameterYAML, DEFAULT_VALUE);
@@ -493,7 +497,7 @@
                 ;
             } else {
                 parameterOM.setDefaultValue(String.valueOf(defaultValueYAML));
-                log("defaultValue="+String.valueOf(defaultValueYAML));
+                log("defaultValue=" + String.valueOf(defaultValueYAML));
             }
 
             Object minMultiplicityYAML = collectElement((List) parameterYAML, MIN_MULTIPLICITY);
@@ -501,7 +505,7 @@
                 ;//deja instancié à 1
             } else {
                 parameterOM.setMinMultiplicity(Integer.valueOf(String.valueOf(minMultiplicityYAML)));
-                log("minMultiplicity="+Integer.valueOf(String.valueOf(minMultiplicityYAML)));
+                log("minMultiplicity=" + Integer.valueOf(String.valueOf(minMultiplicityYAML)));
             }
 
             Object maxMultiplicityYAML = collectElement((List) parameterYAML, MAX_MULTIPLICITY);
@@ -509,7 +513,7 @@
                 ;
             } else {
                 parameterOM.setMaxMultiplicity(Integer.valueOf(String.valueOf(maxMultiplicityYAML)));
-                log("maxMultiplicity="+String.valueOf(maxMultiplicityYAML));
+                log("maxMultiplicity=" + String.valueOf(maxMultiplicityYAML));
             }
 
             Object orderedYAML = collectElement((List) parameterYAML, ORDERED);
@@ -517,7 +521,7 @@
                 ;
             } else {
                 parameterOM.setOrdered(Boolean.valueOf(String.valueOf(orderedYAML)));
-                log("ordered="+Boolean.valueOf(String.valueOf(orderedYAML)));
+                log("ordered=" + Boolean.valueOf(String.valueOf(orderedYAML)));
             }
 
             Object uniqueYAML = collectElement((List) parameterYAML, UNIQUE);
@@ -525,7 +529,7 @@
                 ;
             } else {
                 parameterOM.setUnique(Boolean.valueOf(String.valueOf(uniqueYAML)));
-                log("unique="+Boolean.valueOf(String.valueOf(uniqueYAML)));
+                log("unique=" + Boolean.valueOf(String.valueOf(uniqueYAML)));
             }
         }
     }
@@ -539,7 +543,7 @@
                 ;
             } else {
                 attributeOM.setNavigable(Boolean.valueOf(String.valueOf(navigableYAML)));
-                log("navigable="+Boolean.valueOf(String.valueOf(navigableYAML)));
+                log("navigable=" + Boolean.valueOf(String.valueOf(navigableYAML)));
             }
 
             Object associationTypeYAML = collectElement((List) attributeYAML, ASSOCIATION_TYPE);
@@ -547,7 +551,7 @@
                 ;//attributeOM.setAssociationType(ObjectModelAttributeImpl.ATTRIBUTE_TYPE_COMPOSITE);
             } else {
                 attributeOM.setAssociationType(String.valueOf(associationTypeYAML));
-                log("associationType="+String.valueOf(associationTypeYAML));
+                log("associationType=" + String.valueOf(associationTypeYAML));
             }
 
             Object finalYAML = collectElement((List) attributeYAML, FINAL);
@@ -555,7 +559,7 @@
                 ;
             } else {
                 attributeOM.setFinal(Boolean.valueOf(String.valueOf(finalYAML)));
-                log("final="+Boolean.valueOf(String.valueOf(finalYAML)));
+                log("final=" + Boolean.valueOf(String.valueOf(finalYAML)));
             }
 
             Object staticYAML = collectElement((List) attributeYAML, STATIC);
@@ -563,7 +567,7 @@
                 ;
             } else {
                 attributeOM.setStatic(Boolean.valueOf(String.valueOf(staticYAML)));
-                log("static="+Boolean.valueOf(String.valueOf(staticYAML)));
+                log("static=" + Boolean.valueOf(String.valueOf(staticYAML)));
             }
 
             Object associationClassNameYAML = collectElement((List) attributeYAML, ASSOCIATION_CLASS_NAME);
@@ -576,7 +580,7 @@
                 } else {
                     attributeOM.setAssociationClassName(associationClassName);
                 }
-                log("associationClassName="+associationClassName);
+                log("associationClassName=" + associationClassName);
             }
 
             Object reverseAttributeNameYAML = collectElement((List) attributeYAML, REVERSE_ATTRIBUTE_NAME);
@@ -584,7 +588,7 @@
                 ;// attributeOM.setReverseAttributeName("");//test
             } else {
                 attributeOM.setReverseAttributeName(String.valueOf(reverseAttributeNameYAML));
-                log("reverseAttributeName="+String.valueOf(reverseAttributeNameYAML));
+                log("reverseAttributeName=" + String.valueOf(reverseAttributeNameYAML));
             }
 
             Object reverseMaxMultiplicityYAML = collectElement((List) attributeYAML, REVERSE_MAX_MULTIPLICITY);
@@ -592,7 +596,7 @@
                 ;//instancié à -1
             } else {
                 attributeOM.setReverseMaxMultiplicity(Integer.valueOf(String.valueOf(reverseMaxMultiplicityYAML)));
-                log("reverseMaxMultiplicity="+Integer.valueOf(String.valueOf(reverseMaxMultiplicityYAML)));
+                log("reverseMaxMultiplicity=" + Integer.valueOf(String.valueOf(reverseMaxMultiplicityYAML)));
             }
 
 
@@ -601,7 +605,7 @@
                 ;
             } else {
                 attributeOM.setTransient(Boolean.valueOf(String.valueOf(transientYAML)));
-                log("transient="+Boolean.valueOf(String.valueOf(transientYAML)));
+                log("transient=" + Boolean.valueOf(String.valueOf(transientYAML)));
             }
 
             Object visibilityYAML = collectElement((List) attributeYAML, VISIBILITY);
@@ -609,7 +613,7 @@
                 ;
             } else {
                 attributeOM.setVisibility(String.valueOf(visibilityYAML));
-                log("visibility="+String.valueOf(visibilityYAML));
+                log("visibility=" + String.valueOf(visibilityYAML));
             }
         }
     }
@@ -625,7 +629,7 @@
                 ;
             } else {
                 operationOM.setAbstract(Boolean.valueOf(String.valueOf(abstractYAML)));
-                log("abstract="+Boolean.valueOf(String.valueOf(abstractYAML)));
+                log("abstract=" + Boolean.valueOf(String.valueOf(abstractYAML)));
             }
 
             Object visibilityYAML = collectElement((List) operationYAML, VISIBILITY);
@@ -633,7 +637,7 @@
                 ;
             } else {
                 operationOM.setVisibility(String.valueOf(visibilityYAML));
-                log("visibility="+String.valueOf(visibilityYAML));
+                log("visibility=" + String.valueOf(visibilityYAML));
             }
 
             Object returnParameterYAML = collectElement((List) operationYAML, RETURN_PARAMETER);
@@ -643,7 +647,7 @@
                 ObjectModelParameterImpl parameterOM = new ObjectModelParameterImpl();
                 loadParameter(returnParameterYAML, parameterOM);
                 operationOM.setReturnParameter(parameterOM);
-                log("returnParameter="+parameterOM.getType()+" loaded");
+                log("returnParameter=" + parameterOM.getType() + " loaded");
             }
 
             Object bodyCodeYAML = collectElement((List) operationYAML, BODY_CODE);
@@ -651,7 +655,7 @@
                 ;
             } else {
                 operationOM.setBodyCode(String.valueOf(bodyCodeYAML));
-                log("bodyCode="+String.valueOf(bodyCodeYAML));
+                log("bodyCode=" + String.valueOf(bodyCodeYAML));
             }
 
             List parametersYAML = collectAllElements((List) operationYAML, PARAMETER);
@@ -659,7 +663,7 @@
                 ObjectModelParameterImpl parameterOM = new ObjectModelAttributeImpl();
                 loadParameter(parameterYAML, parameterOM);
                 operationOM.addParameter(parameterOM);
-                log("parameter="+parameterOM.getType()+" loaded");
+                log("parameter=" + parameterOM.getType() + " loaded");
             }
         }
     }

Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlUtil.java
===================================================================
--- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlUtil.java	2013-06-11 10:11:42 UTC (rev 1271)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlUtil.java	2013-06-11 12:16:35 UTC (rev 1272)
@@ -1,6 +1,9 @@
 package org.nuiton.eugene.models.object.reader.yaml;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
 
 /**
  * User: agiraudet
@@ -84,223 +87,161 @@
         return res;
     }
 
-    public static Object collectElementMap(Map data, Object key)
-    {
-        if(data.containsKey(key))
-        {
+    public static Object collectElementMap(Map data, Object key) {
+        if (data.containsKey(key)) {
             return data.get(key);
-        }
-        else
-        {
+        } else {
             return null;
         }
     }
 
     // fonctionnel/robuste/optimise
-    public static List<String> charParse(String str, Character target)
-    {
+    public static List<String> charParse(String str, Character target) {
         LinkedList<String> res = new LinkedList<String>();
-        StringBuilder tmp = new StringBuilder(str.length()+1);//+1 utile en Java ? != C
+        StringBuilder tmp = new StringBuilder(str.length() + 1);//+1 utile en Java ? != C
         boolean pre = false;
-        for(Character c : str.toCharArray())
-        {
-            if(c.equals(target))
-            {
-                if(pre)
-                {
+        for (Character c : str.toCharArray()) {
+            if (c.equals(target)) {
+                if (pre) {
                     res.add(tmp.toString());
                 }
-                tmp.delete(0,tmp.length());
+                tmp.delete(0, tmp.length());
                 pre = false;
-            }
-            else
-            {
+            } else {
                 tmp.append(c);
                 pre = true;
             }
         }
-        if(pre)
-        {
+        if (pre) {
             res.add(tmp.toString());
         }
         return res;
     }
 
     // fonctionnel/robuste/optimise
-    public static List<String> multiCharParse(String str, List<Character> targets)
-    {
+    public static List<String> multiCharParse(String str, List<Character> targets) {
         LinkedList<String> res = new LinkedList<String>();
-        StringBuilder tmp = new StringBuilder(str.length()+1);//+1 utile en Java ? != C
+        StringBuilder tmp = new StringBuilder(str.length() + 1);//+1 utile en Java ? != C
         boolean pre = false;
-        for(Character c : str.toCharArray())
-        {
-            if(targets.contains(c))
-            {
-                if(pre)
-                {
+        for (Character c : str.toCharArray()) {
+            if (targets.contains(c)) {
+                if (pre) {
                     res.add(tmp.toString());
                 }
-                tmp.delete(0,tmp.length());
+                tmp.delete(0, tmp.length());
                 pre = false;
-            }
-            else
-            {
+            } else {
                 tmp.append(c);
                 pre = true;
             }
         }
-        if(pre)
-        {
+        if (pre) {
             res.add(tmp.toString());
         }
         return res;
     }
 
-    public static List<String> charParseIgnore(String str, Character target, Character ignoreStart, Character ignoreEnd)
-    {
+    public static List<String> charParseIgnore(String str, Character target, Character ignoreStart, Character ignoreEnd) {
         LinkedList<String> res = new LinkedList<String>();
-        StringBuilder tmp = new StringBuilder(str.length()+1);//+1 utile en Java ? != C
+        StringBuilder tmp = new StringBuilder(str.length() + 1);//+1 utile en Java ? != C
         boolean pre = false;
         int ign = 0;//parentheses ouvertes
-        for(Character c : str.toCharArray())
-        {
-            if(c.equals(ignoreStart))
-            {
+        for (Character c : str.toCharArray()) {
+            if (c.equals(ignoreStart)) {
                 ign++;
                 tmp.append(c);
-            }
-            else if(c.equals(ignoreEnd))
-            {
+            } else if (c.equals(ignoreEnd)) {
                 ign--;
                 tmp.append(c);
-            }
-            else if(c.equals(target) && ign < 1)
-            {
-                if(pre)
-                {
+            } else if (c.equals(target) && ign < 1) {
+                if (pre) {
                     res.add(tmp.toString());
                 }
-                tmp.delete(0,tmp.length());
+                tmp.delete(0, tmp.length());
                 pre = false;
-            }
-            else
-            {
+            } else {
                 tmp.append(c);
                 pre = true;
             }
         }
-        if(pre)
-        {
+        if (pre) {
             res.add(tmp.toString());
         }
         return res;
     }
 
-    public static List<String> charParseMultiIgnore(String str, Character target, List<Character> ignoreStart, List<Character> ignoreEnd)
-    {
+    public static List<String> charParseMultiIgnore(String str, Character target, List<Character> ignoreStart, List<Character> ignoreEnd) {
         LinkedList<String> res = new LinkedList<String>();
-        StringBuilder tmp = new StringBuilder(str.length()+1);//+1 utile en Java ? != C
+        StringBuilder tmp = new StringBuilder(str.length() + 1);//+1 utile en Java ? != C
         boolean pre = false;
         int ign = 0;//parentheses ouvertes
-        for(Character c : str.toCharArray())
-        {
-            if(ignoreStart.contains(c))
-            {
+        for (Character c : str.toCharArray()) {
+            if (ignoreStart.contains(c)) {
                 ign++;
                 tmp.append(c);
-            }
-            else if(ignoreEnd.contains(c))
-            {
+            } else if (ignoreEnd.contains(c)) {
                 ign--;
                 tmp.append(c);
-            }
-            else if(c.equals(target) && ign < 1)
-            {
-                if(pre)
-                {
+            } else if (c.equals(target) && ign < 1) {
+                if (pre) {
                     res.add(tmp.toString());
                 }
-                tmp.delete(0,tmp.length());
+                tmp.delete(0, tmp.length());
                 pre = false;
-            }
-            else
-            {
+            } else {
                 tmp.append(c);
                 pre = true;
             }
         }
-        if(pre)
-        {
+        if (pre) {
             res.add(tmp.toString());
         }
         return res;
     }
 
-    public static String removeMultiChar(String str, List<Character> targets)
-    {
-        StringBuilder res = new StringBuilder(str.length()+1);
-        for(Character c : str.toCharArray())
-        {
-            if(!targets.contains(c))
-            {
+    public static String removeMultiChar(String str, List<Character> targets) {
+        StringBuilder res = new StringBuilder(str.length() + 1);
+        for (Character c : str.toCharArray()) {
+            if (!targets.contains(c)) {
                 res.append(c);
             }
         }
         return res.toString();
     }
 
-    public static String extract(Character start, Character end, String str)
-    {
-        StringBuilder tmp = new StringBuilder(str.length()+1);
+    public static String extract(Character start, Character end, String str) {
+        StringBuilder tmp = new StringBuilder(str.length() + 1);
         boolean start_end = false;
         int count = 0;
-        for(Character c : str.toCharArray())
-        {
-            if(!start_end && c.equals(start))
-            {
+        for (Character c : str.toCharArray()) {
+            if (!start_end && c.equals(start)) {
                 start_end = true;
-            }
-            else if(start_end && c.equals(start))
-            {
+            } else if (start_end && c.equals(start)) {
                 count++;
                 tmp.append(c);
-            }
-            else if(start_end && c.equals(end))
-            {
-                if(count>0)
-                {
+            } else if (start_end && c.equals(end)) {
+                if (count > 0) {
                     count--;
                     tmp.append(c);
-                }
-                else
-                {
+                } else {
                     return tmp.toString();
                 }
-            }
-            else if(start_end)
-            {
+            } else if (start_end) {
                 tmp.append(c);
             }
         }
         return null;
     }
 
-    public static String extract(Character startend, String str)
-    {
-        StringBuilder tmp = new StringBuilder(str.length()+1);
+    public static String extract(Character startend, String str) {
+        StringBuilder tmp = new StringBuilder(str.length() + 1);
         boolean start_end = false;
-        for(Character c : str.toCharArray())
-        {
-            if(!start_end && c.equals(startend))
-            {
+        for (Character c : str.toCharArray()) {
+            if (!start_end && c.equals(startend)) {
                 start_end = true;
-            }
-            else if(start_end && c.equals(startend))
-            {
+            } else if (start_end && c.equals(startend)) {
                 return tmp.toString();
-            }
-            else if(start_end)
-            {
+            } else if (start_end) {
                 tmp.append(c);
             }
         }
@@ -322,11 +263,10 @@
         //System.out.println(beforeChar("11..**",'.'));
         //System.out.println(afterChar("11..**",'.'));
         //System.out.println(afterChar("java.lang.String",'.'));
-        List<String> test = charParseIgnore("Map<String,String,String>",',','<','>');
-        for(String str : test)
-        {
+        List<String> test = charParseIgnore("Map<String,String,String>", ',', '<', '>');
+        for (String str : test) {
             System.out.println(str);
         }
-        System.out.println(extract('<','>',"<<<>>>"));
+        System.out.println(extract('<', '>', "<<<>>>"));
     }
 }

    

[Eugene-commits] r1272 - trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml

agiraudet＠users.nuiton.org