Discussion :

[Invité]

Bonjour à toutes et tous,

Je me suis écris une petite classe qui convertit un fichier ".properties" en un objet JSon. Cette classe fonctionnait jusqu'a ce que mon fichier devienne un peu plus complexe.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
Properties properties = new Properties();
properties.put("mail.format.invalid", "Format invalide");
properties.put("format.date", "dd/mm/yy");
 
System.out.println(new JSONPropertiesConverter().convert(properties));

Devrait donner

"mail" : {"format" : { "invalid" : "Format invalide" } },
"format" : {"date" : "dd/mm/yy"}

Mais donne

"mail" : {"format" : {"date" : "dd/mm/yy", "invalid" : "Format invalide" } }

Malheureusement je suis bloqué et ne parviens pas à solutionner la chose, je m'adresse donc à la communauté :
1° Existe t'il déjà une classe qui fais celà ?
2° L'un d'entre vous pourrais t'il m'aider à résoudre ce problème ? Un oeil extérieur seras sûrement plus rapide. Ma classe est attachée à ce post. (Tout peut-être changé sauf la signature de la classe et de sa méthode)

Merci

[dahtah]

Salut,
j'ai juste jeté un oeil, mais il semblerait que le nombre de point dans ta clé properties correspondent au nombre de {} désirés. Donc un split sur les points te donne le tableau des clés, tu recomposes avec les { ouvrantes, et ajoutes les } fermantes en bout de chaine (il y en aura n-1 par rapport au tableau issu de split).
Je suis pas sur d'être très clair donc en pseudo code (pas javac sous la main):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
String s = "mail.format.invalid";
String[] keys = s.split('.',);
String dom = keys[0];
for (String key : keys)
{
    dom.append(" : { key");
}
dom = String.format("dom : %s", properties.get(s) );
dom.append("}"*(keys.length -1)) //pad with }}}

Désolé, ça fait un bout de temps que j'ai pas fait de java, donc le nom des méthodes est pas top, mais la méthode est là je pense.

[Invité]

Bonjour,

Merci mais ce n'est pas si simple.
Il peut y avoir plusieurs parties de clefs qui doivent être regroupées, celà doit-être vu comme un arbre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
Properties properties = new Properties();
properties.put("format.month", "mmmm");
properties.put("mail.format.invalid", "Format invalide");
properties.put("format.date", "dd/mm/yy");
 
System.out.println(new JSONPropertiesConverter().convert(properties));

Doit donner :

"mail" : {"format" : { "invalid" : "Format invalide" } },
"format" : {"date" : "dd/mm/yy", "month" : "mmmmm"}

Le "remplacement" n'est donc pas suffisant..

[thelvin]

Dans ce cas tu devrais commencer par construire cette hiérarchie, et t'en servir ensuite pour faire l'objet.

Par exemple en construisant une Map<String, Node> où un Node contient soit une valeur String si on est au bout de la hiérarchie, soit une autre Map<String, Node>.

Ainsi, quelque chose comme truc.machin.bidule = chouette sera contenu dans ta map.get("truc").map().get("machin").map().get("bidule").value()

Ça, ou alors tu modifies tes JSONEntry de sorte que ça puisse être construit comme ça directement.

[Invité]

Thelvin; Merci, c'est un peu ce que je tentais de faire.

Mais j'ai trouvé une solution qui me plaît tout autant et qui en plus me renvoei les propriétés par ordre alphabétique.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
private final HashMap<String, JSONEntry> parents = new HashMap<String, JSONEntry>();
private final List<JSONEntry> roots = new ArrayList<JSONEntry>(1);
 
public String convert2(final Properties properties) {
	List<String[]> flatten = new ArrayList<String[]>();
	for (Object objKey : properties.keySet()) {
		String key = objKey.toString();
		flatten.add(key.split("\\."));
	}
 
	Collections.sort(flatten, new Comparator<String[]>(){
		public int compare(String[] o1, String[] o2) {
			StringBuilder buffer1 = new StringBuilder();
			for (String part : o1) buffer1.append(part);
 
			StringBuilder buffer2 = new tringBuilder();				
			for (String part : o2) buffer2.append(part);
 
			return buffer1.toString().compareTo(buffer2.toString());
		}
	});
 
	String path = null;
	for (Iterator<String[]> it = flatten.iterator(); it.hasNext(); ) {
		String[] parts = it.next();			
		for (int i=0; i<parts.length; i++) {
			path = buildPath(parts, i);
			if (parents.containsKey(path))
				continue;
 
			if ( i==0 ) {					
				JSONEntry root = new JSONEntry(path);
				parents.put(path, root);
				roots.add(root);
			} else {
				JSONEntry child  = new JSONEntry(parts[i]);
				JSONEntry parent = parents.get(buildPath(parts, i-1));
				child.setParent(parent);
				if ( i==parts.length-1 )
child.setValue(properties.getProperty(path));						
				else
					parents.put(path, child);
			}
		}
	}
 
	StringBuffer buffer = new StringBuffer();
	for (JSONEntry root : roots) buffer.append(root.toJSON()).append(",\n");
	return buffer.replace(buffer.length()-2, buffer.length(), "").toString();
}
 
private String buildPath(String[] parts, int level) {
	StringBuilder builder = new StringBuilder();
	for (int i=0; i<level; i++)
		builder.append(parts[i]).append('.');
	return builder.append(parts[level]).toString();
}
 
/* La classe interne JSONEntry ne change pas. 
 * Sauf une petite correction qui ajoute l'accolade seulement si il y à des enfants :
 * buff.append(" : {");
 * if ( childs!=null ) {
 *   ...
 * Deviens
 * if ( childs!=null ) {
 *   buff.append(" : {");
 * Idem pou la fermeture de l'accolade
 */