Bien définir une structure pour faciliter son utilisation

Version imprimable

Bonjour,

Je voudrais sauvegarder dans mon programme un état pour chaque utilisateur "P" qui travaille sur un document "d" (un utilisateur peut travailler sur plusieurs documents). Un état est représenté par 3 variables: cur_cl (un entier), cur_of (un entier aussi) et cur_ops qui est une liste de valeurs {(op1, type1), (op2, type2), ...)}. Je peut ajouter un nouvel état sur un document (d) pour un utilisateur (P) qui n'existais pas (P->d->état), ou pour un utilisateur qui existais mais sur un document sur lequel il ne travaillais pas ... Je veux dire que le nombre d'utilisateurs n'est pas fixé ou connu dès le départ ...

http://imageupload.org/?di=1412984829906

Bref, ce que je voudrais c'est avoir un idée sur comment représenter, et bien structurer tout ça. Je ne fait pour l'instant que l'algo mais je voudrais le structurer d'une façon qui me facilitera l'implémentation après.

Juste pour information, les fonctions qui seront appelé sur cette structure seront en gros les suivants:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 UpdateCur_cl(P, d, newValue) { /* update la valeur cur_cl par newValue, (P-->d-->cur = newvalue) */ } UpdateCur_of(P, d, newValue) { /* update la valeur cur_of par newValue ... */ } UpdateCur_ops(P, d, op, t) { /* update le type de op par le nouveau type t, si op n'existe pas (op, t) sera ajouté */ } checkState(P, d) { if (P-->d n'existe pas) then { // Le créer; // Initialiser P-->d-->cur_ops avec vide {}; // Initialiser P-->d-->cur_cl et cur_of avec 0; } } // ...
Donc ma question concerne seulement la représentation de cette structure, de façon à me faciliter la création d'états, l'accès au valeurs, leur mise à jour ...

Merci bien.

23/02/2011, 19h11
pseudocode

Une idée vite fait de structure c'est d'utiliser une map a deux entrées.

Map(document,user) = Etat

Dans la pratique, on peut créer une "map de map" pour faire cela :

Map< Document , Map<User, State> >

En Java ca peut donner cela:

La modélisation de Document, User et State

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Document { /* ... */ }
 
public class User { /* ... */ }
 
public class State {
	int cur_cl;
	int cur_of;
	Map<String, String> cur_ops = new HashMap<String, String>(); 
	public State(int cl, int of) {
		this.cur_cl=cl;
		this.cur_of=of;
	}
	public State setOps(String op,String type) {
		cur_ops.put(op, type);
		return this;
	}
	public String getType(String op) {
		return cur_ops.get(op);
	}
	public Set<String> getAllOps() {
		return cur_ops.keySet();
	}
}

La structure de stockage

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Storage {
	Map< Document , Map<User, State> > docmap = new HashMap<TestStructure.Document, Map<User,State>>();
	public State get(Document d, User u) {
		Map<User, State> usermap = docmap.get(d);
		if (usermap==null) return null;
		return usermap.get(u);
	}
	public void set(Document d, User u, State s) {
		Map<User, State> usermap = docmap.get(d);
		if (usermap==null) {
			usermap = new HashMap<User, State>();
			docmap.put(d, usermap);
		}
		usermap.put(u,s);
	}
	public void remove(Document d, User u) {
		Map<User, State> usermap = docmap.get(d);
		if (usermap==null) return;
		usermap.remove(u);
		if (usermap.isEmpty()) docmap.remove(d);
	}
}

Et un exemple d'utilisation.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
Storage root = new Storage();
 
Document Document75487 = new Document( /* ... */ );
User JohnDoe = new User( /* ... */ );
State s = new State(0,1).setOps("op1","type1").setOps("op2","type2");
 
// ajoute au stockage
root.set(Document75487, JohnDoe, s);
 
// modifie les infos
root.get(Document75487, JohnDoe).cur_cl = 3;
root.get(Document75487, JohnDoe).setOps("op1","newtype");
 
// affiche le contenu
State JDstate = root.get(Document75487, JohnDoe);
System.out.println(JDstate.cur_cl);
for(String ops : JDstate.getAllOps())
	System.out.println(ops+"="+JDstate.getType(ops));

24/02/2011, 10h49
charlebakhtovsky3
Bonjour,

Merci pour la proposition, ça a l'air intéressant comme modélisation. Je vais voir ça de plus près.

D'autre part, les documents et les utilisateurs ne sont pas vraiment modélisés comme des entités dans mon système, j'utilise juste une chaine pour identifié un utilisateur (même chose pour doc). C'est l'état associé à un ("utilisateurX", "documentY") qui m'intéresse. Donc je voudrais savoir est ce que c'est possible de représenter des listes imbriqués comme suite:

Dans la suite, je note une liste d'une taille indéterminé par [elem1, elem2, ...], et une liste (ou tableau) d'une taille fixe (exemple 3) par (elem1, elem2, elem3)

S = ([(op1,t1), (op2,t2), ...], c1, c2)

D = [(p1, S1), (p2, S2), ...] /* chaque élément S est indexé par un p */

R = [(d1, D1), (d1, D2), ...] /* chaque élément D est indexé par un d */

les "op" et les "t" c'est des Strings, les "c" c'est des int, les "p" et les "d" c'est des Strings.
Comment représenter d'une manière simplifié la structure R a final ?

Est ce que ça pourrait être représenter par quelque chose comme ça (ce qui suit est indépendant d'un langage donné, c'est juste pour exprimer l'idée):
Code:

1 2 3 4 5 6 7 8 9 10 Structure S { List op<String, String>; int c1; int c2; }; List D<String, S>; List R<String, D>;
24/02/2011, 11h17
pseudocode
Citation:

Envoyé par charlebakhtovsky3

Comment représenter d'une manière simplifié la structure R a final ?

La structure le Stockage que j'ai donné en exemple fait exactement cela.

Ce que tu notes (d1, D1), je l'ai représenté par (Document, Map<User, State>)

d1 --> Document
D1 = [(p1, S1), (p2, S2), ...] --> Map<User, State>

Pour accéder à la structure "D1", on peut ajouter une méthode dans la classe Storage.
Code:

1 2 3 public Map<User, State> get(Document d) { return docmap.get(d); }