Author: agiraudet Date: 2013-06-07 11:30:56 +0200 (Fri, 07 Jun 2013) New Revision: 1267 Url: http://nuiton.org/projects/eugene/repository/revisions/1267 Log: impl?\195?\169mentation de la syntaxe YAML user friendly (test) Added: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/Parser.java Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/KeyWords.java trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxePureYaml.java trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadObjectModel.java trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadYamlFile.java trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlObject.java trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlUtil.java Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/KeyWords.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/KeyWords.java 2013-05-31 15:50:13 UTC (rev 1266) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/KeyWords.java 2013-06-07 09:30:56 UTC (rev 1267) @@ -22,6 +22,7 @@ public static final String IMPORTS = "imports"; public static final String INNER = "inner"; public static final String INTERFACE = "interface"; + public static final String LABEL = "label"; public static final String LITERAL = "literal"; public static final String MAX_MULTIPLICITY = "maxmultiplicity"; public static final String MIN_MULTIPLICITY = "minmultiplicity"; @@ -33,6 +34,9 @@ public static final String PACKAGE = "package"; public static final String PARAMETER = "parameter"; public static final String PARTICIPANT = "participant"; + public static final String PRIVATE = "private"; + public static final String PROTECTED = "protected"; + public static final String PUBLIC = "public"; public static final String RETURN_PARAMETER = "returnparameter"; public static final String REVERSE_ATTRIBUTE_NAME = "reverseattributename"; public static final String REVERSE_MAX_MULTIPLICITY = "reversemaxmultiplicity"; Added: 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 (rev 0) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/Parser.java 2013-06-07 09:30:56 UTC (rev 1267) @@ -0,0 +1,1005 @@ +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 + * + * 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) + */ +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 ? + { + parseClass(key,value,associationClassYAMLO);//non fonctionnel (remplacer CLASS par ASSOCIATION_CLASS) + + //degolass' + 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 + 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); + } + } + } + } + } + } + + 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(ORDERED)) + { + attributeYAMLO.addStringToMap(ORDERED,String.valueOf(true)); + attributePARSE.remove(attributePARSE.indexOf(ORDERED)); + } + 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)); + } + + 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); + } + } + + 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) + { + //attributeYAMLO.addStringToMap(DEFAULT_VALUE,String.valueOf(value)); + attributeYAMLO.addStringToMap(NAME,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) ? + 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)); + } + if(operationPARSE.size() > 1) + { + YamlObject returnParameterYAMLO = new YamlObject(); + returnParameterYAMLO.addStringToMap(TYPE,operationPARSE.get(0)); + operationYAMLO.addYamlObjectToMap(RETURN_PARAMETER,returnParameterYAMLO); + + 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); + } + } + } + } + } + } + + 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.containsKeyMapStringListString(PARTICIPANT)) + { + ;//TODO + } + } + } + } + + //OK + public static String browseType(String type, Map<String,String> imports) + { + //List<Map<String,List<Integer>>> + 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 + 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)); + } + } + //methode getReverseAttribute(mode,type,label) + //recuperer le reverse attribute + //TODO + //modelYAMLO.getFirstMapStringListYamlObject(YamlUtil.afterChar(type,'.')).get + //for() + } + else//unidirectionnel + { + YamlObject reverseObject = getReverseObject(modelYAMLO,YamlUtil.afterChar(type,'.')); + if(reverseObject != null) + { + YamlObject reverseAttribute = new YamlObject(); + reverseAttribute.addStringToMap(NAVIGABLE,String.valueOf(false)); + reverseAttribute.addStringToMap(TYPE,imports.get(labelisable.getFirstMapStringListString(NAME))); + if(attribute.containsKeyMapStringListString(MAX_MULTIPLICITY)) + { + reverseAttribute.addStringToMap(REVERSE_MAX_MULTIPLICITY,attribute.getFirstMapStringListString(MAX_MULTIPLICITY)); + } + if(attribute.containsKeyMapStringListString(NAME)) + { + reverseAttribute.addStringToMap(REVERSE_ATTRIBUTE_NAME,attribute.getFirstMapStringListString(NAME)); + } + } + } + } + } + else//simple attribut + { + ;//ou gerer par valeurs par defaut ? + //associationType="composite"//default eugene + //minMultiplicity="1"//default eugene + //maxMultiplicity="1"//default eugene + } + } + } + } + } + } + } + + 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); + } + } +} Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxePureYaml.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxePureYaml.java 2013-05-31 15:50:13 UTC (rev 1266) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/SyntaxePureYaml.java 2013-06-07 09:30:56 UTC (rev 1267) @@ -13,19 +13,19 @@ //TODO: interface Syntaxe ou classe abstraite (appel l'operation suivante : charger l'ObjectModel) //key.toLowerCase() ? public class SyntaxePureYaml { - + /* public static void loadModelYaml(Object modelYAML, YamlObject modelYAMLO) { - loadYamlObject(modelYAML, modelYAMLO, "model"); + loadYamlObject(modelYAML, modelYAMLO); } - - public static void loadYamlObject(Object objectYaml, YamlObject modelYaml, String previous) + */ + public static void loadYamlObject(Object objectYaml, YamlObject modelYaml) { if(objectYaml instanceof List) { for(Object tmp1 : (List) objectYaml) { - loadYamlObject(tmp1, modelYaml, previous); + loadYamlObject(tmp1, modelYaml); } } else if(objectYaml instanceof Map) @@ -35,7 +35,7 @@ if(((Map.Entry) tmp1).getValue() instanceof List || ((Map.Entry) tmp1).getValue() instanceof Map) { YamlObject tmp2 = new YamlObject(); - loadYamlObject(((Map.Entry) tmp1).getValue(),tmp2,String.valueOf(((Map.Entry) tmp1).getKey()).toLowerCase()); + loadYamlObject(((Map.Entry) tmp1).getValue(),tmp2); modelYaml.addYamlObjectToMap(String.valueOf(((Map.Entry) tmp1).getKey()).toLowerCase(),tmp2); } else Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadObjectModel.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadObjectModel.java 2013-05-31 15:50:13 UTC (rev 1266) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadObjectModel.java 2013-06-07 09:30:56 UTC (rev 1267) @@ -263,10 +263,10 @@ List<String> superInterfacesYAMLO = classifierYAMLO.getMapStringListString(SUPER_INTERFACES); for(String superInterfaceYAMLO : superInterfacesYAMLO) { - log(" SUPER_INTERFACE"); ObjectModelImplRef superInterfaceOM = new ObjectModelImplRef(); superInterfaceOM.setName(superInterfaceYAMLO); classifierOM.addInterface(superInterfaceOM); + log("superInterface="+superInterfaceYAMLO); } } @@ -288,10 +288,10 @@ List<String> superClassesYAMLO = classYAMLO.getMapStringListString(SUPER_CLASSES); for(String superClassYAMLO : superClassesYAMLO) { - ObjectModelImplRef superClassOM = new ObjectModelImplRef(); + ObjectModelImplSuperClassRef superClassOM = new ObjectModelImplSuperClassRef(); superClassOM.setName(superClassYAMLO); - classOM.addInterface(superClassOM); - log("superClasses="+classOM.getSuperclasses()); + classOM.addSuperclass(superClassOM); + log("superClasses="+superClassYAMLO); } } Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadYamlFile.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadYamlFile.java 2013-05-31 15:50:13 UTC (rev 1266) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/TestLoadYamlFile.java 2013-06-07 09:30:56 UTC (rev 1267) @@ -25,6 +25,23 @@ 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(); @@ -38,33 +55,57 @@ inputModel.close(); //chercher version et charger en conséquent - syntaxeVersion="1"; - defaultVersion="0"; + Object version = null; if(modelYAML instanceof List) { - Object version = YamlUtil.collectElement((List) modelYAML, SYNTAXE); - if(version != null) - { - syntaxeVersion = YamlUtil.beforeChar(String.valueOf(version),'.'); - defaultVersion = YamlUtil.afterChar(String.valueOf(version),'.'); - } + 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.loadModelYaml(modelYAML, modelYAMLO); + SyntaxePureYaml.loadYamlObject(modelYAML, modelYAMLO); + log("load SyntaxePureYaml"); } else if(syntaxeVersion.equals("2")) { - ;//syntaxe user firendly : coming soon + //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.loadModelYaml(modelYAML, modelYAMLO); + 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) } } Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlObject.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlObject.java 2013-05-31 15:50:13 UTC (rev 1266) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlObject.java 2013-06-07 09:30:56 UTC (rev 1267) @@ -146,6 +146,32 @@ return mapStringListString; } + public boolean setMapStringListString(String key, String value, String element) + { + if(mapStringListString.containsKey(key)) + { + if(mapStringListString.get(key).contains(value)) + { + mapStringListString.get(key).set(mapStringListString.get(key).indexOf(value),element); + return true; + } + } + return false; + } + + public boolean setMapStringListYamlObject(String key, YamlObject value, YamlObject element) + { + if(mapStringListYamlObject.containsKey(key)) + { + if(mapStringListYamlObject.get(key).contains(value)) + { + mapStringListYamlObject.get(key).set(mapStringListYamlObject.get(key).indexOf(value),element); + return true; + } + } + return false; + } + public boolean removeMapStringListString(String key, String value) { if(mapStringListString.containsKey(key)) @@ -214,7 +240,12 @@ { for(YamlObject yobj : entry.getValue()) { - res.append(indentation).append(entry.getKey()).append(":\n").append(yobj.toString( " "+indentation)).append("\n"); + //test temporaire + if(yobj != null) + { + res.append(indentation).append(entry.getKey()).append(":\n").append(yobj.toString( " "+indentation)).append("\n"); + } + //test } } return res.toString(); Modified: trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlUtil.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlUtil.java 2013-05-31 15:50:13 UTC (rev 1266) +++ trunk/eugene/src/main/java/org/nuiton/eugene/models/object/reader/yaml/YamlUtil.java 2013-06-07 09:30:56 UTC (rev 1267) @@ -61,7 +61,7 @@ return out.reverse().toString(); } - public static Object collectElement(List data, Object key) { + public static Object collectElementList(List data, Object key) { for (Object obj : data) { if (obj instanceof Map) { if (((Map) obj).containsKey(key)) { @@ -72,7 +72,7 @@ return null; } - public static List<Object> collectAllElements(List data, Object key) { + public static List<Object> collectAllElementsList(List data, Object key) { List<Object> res = new LinkedList<Object>(); for (Object obj : data) { if (obj instanceof Map) { @@ -83,4 +83,250 @@ } return res; } + + public static Object collectElementMap(Map data, Object key) + { + if(data.containsKey(key)) + { + return data.get(key); + } + else + { + return null; + } + } + + // fonctionnel/robuste/optimise + public static List<String> charParse(String str, Character target) + { + LinkedList<String> res = new LinkedList<String>(); + StringBuilder tmp = new StringBuilder(str.length()+1);//+1 utile en Java ? != C + boolean pre = false; + for(Character c : str.toCharArray()) + { + if(c.equals(target)) + { + if(pre) + { + res.add(tmp.toString()); + } + tmp.delete(0,tmp.length()); + pre = false; + } + else + { + tmp.append(c); + pre = true; + } + } + if(pre) + { + res.add(tmp.toString()); + } + return res; + } + + // fonctionnel/robuste/optimise + public static List<String> multiCharParse(String str, List<Character> targets) + { + LinkedList<String> res = new LinkedList<String>(); + StringBuilder tmp = new StringBuilder(str.length()+1);//+1 utile en Java ? != C + boolean pre = false; + for(Character c : str.toCharArray()) + { + if(targets.contains(c)) + { + if(pre) + { + res.add(tmp.toString()); + } + tmp.delete(0,tmp.length()); + pre = false; + } + else + { + tmp.append(c); + pre = true; + } + } + if(pre) + { + res.add(tmp.toString()); + } + return res; + } + + public static List<String> charParseIgnore(String str, Character target, Character ignoreStart, Character ignoreEnd) + { + LinkedList<String> res = new LinkedList<String>(); + StringBuilder tmp = new StringBuilder(str.length()+1);//+1 utile en Java ? != C + boolean pre = false; + int ign = 0;//parentheses ouvertes + for(Character c : str.toCharArray()) + { + if(c.equals(ignoreStart)) + { + ign++; + tmp.append(c); + } + else if(c.equals(ignoreEnd)) + { + ign--; + tmp.append(c); + } + else if(c.equals(target) && ign < 1) + { + if(pre) + { + res.add(tmp.toString()); + } + tmp.delete(0,tmp.length()); + pre = false; + } + else + { + tmp.append(c); + pre = true; + } + } + if(pre) + { + res.add(tmp.toString()); + } + return res; + } + + public static List<String> charParseMultiIgnore(String str, Character target, List<Character> ignoreStart, List<Character> ignoreEnd) + { + LinkedList<String> res = new LinkedList<String>(); + StringBuilder tmp = new StringBuilder(str.length()+1);//+1 utile en Java ? != C + boolean pre = false; + int ign = 0;//parentheses ouvertes + for(Character c : str.toCharArray()) + { + if(ignoreStart.contains(c)) + { + ign++; + tmp.append(c); + } + else if(ignoreEnd.contains(c)) + { + ign--; + tmp.append(c); + } + else if(c.equals(target) && ign < 1) + { + if(pre) + { + res.add(tmp.toString()); + } + tmp.delete(0,tmp.length()); + pre = false; + } + else + { + tmp.append(c); + pre = true; + } + } + if(pre) + { + res.add(tmp.toString()); + } + return res; + } + + public static String removeMultiChar(String str, List<Character> targets) + { + StringBuilder res = new StringBuilder(str.length()+1); + for(Character c : str.toCharArray()) + { + if(!targets.contains(c)) + { + res.append(c); + } + } + return res.toString(); + } + + public static String extract(Character start, Character end, String str) + { + StringBuilder tmp = new StringBuilder(str.length()+1); + boolean start_end = false; + int count = 0; + for(Character c : str.toCharArray()) + { + if(!start_end && c.equals(start)) + { + start_end = true; + } + else if(start_end && c.equals(start)) + { + count++; + tmp.append(c); + } + else if(start_end && c.equals(end)) + { + if(count>0) + { + count--; + tmp.append(c); + } + else + { + return tmp.toString(); + } + } + else if(start_end) + { + tmp.append(c); + } + } + return null; + } + + public static String extract(Character startend, String str) + { + StringBuilder tmp = new StringBuilder(str.length()+1); + boolean start_end = false; + for(Character c : str.toCharArray()) + { + if(!start_end && c.equals(startend)) + { + start_end = true; + } + else if(start_end && c.equals(startend)) + { + return tmp.toString(); + } + else if(start_end) + { + tmp.append(c); + } + } + return null; + } + + public static void main(String[] args) { + /*List<Character> ignoreStart = new LinkedList<Character>(); + ignoreStart.add('('); + ignoreStart.add('<'); + List<Character> ignoreEnd = new LinkedList<Character>(); + ignoreEnd.add(')'); + ignoreEnd.add('>'); + List<String> tmp = charParseMultiIgnore("public Map<Integer, String> Somme(List<String> bonjour, int y)",' ',ignoreStart,ignoreEnd); + for(String str : tmp) + { + System.out.println(str); + }*/ + //System.out.println(beforeChar("11..**",'.')); + //System.out.println(afterChar("11..**",'.')); + //System.out.println(afterChar("java.lang.String",'.')); + List<String> test = charParseIgnore("Map<String,String,String>",',','<','>'); + for(String str : test) + { + System.out.println(str); + } + System.out.println(extract('<','>',"<<<>>>")); + } }