r1273 - trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml - Eugene-commits

11 Jun 2013

Author: agiraudet
Date: 2013-06-11 14:25:25 +0200 (Tue, 11 Jun 2013)
New Revision: 1273

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

Log:
suppression des classes Deprecated de org.nuiton.eugene.models.object.reader.yaml.*

Removed:
   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/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/YamlToObjectModel.java

Deleted: 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 12:16:35 UTC (rev 1272)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/Parser.java	2013-06-11 12:25:25 UTC (rev 1273)
@@ -1,1010 +0,0 @@
-package org.nuiton.eugene.models.object.reader.yaml;
-
-import java.io.FileWriter;
-import java.io.IOException;
-import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-
-/**
- * User: agiraudet
- * Date: 03/06/13
- * Time: 09:56
- */
-
-/**
- * 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)
- */
-@Deprecated
-public class Parser extends KeyWords {
-
-    private static boolean _loginit = true;
-
-    private static void log(String str) {
-        try {
-            FileWriter log;
-            String path = "/tmp/log.parser.txt";
-
-            if (_loginit) {
-                log = new FileWriter(path, false);
-                log.close();
-                _loginit = false;
-            }
-            log = new FileWriter(path, true);
-            log.write("[LOG] " + str + "\n");
-            log.close();
-        } catch (IOException e) {
-            ;
-        }
-    }
-
-    public Parser() {
-        ;
-    }
-
-    //TODO: ajouter le nom des Objects aux imports ! lors du parsage (imports internes)
-    //TODO: ajouter "imports" Map.Entity<Strign,List<String>>
-    //TODO: resoudre labels avant imports
-    //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) {
-                    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(NAME)) {
-                        modelYAMLO.addStringToMap(NAME, 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));
-                            }
-                        }
-                    }
-
-                    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)) {
-                        YamlObject associationClassYAMLO = new YamlObject();
-                        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);
-                    }
-                }
-            }
-        }
-        return modelYAMLO;
-    }
-
-    //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)) {
-            classPARSE.remove(classPARSE.indexOf(CLASS));
-        }
-        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));
-            classPARSE.remove(classPARSE.indexOf(STATIC));
-        }
-        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));
-            classPARSE.remove(classPARSE.indexOf(INNER));
-        }
-        if (classPARSE.contains(PUBLIC)) {
-            classYAMLO.addStringToMap(VISIBILITY, PUBLIC);
-            classPARSE.remove(classPARSE.indexOf(PUBLIC));
-        } else if (classPARSE.contains(PRIVATE)) {
-            classYAMLO.addStringToMap(VISIBILITY, PRIVATE);
-            classPARSE.remove(classPARSE.indexOf(PRIVATE));
-        } else if (classPARSE.contains(PROTECTED)) {
-            classYAMLO.addStringToMap(VISIBILITY, PROTECTED);
-            classPARSE.remove(classPARSE.indexOf(PROTECTED));
-        }
-
-        for (String tmp1 : classPARSE) {
-            if (tmp1.contains("<<") && tmp1.contains(">>")) {
-                List<Character> targets = new LinkedList<Character>();
-                targets.add('<');
-                targets.add('>');
-                String tmp2 = YamlUtil.removeMultiChar(tmp1, targets);
-                targets = new LinkedList<Character>();
-                targets.add(' ');
-                targets.add(',');
-                List<String> tmp3 = YamlUtil.multiCharParse(tmp2, targets);
-                for (String tmp4 : tmp3) {
-                    classYAMLO.addStringToMap(STEREOTYPES, tmp4);
-                    log("stereotype=" + tmp4);
-                }
-            }
-        }
-        if (classPARSE.size() > 0)//prend compte de l'ordre : nom avant stereotypes
-        {
-            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) {
-                    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) {
-                                //TODO: superClasses sur une ligne
-                                classYAMLO.addStringToMap(SUPER_CLASSES, String.valueOf(superClass));
-                            }
-                        }
-                    } 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));
-                            }
-                        }
-                    } else {
-                        if (keyP.contains("(") && keyP.contains(")")) {
-                            YamlObject operationYAMLO = new YamlObject();
-                            parseOperation(keyP, valueP, operationYAMLO);
-                            classYAMLO.addYamlObjectToMap(OPERATION, operationYAMLO);
-                        } else {
-                            YamlObject attributeYAMLO = new YamlObject();
-                            parseAttribute(keyP, valueP, attributeYAMLO);
-                            classYAMLO.addYamlObjectToMap(ATTRIBUTE, attributeYAMLO);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    public void parseInterface(String key, Object value, YamlObject interfaceYAMLO)//enlever superflu
-    {
-        List<String> classPARSE = YamlUtil.charParseIgnore(key, ' ', '<', '>');
-        if (classPARSE.contains(INTERFACE)) {
-            classPARSE.remove(classPARSE.indexOf(INTERFACE));
-        }
-        if (classPARSE.contains(ABSTRACT)) {
-            interfaceYAMLO.addStringToMap(ABSTRACT, String.valueOf(true));
-            classPARSE.remove(classPARSE.indexOf(ABSTRACT));
-        }
-        if (classPARSE.contains(STATIC)) {
-            interfaceYAMLO.addStringToMap(STATIC, String.valueOf(true));
-            classPARSE.remove(classPARSE.indexOf(STATIC));
-        }
-        if (classPARSE.contains(EXTERN)) {
-            interfaceYAMLO.addStringToMap(EXTERN, String.valueOf(true));
-            classPARSE.remove(classPARSE.indexOf(EXTERN));
-        }
-        if (classPARSE.contains(INNER)) {
-            interfaceYAMLO.addStringToMap(INNER, String.valueOf(true));
-            classPARSE.remove(classPARSE.indexOf(INNER));
-        }
-        if (classPARSE.contains(PUBLIC)) {
-            interfaceYAMLO.addStringToMap(VISIBILITY, PUBLIC);
-            classPARSE.remove(classPARSE.indexOf(PUBLIC));
-        } else if (classPARSE.contains(PRIVATE)) {
-            interfaceYAMLO.addStringToMap(VISIBILITY, PRIVATE);
-            classPARSE.remove(classPARSE.indexOf(PRIVATE));
-        } else if (classPARSE.contains(PROTECTED)) {
-            interfaceYAMLO.addStringToMap(VISIBILITY, PROTECTED);
-            classPARSE.remove(classPARSE.indexOf(PROTECTED));
-        }
-
-        for (String tmp1 : classPARSE) {
-            if (tmp1.contains("<<") && tmp1.contains(">>")) {
-                List<Character> targets = new LinkedList<Character>();
-                targets.add('<');
-                targets.add('>');
-                String tmp2 = YamlUtil.removeMultiChar(tmp1, targets);
-                targets = new LinkedList<Character>();
-                targets.add(' ');
-                targets.add(',');
-                List<String> tmp3 = YamlUtil.multiCharParse(tmp2, targets);
-                for (String tmp4 : tmp3) {
-                    interfaceYAMLO.addStringToMap(STEREOTYPES, tmp4);
-                    log("stereotype=" + tmp4);
-                }
-            }
-        }
-        if (classPARSE.size() > 0)//prend compte de l'ordre : nom avant stereotypes
-        {
-            interfaceYAMLO.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) {
-                    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) {
-                                //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) {
-                                //TODO: superInterfaces sur une ligne
-                                interfaceYAMLO.addStringToMap(SUPER_INTERFACES, String.valueOf(superInterface));
-                            }
-                        }
-                    } else {
-                        if (keyP.contains("(") && keyP.contains(")")) {
-                            YamlObject operationYAMLO = new YamlObject();
-                            parseOperation(keyP, valueP, operationYAMLO);
-                            interfaceYAMLO.addYamlObjectToMap(OPERATION, operationYAMLO);
-                        } else {
-                            YamlObject attributeYAMLO = new YamlObject();
-                            parseAttribute(keyP, valueP, attributeYAMLO);
-                            interfaceYAMLO.addYamlObjectToMap(ATTRIBUTE, attributeYAMLO);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    //
-    public void parseAssociationClass(String key, Object value, YamlObject associationClassYAMLO)//declarer participant attribut ?
-    {
-        //
-
-        /*
-        FACTORISER LE CODE !
-         */
-        List<String> classPARSE = YamlUtil.charParseIgnore(key, ' ', '<', '>');
-        if (classPARSE.contains(ASSOCIATION_CLASS)) {
-            classPARSE.remove(classPARSE.indexOf(ASSOCIATION_CLASS));
-        }
-        if (classPARSE.contains(ABSTRACT)) {
-            associationClassYAMLO.addStringToMap(ABSTRACT, String.valueOf(true));
-            classPARSE.remove(classPARSE.indexOf(ABSTRACT));
-        }
-        if (classPARSE.contains(STATIC)) {
-            associationClassYAMLO.addStringToMap(STATIC, String.valueOf(true));
-            classPARSE.remove(classPARSE.indexOf(STATIC));
-        }
-        if (classPARSE.contains(EXTERN)) {
-            associationClassYAMLO.addStringToMap(EXTERN, String.valueOf(true));
-            classPARSE.remove(classPARSE.indexOf(EXTERN));
-        }
-        if (classPARSE.contains(INNER)) {
-            associationClassYAMLO.addStringToMap(INNER, String.valueOf(true));
-            classPARSE.remove(classPARSE.indexOf(INNER));
-        }
-        if (classPARSE.contains(PUBLIC)) {
-            associationClassYAMLO.addStringToMap(VISIBILITY, PUBLIC);
-            classPARSE.remove(classPARSE.indexOf(PUBLIC));
-        } else if (classPARSE.contains(PRIVATE)) {
-            associationClassYAMLO.addStringToMap(VISIBILITY, PRIVATE);
-            classPARSE.remove(classPARSE.indexOf(PRIVATE));
-        } else if (classPARSE.contains(PROTECTED)) {
-            associationClassYAMLO.addStringToMap(VISIBILITY, PROTECTED);
-            classPARSE.remove(classPARSE.indexOf(PROTECTED));
-        }
-
-        for (String tmp1 : classPARSE) {
-            if (tmp1.contains("<<") && tmp1.contains(">>")) {
-                List<Character> targets = new LinkedList<Character>();
-                targets.add('<');
-                targets.add('>');
-                String tmp2 = YamlUtil.removeMultiChar(tmp1, targets);
-                targets = new LinkedList<Character>();
-                targets.add(' ');
-                targets.add(',');
-                List<String> tmp3 = YamlUtil.multiCharParse(tmp2, targets);
-                for (String tmp4 : tmp3) {
-                    associationClassYAMLO.addStringToMap(STEREOTYPES, tmp4);
-                    log("stereotype=" + tmp4);
-                }
-            }
-        }
-        if (classPARSE.size() > 0)//prend compte de l'ordre : nom avant stereotypes
-        {
-            associationClassYAMLO.addStringToMap(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) {
-                            //name attribute "value":
-
-                            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()));
-
-                                participantYAMLO.addStringToMap(LABEL, label);
-
-                                participantPARSE.remove("\"" + YamlUtil.extract('"', String.valueOf(((Map.Entry) entry).getKey())) + "\"");
-                            }
-
-                            if (participantPARSE.size() > 0)//ajout type
-                            {
-                                participantYAMLO.addStringToMap(NAME, participantPARSE.get(0));
-                            }
-                            if (participantPARSE.size() > 1)//ajout name
-                            {
-                                participantYAMLO.addStringToMap(ATTRIBUTE, participantPARSE.get(1));
-                            }
-                            associationClassYAMLO.addYamlObjectToMap(PARTICIPANT, participantYAMLO);
-
-                            /*YamlObject participantYAMLO = new YamlObject();
-                            participantYAMLO.addStringToMap(NAME, String.valueOf(((Map.Entry) entry).getKey()));
-                            if(((Map.Entry) entry).getValue() != null)
-                            {
-                                participantYAMLO.addStringToMap(ATTRIBUTE,String.valueOf(((Map.Entry) entry).getValue()));
-                            }
-                            associationClassYAMLO.addYamlObjectToMap(PARTICIPANT,participantYAMLO);*/
-                        }
-                    }
-                }
-                ((Map) value).remove(PARTICIPANT);
-            }
-        }
-        //participant
-
-        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) {
-                                //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) {
-                                //TODO: superInterfaces sur une ligne
-                                associationClassYAMLO.addStringToMap(SUPER_INTERFACES, String.valueOf(superInterface));
-                            }
-                        }
-                    } else {
-                        if (keyP.contains("(") && keyP.contains(")")) {
-                            YamlObject operationYAMLO = new YamlObject();
-                            parseOperation(keyP, valueP, operationYAMLO);
-                            associationClassYAMLO.addYamlObjectToMap(OPERATION, operationYAMLO);
-                        } else {
-                            YamlObject attributeYAMLO = new YamlObject();
-                            parseAttribute(keyP, valueP, attributeYAMLO);
-                            associationClassYAMLO.addYamlObjectToMap(ATTRIBUTE, attributeYAMLO);
-                        }
-                    }
-                }
-            }
-        }
-        /*
-        FACTORISER LE CODE !
-         */
-    }
-
-    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));
-            enumerationPARSE.remove(enumerationPARSE.indexOf(STATIC));
-        }
-
-        for (String tmp1 : enumerationPARSE) {
-            if (tmp1.contains("<<") && tmp1.contains(">>")) {
-                List<Character> targets = new LinkedList<Character>();
-                targets.add('<');
-                targets.add('>');
-                String tmp2 = YamlUtil.removeMultiChar(tmp1, targets);
-                targets = new LinkedList<Character>();
-                targets.add(' ');
-                targets.add(',');
-                List<String> tmp3 = YamlUtil.multiCharParse(tmp2, targets);
-                for (String tmp4 : tmp3) {
-                    enumerationYAMLO.addStringToMap(STEREOTYPES, tmp4);
-                    log("stereotype=" + tmp4);
-                }
-            }
-        }
-        if (enumerationPARSE.size() > 0)//prend compte de l'ordre : nom avant stereotypes
-        {
-            enumerationYAMLO.addStringToMap(NAME, enumerationPARSE.get(0));
-            log("name=" + enumerationPARSE.get(0));
-        }
-
-
-        ;//literal
-    }
-
-    //~ok, fonctionnel
-    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));
-            attributePARSE.remove(attributePARSE.indexOf(STATIC));
-        }
-        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));
-            attributePARSE.remove(attributePARSE.indexOf(UNIQUE));
-        }
-        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));
-            attributePARSE.remove(attributePARSE.indexOf(TRANSIENT));
-        }
-        if (attributePARSE.contains(PUBLIC)) {
-            attributeYAMLO.addStringToMap(VISIBILITY, PUBLIC);
-            attributePARSE.remove(attributePARSE.indexOf(PUBLIC));
-        } else if (attributePARSE.contains(PROTECTED)) {
-            attributeYAMLO.addStringToMap(VISIBILITY, PROTECTED);
-            attributePARSE.remove(attributePARSE.indexOf(PUBLIC));
-        } else if (attributePARSE.contains(PRIVATE)) {
-            attributeYAMLO.addStringToMap(VISIBILITY, PRIVATE);
-            attributePARSE.remove(attributePARSE.indexOf(PUBLIC));
-        }
-
-        if (attributePARSE.contains(ORDERED)) {
-            attributeYAMLO.addStringToMap(ORDERING, ORDERED);
-            attributePARSE.remove(attributePARSE.indexOf(ORDERED));
-        } 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 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("*")) {
-                    min = "-1";
-                }
-                if (max.equals("*")) {
-                    max = "-1";
-                }
-                attributeYAMLO.addStringToMap(MIN_MULTIPLICITY, min);
-                attributeYAMLO.addStringToMap(MAX_MULTIPLICITY, max);
-            }
-            attributePARSE.remove("[" + YamlUtil.extract('[', ']', key) + "]");
-        }
-
-        //extraire directement car pas de suppression
-        /*for(String tmp1 : attributePARSE)
-        {
-            log("tmp1="+tmp1);
-            if(tmp1.contains("\""))//tester deux occurrences ?//remplacer label par reverseMultiplicity si lien unidirectionnel
-            {
-                String label = YamlUtil.extract('"',tmp1);
-                attributeYAMLO.addStringToMap(LABEL,label);
-                //attributePARSE.remove(tmp1);
-                log("label="+label);
-            }
-            else if(tmp1.contains("[") && tmp1.contains("]"))
-            {
-                String multiplicity = YamlUtil.extract('[',']',tmp1);
-                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("*"))
-                    {
-                        min = "-1";
-                    }
-                    if(max.equals("*"))
-                    {
-                        max = "-1";
-                    }
-                    attributeYAMLO.addStringToMap(MIN_MULTIPLICITY,min);
-                    attributeYAMLO.addStringToMap(MAX_MULTIPLICITY,max);
-                }
-                //attributePARSE.remove(tmp1);
-            }
-        }*/
-        //name: type ?
-        if (attributePARSE.size() > 0)//ajout type
-        {
-            attributeYAMLO.addStringToMap(TYPE, attributePARSE.get(0));
-        }
-        if (attributePARSE.size() > 1)//ajout name
-        {
-            attributeYAMLO.addStringToMap(NAME, attributePARSE.get(1));
-        }
-
-        /*if(value != null)//defaultValue
-        {
-            //attributeYAMLO.addStringToMap(DEFAULT_VALUE,String.valueOf(value));
-            attributeYAMLO.addStringToMap(TYPE,String.valueOf(value));
-        }*/
-
-        //on parcours le reste on recherche les [] (multiplicity) et les "" (label)
-
-    }
-
-    //OK, fonctionnel : yeah ninja flex
-    //TODO: return Parameter après les : (value) ? name: value
-    public void parseOperation(String key, Object value, YamlObject operationYAMLO) {
-        log("operation=" + key);
-        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);
-
-        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));
-            operationPARSE.remove(operationPARSE.indexOf(ABSTRACT));
-        }
-        if (operationPARSE.contains(PUBLIC)) {
-            operationYAMLO.addStringToMap(VISIBILITY, PUBLIC);
-            operationPARSE.remove(operationPARSE.indexOf(PUBLIC));
-        } else if (operationPARSE.contains(PROTECTED)) {
-            operationYAMLO.addStringToMap(VISIBILITY, PROTECTED);
-            operationPARSE.remove(operationPARSE.indexOf(PROTECTED));
-        } 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) {
-                        YamlObject parameterYAMLO = new YamlObject();
-                        parameterYAMLO.addStringToMap(TYPE, tmp2.get(0));
-                        parameterYAMLO.addStringToMap(NAME, tmp2.get(1));
-                        operationYAMLO.addYamlObjectToMap(PARAMETER, parameterYAMLO);
-                    }
-                }
-                //operationPARSE.remove(tmp);
-            }
-        }
-
-        /*if(operationPARSE.size() > 1)
-        {
-            YamlObject returnParameterYAMLO = new YamlObject();
-            returnParameterYAMLO.addStringToMap(TYPE,operationPARSE.get(0));
-            operationYAMLO.addYamlObjectToMap(RETURN_PARAMETER,returnParameterYAMLO);
-        }*/
-
-        if (value != null) {
-            YamlObject returnParameterYAMLO = new YamlObject();
-            returnParameterYAMLO.addStringToMap(TYPE, String.valueOf(value));
-            operationYAMLO.addYamlObjectToMap(RETURN_PARAMETER, returnParameterYAMLO);
-        }
-    }
-
-    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);
-            }
-        }
-        //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)) {
-            packageM = modelYAMLO.getFirstMapStringListString(PACKAGE);
-        }
-        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);
-                    } else if (packageM != null) {
-                        imports.put(name, packageM + "." + name);
-                    }
-                }
-            }
-        }
-        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));
-                        }
-                    }
-                }
-                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)) {
-                    log("   contains attributes");
-                    for (YamlObject attributeYAMLO : importable.getMapStringListYamlObject(ATTRIBUTE)) {
-                        log("       browse attributes");
-                        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));
-                                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(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));
-
-                                    }
-                                }
-                            }
-                        }
-                        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));
-
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                if (importable.containsKeyYamlMapStringListYamlObject(PARTICIPANT)) {
-                    log("0");
-                    for (YamlObject participantYAMLO : importable.getMapStringListYamlObject(PARTICIPANT)) {
-                        log("1");
-                        if (participantYAMLO.containsKeyMapStringListString(NAME)) {
-                            log("2");
-                            participantYAMLO.setMapStringListString(NAME, participantYAMLO.getFirstMapStringListString(NAME), resolveType(participantYAMLO.getFirstMapStringListString(NAME), imports));
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    //OK
-    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<>
-            {
-                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);
-                }
-                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();
-            /*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) {
-        List<Character> ignore = new LinkedList<Character>();
-        ignore.add(' ');
-        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>();
-        String packageM = null;
-        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)) {
-                    String name = importable.getFirstMapStringListString(NAME);
-                    if (importable.containsKeyMapStringListString(PACKAGE)) {
-                        imports.put(name, importable.getFirstMapStringListString(PACKAGE) + "." + name);
-                    } else if (packageM != null) {
-                        imports.put(name, packageM + "." + name);
-                    }
-                }
-            }
-        }
-        //test
-
-
-        List<String> importsI = new LinkedList<String>();
-        //String packageM = null;
-        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)) {
-                    String name = importable.getFirstMapStringListString(NAME);
-                    if (importable.containsKeyMapStringListString(PACKAGE)) {
-                        importsI.add(importable.getFirstMapStringListString(PACKAGE) + "." + name);
-                    } else if (packageM != null) {
-                        importsI.add(packageM + "." + name);
-                    }
-                }
-            }
-        }
-
-        //recuperer imports internes
-        //if reference class interne et navigable (ou ! navigable=false)
-        //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)) {
-                            String type = attribute.getFirstMapStringListString(TYPE);
-                            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)
-                                    {
-                                        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));
-                                            }
-                                            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 (reverseAttribute.containsKeyMapStringListString(NAME)) {
-                                                attribute.addStringToMap(REVERSE_ATTRIBUTE_NAME, reverseAttribute.getFirstMapStringListString(NAME));
-                                            }
-                                        }
-                                    } else//unidirectionnel
-                                    {
-                                        log("unidirectionnel");
-                                        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));
-                                            }
-                                            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);
-                                                } else if (attribute.getFirstMapStringListString(ORDERING).equals(UNORDERED)) {
-                                                    reverseAttribute.addStringToMap(ORDERING, ORDERED);
-                                                }
-                                            }
-                                            //test
-                                            reverseObject.addYamlObjectToMap(ATTRIBUTE, reverseAttribute);
-
-                                            attribute.addStringToMap(NAVIGABLE, String.valueOf(true));
-                                        }
-                                    }
-                                }
-                            } else//simple attribut
-                            {
-                                ;//ou gerer par valeurs par defaut ?
-                                //associationType="composite"//default eugene
-                                //minMultiplicity="1"//default eugene
-                                //maxMultiplicity="1"//default eugene
-                            }
-                        }
-                    }
-                }
-                if (labelisable.containsKeyYamlMapStringListYamlObject(PARTICIPANT)) {
-                    log("0");
-                    for (YamlObject participant : labelisable.getMapStringListYamlObject(PARTICIPANT)) {
-                        if (participant.containsKeyMapStringListString(NAME)) {
-                            log("1");
-                            String name = participant.getFirstMapStringListString(NAME);
-                            if (importsI.contains(name))//refClassifier
-                            {
-                                log("2");
-                                if (participant.containsKeyMapStringListString(LABEL)) {
-                                    log("3");
-                                    String label = participant.getFirstMapStringListString(LABEL);
-                                    YamlObject reverseAttribute = getReverseAttribute(modelYAMLO, YamlUtil.afterChar(name, '.'), label);
-                                    if (reverseAttribute != null) {
-                                        log("4");
-                                        if (labelisable.containsKeyMapStringListString(NAME)) {
-                                            log("5");
-                                            //tester package
-                                            reverseAttribute.addStringToMap(ASSOCIATION_CLASS_NAME, modelYAMLO.getFirstMapStringListString(PACKAGE) + "." + labelisable.getFirstMapStringListString(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)) {
-                                    String reverseLabel = attributeYAMLO.getFirstMapStringListString(LABEL);
-                                    if (reverseLabel.equals(label)) {
-                                        return attributeYAMLO;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        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)) {
-                    String name = objectYAMLO.getFirstMapStringListString(NAME);
-                    if (name.equals(type)) {
-                        return objectYAMLO;
-                    }
-                }
-            }
-        }
-        return null;
-    }
-
-    public static void main(String[] args) {
-        /*Map<String,String> imports = new LinkedHashMap<String, String>();
-        imports.put("String","java.lang.String");
-        imports.put("List","java.util.List");
-        imports.put("Map","java.util.Map");
-        String type = "Map<List<String>,List<String>>";
-        System.out.println(resolveType(type,imports));*/
-        /*List<String> test = new LinkedList<String>();
-        test.add("test1");
-        test.add("test2");
-        test.add("\"test3\"");
-        test.remove(test.indexOf("test2"));
-        for(String str : test)
-        {
-            System.out.println(str);
-        }*/
-    }
-}

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

Deleted: 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 12:16:35 UTC (rev 1272)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadYamlFile.java	2013-06-11 12:25:25 UTC (rev 1273)
@@ -1,105 +0,0 @@
-package org.nuiton.eugene.models.object.reader.yaml;
-
-import org.nuiton.eugene.models.object.ObjectModel;
-import org.nuiton.eugene.models.object.xml.ObjectModelImpl;
-import org.yaml.snakeyaml.Yaml;
-
-import java.io.*;
-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
- */
-@Deprecated
-public class TestLoadYamlFile extends KeyWords {
-    Yaml yaml;
-    ObjectModelImpl modelOM;
-    YamlObject modelYAMLO;
-    Object modelYAML;
-    String syntaxeVersion;//version de la synatxe
-    String defaultVersion;//version des valeurs par defaut
-
-    private boolean _loginit = true;
-
-    private void log(String str) {
-        try {
-            FileWriter log;
-            String path = "/tmp/log.loadfile.txt";
-
-            if (_loginit) {
-                log = new FileWriter(path, false);
-                log.close();
-                _loginit = false;
-            }
-            log = new FileWriter(path, true);
-            log.write("[LOG] " + str + "\n");
-            log.close();
-        } catch (IOException e) {
-            ;
-        }
-    }
-
-    public TestLoadYamlFile() {
-        yaml = new Yaml();
-    }
-
-    public void LoadYamlFile(File fileYAML, ObjectModel model) throws IOException {
-        modelOM = (ObjectModelImpl) model;
-        modelYAMLO = new YamlObject();
-        InputStream inputModel = new FileInputStream(fileYAML);
-        modelYAML = yaml.load(inputModel);
-        inputModel.close();
-
-        //chercher version et charger en conséquent
-        Object version = null;
-        if (modelYAML instanceof List) {
-            version = YamlUtil.collectElementList((List) modelYAML, SYNTAXE);
-            syntaxeVersion = "1";
-            defaultVersion = "0";
-            log("modelYAML instanceof List");
-        }
-        if (modelYAML instanceof Map) {
-            version = YamlUtil.collectElementMap((Map) modelYAML, SYNTAXE);
-            syntaxeVersion = "2";
-            defaultVersion = "0";
-            log("modelYAML instanceof Map");
-        } 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 (syntaxeVersion.equals("1")) {
-            SyntaxePureYaml.loadYamlObject(modelYAML, modelYAMLO);
-            log("load SyntaxePureYaml");
-        } 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 {
-            ;//syntaxe par defaut, si version syntaxe non reconnue
-            SyntaxePureYaml.loadYamlObject(modelYAML, modelYAMLO);
-        }
-
-        TestLoadObjectModel test = new TestLoadObjectModel();
-        test.loadModel(modelYAMLO, modelOM);
-        log("END");
-        //TODO: charger ObjectModel avec les valeurs par defaut en fonction de la version (ajouter parametre à loadModel)
-    }
-}

Deleted: 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 12:16:35 UTC (rev 1272)
+++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlToObjectModel.java	2013-06-11 12:25:25 UTC (rev 1273)
@@ -1,670 +0,0 @@
-package org.nuiton.eugene.models.object.reader.yaml;
-
-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.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;
-
-/**
- * User: agiraudet
- * Date: 15/05/13
- * Time: 11:15
- */
-@Deprecated
-public class YamlToObjectModel {
-    protected Yaml yaml;
-    protected String packageOM;
-    protected Map<String, String> imports;
-    protected Map<String, String> defaultValues;
-
-    //mots clefs
-    public static final String ABSTRACT = "abstract";
-    public static final String ASSOCIATION_CLASS_NAME = "associationclassname";
-    public static final String ASSOCIATION_TYPE = "associationtype";
-    public static final String ATTRIBUTE = "attribute";
-    public static final String BODY_CODE = "bodeycode";
-    public static final String CLASS = "class";
-    public static final String CLASS_ASSOCIATION = "associationclass";
-    public static final String COMMENTS = "comments";
-    public static final String DEFAULT_VALUE = "defaultvalue";
-    public static final String DOCUMENTATION = "documentation";
-    public static final String ENUMERATION = "enumeration";
-    public static final String EXTERN = "extern";
-    public static final String FINAL = "final";
-    public static final String IMPORTS = "imports";
-    public static final String INNER = "inner";
-    public static final String INTERFACE = "interface";
-    public static final String LITERAL = "literal";
-    public static final String MAX_MULTIPLICITY = "maxmultiplicity";
-    public static final String MIN_MULTIPLICITY = "minmultiplicity";
-    public static final String NAME = "name";
-    public static final String NAVIGABLE = "navigable";
-    public static final String OPERATION = "operation";
-    public static final String ORDERED = "ordered";
-    public static final String ORDERING = "ordering";
-    public static final String PACKAGE = "package";
-    public static final String PARAMETER = "parameter";
-    public static final String PARTICIPANT = "participant";
-    public static final String RETURN_PARAMETER = "returnparameter";
-    public static final String REVERSE_ATTRIBUTE_NAME = "reverseattributename";
-    public static final String REVERSE_MAX_MULTIPLICITY = "reversemaxmultiplicity";
-    public static final String STATIC = "static";
-    public static final String STEREOTYPES = "stereotypes";
-    public static final String SUPER_CLASSES = "superclasses";
-    public static final String SUPER_INTERFACES = "superinterfaces";
-    public static final String TAG_VALUES = "tagvalues";
-    public static final String TRANSIENT = "transient";
-    public static final String TYPE = "type";
-    public static final String UNIQUE = "unique";
-    public static final String VERSION = "version";
-    public static final String VISIBILITY = "visibility";
-    public static final String ELEMENT = "element";
-
-    private boolean _loginit = true;
-
-    private void log(String str) {
-        try {
-            FileWriter log;
-            String path = "/tmp/log.yaml.txt";
-
-            if (_loginit) {
-                log = new FileWriter(path, false);
-                log.close();
-                _loginit = false;
-            }
-            log = new FileWriter(path, true);
-            log.write("[LOG] " + str + "\n");
-            log.close();
-        } catch (IOException e) {
-            ;
-        }
-    }
-
-    public YamlToObjectModel() {
-        yaml = new Yaml();
-    }
-
-    //TODO: gestion des labels ? -> non pas pour le moment (plutot pour la syntaxe "user friendly")
-    //TODO: retourner boolean sur reussite chargement ? ou lever excpetions ? -> aucun des deux pour le moment
-    //TODO: charger valeurs par defaut en fonction de la version de la syntaxe yaml (syntaxe: version), charger les valeurs à partir d'un fichier ou d'une classe ? -> a partir d'un fichier YAML
-    //TODO: mettre les valeurs par défaut en dur dans le code
-    //TODOK: gérer les imports sous forme de List et récuperer le type
-    //TODO: pre-charger les noms et paquetages des classes pour les imports
-    //TODO: 1/ instancier les objets et les attributs de niveau 1 (name, package...) (et charger les imports vers les classes du modele) 2/ charger les objets de niveau 2 (attributes, operations...)
-    /*
-     * nouvelle implémentation : contraintes : labels, valeurs par défaut, parser des chaines (imports internes/externes)
-     *
-     */
-    //http://demo.codelutin.com/pollen/poll/summary/23f361a09411482eb6be219ddf4ab5...
-    public void loadFile(File file, ObjectModel model) throws IOException {
-        //TODO: valeurs par defaut, faire interface ? ou simple map ? + mots clefs ?
-        defaultValues = new LinkedHashMap<String, String>();
-
-        ObjectModelImpl modelOM = (ObjectModelImpl) model;
-        InputStream inputModel = new FileInputStream(file);
-        Object modelYAML = yaml.load(inputModel);
-        inputModel.close();
-
-        List<String> ignore = new LinkedList<String>();
-        ignore.add(TAG_VALUES);
-        browseKeySetToLowerCase(modelYAML, ignore);
-
-        loadModel(modelYAML, modelOM);
-    }
-
-    public Object collectElement(List data, Object key) {
-        for (Object obj : data) {
-            if (obj instanceof Map) {
-                if (((Map) obj).containsKey(key)) {
-                    return ((Map) obj).get(key);
-                }
-            }
-        }
-        return null;
-    }
-
-    public List<Object> collectAllElements(List data, Object key) {
-        List<Object> res = new LinkedList<Object>();
-        for (Object obj : data) {
-            if (obj instanceof Map) {
-                if (((Map) obj).containsKey(key)) {
-                    res.add(((Map) obj).get(key));
-                }
-            }
-        }
-        return res;
-    }
-
-    public void loadModel(Object modelYAML, ObjectModelImpl modelOM) {
-        if (modelYAML instanceof List) {
-            //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));
-                }
-            }
-
-            //load package
-            Object packageYAML = collectElement((List) modelYAML, PACKAGE);
-            if (packageYAML == null) {
-                packageOM = "";
-            } else {
-                packageOM = String.valueOf(packageYAML);
-            }
-            log("package=" + packageOM);
-
-            Object nameYAML = collectElement((List) modelYAML, NAME);
-            if (nameYAML == null) {
-                ;
-            } else {
-                modelOM.setName(String.valueOf(nameYAML));
-                log("name=" + String.valueOf(nameYAML));
-            }
-
-            Object versionYAML = collectElement((List) modelYAML, VERSION);
-            if (versionYAML == null) {
-                ;
-            } else {
-                modelOM.setVersion(String.valueOf(versionYAML));
-                log("version=" + String.valueOf(versionYAML));
-            }
-
-            Object tagValuesYAML = collectElement((List) modelYAML, TAG_VALUES);
-            if (tagValuesYAML instanceof Map) {
-                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()) + "]");
-                    }
-                }
-            }
-
-            /*//test imports objets modele
-            /*List<Object> objectsYAML = collectAllElements((List) modelYAML, CLASS);
-            objectsYAML.addAll(collectAllElements((List) modelYAML, INTERFACE));
-            objectsYAML.addAll(collectAllElements((List) modelYAML, CLASS_ASSOCIATION));
-            objectsYAML.addAll(collectAllElements((List) modelYAML, ENUMERATION));
-            for(Object objectYAML : objectsYAML)
-            {
-                if(objectYAML instanceof List)
-                {
-                    Object importNameYAML = collectElement((List) objectYAML, NAME);
-                    //Object importPackageYAML = collectElement((List) objectYAML, PACKAGE);
-                    imports.put(String.valueOf(importNameYAML),packageOM+"."+String.valueOf(importNameYAML));
-                    log("import="+imports.get(String.valueOf(importNameYAML)));
-                    log(imports.toString());
-                }
-            }
-            *///test imports objets modele
-
-            List classesYAML = collectAllElements((List) modelYAML, CLASS);
-            for (Object classYAML : classesYAML) {
-                ObjectModelClassImpl classOM = new ObjectModelClassImpl();
-                loadClass(classYAML, classOM);
-                modelOM.addClass(classOM);
-                log("class=" + classOM.getName() + " loaded");
-            }
-
-            List interfacesYAML = collectAllElements((List) modelYAML, INTERFACE);
-            for (Object interfaceYAML : interfacesYAML) {
-                ObjectModelInterfaceImpl interfaceOM = new ObjectModelInterfaceImpl();
-                loadInterface(interfaceYAML, interfaceOM);
-                modelOM.addInterface(interfaceOM);
-                log("interface=" + interfaceOM.getName() + " loaded");
-            }
-
-            List classesAssociationYAML = collectAllElements((List) modelYAML, CLASS_ASSOCIATION);
-            for (Object classAssociationYAML : classesAssociationYAML) {
-                ObjectModelAssociationClassImpl classAssociationOM = new ObjectModelAssociationClassImpl();
-                loadAssociationClass(classAssociationYAML, classAssociationOM);
-                modelOM.addAssociationClass(classAssociationOM);
-                log("classAssociation=" + classAssociationOM.getName() + " loaded");
-            }
-
-            List enumerationsYAML = collectAllElements((List) modelYAML, ENUMERATION);
-            for (Object enumerationYAML : enumerationsYAML) {
-                ObjectModelEnumerationImpl enumerationOM = new ObjectModelEnumerationImpl();
-                loadEnumeration(enumerationYAML, enumerationOM);
-                modelOM.addEnumeration(enumerationOM);
-                log("enumeration=" + enumerationOM.getName() + " loaded");
-            }
-        }
-    }
-
-    public void loadElement(Object elementYAML, ObjectModelElementImpl elementOM) {
-        if (elementYAML instanceof List) {
-            //TODO: setDeclaringElement
-            //TODO: setObjectModelImpl
-            //TODO: addModifier
-
-            Object nameYAML = collectElement((List) elementYAML, NAME);
-            if (nameYAML == null) {
-                ;
-            } else {
-                elementOM.setName(String.valueOf(nameYAML));
-                log("name=" + String.valueOf(nameYAML));
-            }
-
-            Object staticYAML = collectElement((List) elementYAML, STATIC);
-            if (staticYAML == null) {
-                ;
-            } else {
-                elementOM.setStatic(Boolean.valueOf(String.valueOf(staticYAML)));
-                log("static=" + (Boolean.valueOf(String.valueOf(staticYAML))));
-            }
-
-            Object documentationYAML = collectElement((List) elementYAML, DOCUMENTATION);
-            if (documentationYAML == null) {
-                ;
-            } else {
-                elementOM.setDocumentation(String.valueOf(documentationYAML));
-                log("documentation=" + String.valueOf(documentationYAML));
-            }
-
-            Object tagValuesYAML = collectElement((List) elementYAML, TAG_VALUES);
-            if (tagValuesYAML instanceof Map) {
-                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()) + "]");
-                    }
-                }
-            }
-
-            Object commentsYAML = collectElement((List) elementYAML, COMMENTS);
-            if (commentsYAML instanceof List) {
-                for (Object comment : (List) commentsYAML) {
-                    elementOM.addComment(String.valueOf(comment));
-                    log("comment=" + String.valueOf(comment));
-                }
-            }
-
-            Object stereotypesYAML = collectElement((List) elementYAML, STEREOTYPES);
-            {
-                if (stereotypesYAML instanceof List) {
-                    for (Object stereotype : (List) stereotypesYAML) {
-                        ObjectModelImplRef stereotypeOM = new ObjectModelImplRef();
-                        stereotypeOM.setName(String.valueOf(stereotype));
-                        elementOM.addStereotype(stereotypeOM);
-                        log("stereotype=" + String.valueOf(stereotype));
-                    }
-                }
-            }
-        }
-    }
-
-    public void loadClassifier(Object classifierYAML, ObjectModelClassifierImpl classifierOM) {
-        if (classifierYAML instanceof List) {
-            //TODO: addDependency
-
-            loadElement(classifierYAML, classifierOM);
-
-            Object packageYAML = collectElement((List) classifierYAML, PACKAGE);
-            if (packageYAML == null) {
-                classifierOM.setPackage(packageOM);
-            } else {
-                classifierOM.setPackage(String.valueOf(packageYAML));
-                log("package=" + String.valueOf(packageYAML));
-            }
-
-            Object externYAML = collectElement((List) classifierYAML, EXTERN);
-            if (externYAML == null) {
-                ;
-            } else {
-                classifierOM.setExtern(Boolean.valueOf(String.valueOf(externYAML)));
-                log("extern=" + String.valueOf(externYAML));
-            }
-
-            Object innerYAML = collectElement((List) classifierYAML, INNER);
-            if (innerYAML == null) {
-                ;
-            } else {
-                classifierOM.setInner(Boolean.valueOf(String.valueOf(innerYAML)));
-                log("inner=" + String.valueOf(innerYAML));
-            }
-
-            Object typeYAML = collectElement((List) classifierYAML, TYPE);
-            if (typeYAML == null) {
-                ;
-            } else {
-                classifierOM.setType(String.valueOf(typeYAML));
-                log("type=" + String.valueOf(typeYAML));
-            }
-
-            List attributesYAML = collectAllElements((List) classifierYAML, ATTRIBUTE);
-            for (Object attributeYAML : attributesYAML) {
-                ObjectModelAttributeImpl attributeOM = new ObjectModelAttributeImpl();
-                loadAttribute(attributeYAML, attributeOM);
-                classifierOM.addAttribute(attributeOM);
-                log("attribute=" + attributeOM.getType() + " loaded");
-            }
-
-            List operationsYAML = collectAllElements((List) classifierYAML, OPERATION);
-            for (Object operationYAML : operationsYAML) {
-                ObjectModelOperationImpl operationOM = new ObjectModelOperationImpl();
-                loadOperation(operationYAML, operationOM);
-                classifierOM.addOperation(operationOM);
-                log("operation=" + operationOM.getName() + " loaded");
-            }
-
-            Object superInterfacesYAML = collectElement((List) classifierYAML, SUPER_INTERFACES);
-            if (superInterfacesYAML instanceof List) {
-                for (Object superInterface : (List) superInterfacesYAML) {
-                    ObjectModelImplRef superInterfaceOM = new ObjectModelImplRef();
-                    superInterfaceOM.setName(String.valueOf(superInterface));
-                    classifierOM.addInterface(superInterfaceOM);
-                    log("superInterface=" + String.valueOf(superInterface));
-                }
-            }
-        }
-    }
-
-    public void loadClass(Object classYAML, ObjectModelClassImpl classOM) {
-        if (classYAML instanceof List) {
-            //TODO: addInnerClassifier
-
-            loadClassifier(classYAML, classOM);
-
-            Object abstractYAML = collectElement((List) classYAML, ABSTRACT);
-            if (abstractYAML == null) {
-                ;
-            } else {
-                classOM.setAbstract(Boolean.valueOf(String.valueOf(abstractYAML)));
-                log("abstract=" + String.valueOf(abstractYAML));
-            }
-
-            Object superClassesYAML = collectElement((List) classYAML, SUPER_CLASSES);
-            if (superClassesYAML instanceof List) {
-                for (Object superClass : (List) superClassesYAML) {
-                    ObjectModelImplSuperClassRef superClassOM = new ObjectModelImplSuperClassRef();
-                    //ObjectModelImplRef superClassOM = new ObjectModelImplRef();
-                    superClassOM.setName(String.valueOf(superClass));
-                    classOM.addSuperclass(superClassOM);
-                    log("superClass=" + String.valueOf(superClass));
-                }
-            }
-        }
-    }
-
-    public void loadInterface(Object interfaceYAML, ObjectModelInterfaceImpl interfaceOM) {
-        if (interfaceYAML instanceof List) {
-            loadClassifier(interfaceYAML, interfaceOM);
-        }
-    }
-
-    //TODO: gerer participants sous forme de liste -ou pas ? "attribute" utile ?-
-    public void loadAssociationClass(Object associationClassYAML, ObjectModelAssociationClassImpl associationClassOM) {
-        if (associationClassYAML instanceof List) {
-            loadClass(associationClassYAML, associationClassOM);
-
-            List participantsYAML = collectAllElements((List) associationClassYAML, PARTICIPANT);
-            for (Object participantYAML : participantsYAML) {
-                if (participantYAML instanceof List) {
-
-                    ObjectModeImplAssociationClassParticipant participantOM = new ObjectModeImplAssociationClassParticipant();
-                    participantOM.setAssociationClass(associationClassOM);
-
-                    //le nom de la classe sans oublier la package devant
-                    Object nameYAML = collectElement((List) participantYAML, NAME);
-                    if (nameYAML == null) {
-                        ;
-                    } else {
-                        String name = String.valueOf(nameYAML);
-                        if (imports.containsKey(name)) {
-                            participantOM.setName(imports.get(name));
-                        } else {
-                            participantOM.setName(name);
-                        }
-                        log("name=" + name);
-                    }
-
-                    Object attributeYAML = collectElement((List) participantYAML, ATTRIBUTE);
-                    if (attributeYAML == null) {
-                        ;
-                    } else {
-                        participantOM.setAttribute(String.valueOf(attributeYAML));
-                        log("attribute=" + String.valueOf(attributeYAML));
-                    }
-                    log("participant=" + String.valueOf(nameYAML) + " loaded");
-                    associationClassOM.addParticipant(participantOM);
-                }
-            }
-        }
-    }
-
-    public void loadEnumeration(Object enumerationYAML, ObjectModelEnumerationImpl enumerationOM) {
-        if (enumerationYAML instanceof List) {
-            loadElement(enumerationYAML, enumerationOM);
-
-            Object literalsYAML = collectElement((List) enumerationYAML, LITERAL);
-            if (literalsYAML instanceof List) {
-                for (Object literalYAML : (List) literalsYAML) {
-                    ObjectModelImplRef literalOM = new ObjectModelImplRef();
-                    literalOM.setName(String.valueOf(literalYAML));
-                    enumerationOM.addLiteral(literalOM);
-                    log("literal=" + String.valueOf(literalsYAML));
-                }
-            }
-
-            Object packageYAML = collectElement((List) enumerationYAML, PACKAGE);
-            if (packageYAML == null) {
-                enumerationOM.setPackage(packageOM);
-            } else {
-                enumerationOM.setPackage(String.valueOf(packageYAML));
-                log("package=" + String.valueOf(packageYAML));
-            }
-        }
-    }
-
-    public void loadParameter(Object parameterYAML, ObjectModelParameterImpl parameterOM) {
-        if (parameterYAML instanceof List) {
-            loadElement(parameterYAML, parameterOM);
-
-            Object orderingYAML = collectElement((List) parameterYAML, ORDERING);
-            if (orderingYAML == null) {
-                ;
-            } else {
-                parameterOM.setOrdering(String.valueOf(orderingYAML));
-                log("ordering=" + String.valueOf(orderingYAML));
-            }
-
-            Object typeYAML = collectElement((List) parameterYAML, TYPE);
-            if (typeYAML == null) {
-                ;//lever exception
-            } else {
-                String type = String.valueOf(typeYAML);
-                if (imports.containsKey(type)) {
-                    parameterOM.setType(imports.get(type));
-                } else {
-                    parameterOM.setType(type);
-                }
-                log("type=" + parameterOM.getType());
-            }
-
-            Object defaultValueYAML = collectElement((List) parameterYAML, DEFAULT_VALUE);
-            if (defaultValueYAML == null) {
-                ;
-            } else {
-                parameterOM.setDefaultValue(String.valueOf(defaultValueYAML));
-                log("defaultValue=" + String.valueOf(defaultValueYAML));
-            }
-
-            Object minMultiplicityYAML = collectElement((List) parameterYAML, MIN_MULTIPLICITY);
-            if (minMultiplicityYAML == null) {
-                ;//deja instancié à 1
-            } else {
-                parameterOM.setMinMultiplicity(Integer.valueOf(String.valueOf(minMultiplicityYAML)));
-                log("minMultiplicity=" + Integer.valueOf(String.valueOf(minMultiplicityYAML)));
-            }
-
-            Object maxMultiplicityYAML = collectElement((List) parameterYAML, MAX_MULTIPLICITY);
-            if (maxMultiplicityYAML == null) {
-                ;
-            } else {
-                parameterOM.setMaxMultiplicity(Integer.valueOf(String.valueOf(maxMultiplicityYAML)));
-                log("maxMultiplicity=" + String.valueOf(maxMultiplicityYAML));
-            }
-
-            Object orderedYAML = collectElement((List) parameterYAML, ORDERED);
-            if (orderedYAML == null) {
-                ;
-            } else {
-                parameterOM.setOrdered(Boolean.valueOf(String.valueOf(orderedYAML)));
-                log("ordered=" + Boolean.valueOf(String.valueOf(orderedYAML)));
-            }
-
-            Object uniqueYAML = collectElement((List) parameterYAML, UNIQUE);
-            if (uniqueYAML == null) {
-                ;
-            } else {
-                parameterOM.setUnique(Boolean.valueOf(String.valueOf(uniqueYAML)));
-                log("unique=" + Boolean.valueOf(String.valueOf(uniqueYAML)));
-            }
-        }
-    }
-
-    public void loadAttribute(Object attributeYAML, ObjectModelAttributeImpl attributeOM) {
-        if (attributeYAML instanceof List) {
-            loadParameter(attributeYAML, attributeOM);
-
-            Object navigableYAML = collectElement((List) attributeYAML, NAVIGABLE);
-            if (navigableYAML == null) {
-                ;
-            } else {
-                attributeOM.setNavigable(Boolean.valueOf(String.valueOf(navigableYAML)));
-                log("navigable=" + Boolean.valueOf(String.valueOf(navigableYAML)));
-            }
-
-            Object associationTypeYAML = collectElement((List) attributeYAML, ASSOCIATION_TYPE);
-            if (associationTypeYAML == null) {
-                ;//attributeOM.setAssociationType(ObjectModelAttributeImpl.ATTRIBUTE_TYPE_COMPOSITE);
-            } else {
-                attributeOM.setAssociationType(String.valueOf(associationTypeYAML));
-                log("associationType=" + String.valueOf(associationTypeYAML));
-            }
-
-            Object finalYAML = collectElement((List) attributeYAML, FINAL);
-            if (finalYAML == null) {
-                ;
-            } else {
-                attributeOM.setFinal(Boolean.valueOf(String.valueOf(finalYAML)));
-                log("final=" + Boolean.valueOf(String.valueOf(finalYAML)));
-            }
-
-            Object staticYAML = collectElement((List) attributeYAML, STATIC);
-            if (staticYAML == null) {
-                ;
-            } else {
-                attributeOM.setStatic(Boolean.valueOf(String.valueOf(staticYAML)));
-                log("static=" + Boolean.valueOf(String.valueOf(staticYAML)));
-            }
-
-            Object associationClassNameYAML = collectElement((List) attributeYAML, ASSOCIATION_CLASS_NAME);
-            if (associationClassNameYAML == null) {
-                ;
-            } else {
-                String associationClassName = String.valueOf(associationClassNameYAML);
-                if (imports.containsKey(associationClassName)) {
-                    attributeOM.setAssociationClassName(imports.get(associationClassName));
-                } else {
-                    attributeOM.setAssociationClassName(associationClassName);
-                }
-                log("associationClassName=" + associationClassName);
-            }
-
-            Object reverseAttributeNameYAML = collectElement((List) attributeYAML, REVERSE_ATTRIBUTE_NAME);
-            if (reverseAttributeNameYAML == null) {
-                ;// attributeOM.setReverseAttributeName("");//test
-            } else {
-                attributeOM.setReverseAttributeName(String.valueOf(reverseAttributeNameYAML));
-                log("reverseAttributeName=" + String.valueOf(reverseAttributeNameYAML));
-            }
-
-            Object reverseMaxMultiplicityYAML = collectElement((List) attributeYAML, REVERSE_MAX_MULTIPLICITY);
-            if (reverseMaxMultiplicityYAML == null) {
-                ;//instancié à -1
-            } else {
-                attributeOM.setReverseMaxMultiplicity(Integer.valueOf(String.valueOf(reverseMaxMultiplicityYAML)));
-                log("reverseMaxMultiplicity=" + Integer.valueOf(String.valueOf(reverseMaxMultiplicityYAML)));
-            }
-
-
-            Object transientYAML = collectElement((List) attributeYAML, TRANSIENT);
-            if (transientYAML == null) {
-                ;
-            } else {
-                attributeOM.setTransient(Boolean.valueOf(String.valueOf(transientYAML)));
-                log("transient=" + Boolean.valueOf(String.valueOf(transientYAML)));
-            }
-
-            Object visibilityYAML = collectElement((List) attributeYAML, VISIBILITY);
-            if (visibilityYAML == null) {
-                ;
-            } else {
-                attributeOM.setVisibility(String.valueOf(visibilityYAML));
-                log("visibility=" + String.valueOf(visibilityYAML));
-            }
-        }
-    }
-
-    public void loadOperation(Object operationYAML, ObjectModelOperationImpl operationOM) {
-        if (operationYAML instanceof List) {
-            //TODO: addExceptionParameter
-
-            loadElement(operationYAML, operationOM);
-
-            Object abstractYAML = collectElement((List) operationYAML, ABSTRACT);
-            if (abstractYAML == null) {
-                ;
-            } else {
-                operationOM.setAbstract(Boolean.valueOf(String.valueOf(abstractYAML)));
-                log("abstract=" + Boolean.valueOf(String.valueOf(abstractYAML)));
-            }
-
-            Object visibilityYAML = collectElement((List) operationYAML, VISIBILITY);
-            if (visibilityYAML == null) {
-                ;
-            } else {
-                operationOM.setVisibility(String.valueOf(visibilityYAML));
-                log("visibility=" + String.valueOf(visibilityYAML));
-            }
-
-            Object returnParameterYAML = collectElement((List) operationYAML, RETURN_PARAMETER);
-            if (returnParameterYAML == null) {
-                ;
-            } else {
-                ObjectModelParameterImpl parameterOM = new ObjectModelParameterImpl();
-                loadParameter(returnParameterYAML, parameterOM);
-                operationOM.setReturnParameter(parameterOM);
-                log("returnParameter=" + parameterOM.getType() + " loaded");
-            }
-
-            Object bodyCodeYAML = collectElement((List) operationYAML, BODY_CODE);
-            if (bodyCodeYAML == null) {
-                ;
-            } else {
-                operationOM.setBodyCode(String.valueOf(bodyCodeYAML));
-                log("bodyCode=" + String.valueOf(bodyCodeYAML));
-            }
-
-            List parametersYAML = collectAllElements((List) operationYAML, PARAMETER);
-            for (Object parameterYAML : parametersYAML) {
-                ObjectModelParameterImpl parameterOM = new ObjectModelAttributeImpl();
-                loadParameter(parameterYAML, parameterOM);
-                operationOM.addParameter(parameterOM);
-                log("parameter=" + parameterOM.getType() + " loaded");
-            }
-        }
-    }
-}

    

r1273 - trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml

agiraudet＠users.nuiton.org

tags

participants (1)