Bonsoir à tous,

Le titre du sujet est p-ê mal choisit, mais j'ai pas trouvé mieux.

Je vous explique mon problème :
J'ai, en base de données, un champs "conditions" qui contient, comme son nom l'indique, des conditions nécessaires porter un objet.
Actuellement, ces conditions sont stockées sous forme d'une chaine de caractères du type :

condition1=omg;condition2<10;condition3>9

Lorsque que je veux vérifier ces conditions, je split la chaine par les points virgules, puis je test chaque élément du tableau obtenu avec des regex.
Inutile de vous dire cette technique est extrêmement gourmande en ressources et en temps.

Je cherche donc à "compiler" ces conditions pour rendre les tests plus rapides.
J'ai pensé à une serialisation, mais comment gérer les inégalités ?
Y a-t-il une (d')autre(s) solution(s) ?

Merci de votre aide future.

si tu compiles, tu auras du binaire, impossible donc de lire tes conditions.

Bonsoir à toi,
J'ai peut-être mal compris, mais le champ "conditions" dans ta BDD, si tu faisais que ce soit un Arraylist<String> contenant seulement à chaque fois "=X" "<X" etc... Ca ferait un gain de temps considérable. Ou tu peux même faire un objet Condition avec les variables nécéssaires. Par contre "compiler"... Tu voudrais pas plutôt dire "compresser" ? Je vois pas trop comment faire

les regex marchent en java °_0 ?
ou je savais pas?
ou tu te connectes à une base sql dans laquelle tu fais des regex =/ =/

Peut-être en utilisant un champ de bits avec des flags ?

Bonjour,

Comme je l'ai dis dans mon premier post, le terme "compiler" n'est p-ê pas très approprié, ne vous focalisez pas dessus.

Je vais tenter de vous ré-expliquer mon problème.

J'ai une table objets contenant un champ de type texte conditions dans ma base de données.
Le champ conditions stocke les données sous cette forme :

conditions1=oui;condition2<5;condition3>4

Maintenant, lorsque que je veux tester ces conditions, mon code Java fonctionne de cette manière :

String[] conditions = conditionsChaine.split(";");

Pattern patternCondtion1 = Pattern.compile("condition1=(oui|non|p-e)");
Pattern patternCondtion2 = Pattern.compile("condition2(<|>|=)([0-9]+)");
Pattern patternCondtion3 = Pattern.compile("condition3(<|>|=)([0-9]+)");

for(int i = 0; i < conditions.length; i++)
{
	Matcher matcherCondtion1 = patternCondtion1.matcher(conditions[i]);
	Matcher matcherCondtion2 = patternCondtion2.matcher(conditions[i]);
	Matcher matcherCondtion3 = patternCondtion3.matcher(conditions[i]);
	
	if(matcherCondtion1.matches())
	{
		String valeur = matcherCondtion1.group(1);

		// Je sais que valeur doit être = à la variable Y, je test donc en conséquence
	}
	else if(matcherCondtion2.matches())
	{
		String operateur = matcherCondtion2.group(1);
		String valeur = matcherCondtion2.group(2);

		if(operateur.equals("<"))
		{
			// Je sais que valeur doit être < à la variable X, je test donc en conséquence
		}
		else if(operateur.equals(">"))
		{
			// Je sais que valeur doit être > à la variable X, je test donc en conséquence
		}
		else
		{
			// Je sais que valeur doit être = à la variable X, je test donc en conséquence
		}
	}
	else if(matcherCondtion3.matches())
	{
		String operateur = matcherCondtion3.group(1);
		String valeur = matcherCondtion3.group(2);

		if(operateur.equals("<"))
		{
			// Je sais que valeur doit être < à la variable X, je test donc en conséquence
		}
		else if(operateur.equals(">"))
		{
			// Je sais que valeur doit être > à la variable X, je test donc en conséquence
		}
		else
		{
			// Je sais que valeur doit être = à la variable X, je test donc en conséquence
		}
	}
}

Mais c'est très lourd est très long.

Je cherche donc une astuce pour éviter d'utiliser les regex, par exemple "serialiser" mes conditions.

@Snooooopy : http://java.sun.com/j2se/1.4.2/docs/ap [...] -summary.html

Merci.

Si tu en as vraiment beaucoup, il pourrait être pas mal de créer une interface Condition avec une méthode isSatisfied. Ensuite, Tu n'aurais qu'à utiliser une List<Condition>.
Avantage :
1 - Le code effectif de chaque condition est encapsulé dans la méthode isSatisfied de chacune des sous-classes implémentant ton interface. Ca allège le code de ta classe principale.
2 - Tu peux vérifier toutes ou certaines conditions à la chaîne avec une simple boucle
3 - Tu peux créer autant de conditions que tu as besoin sans toucher au code de la classe principale.
4 - La modification du code spécifique à une condition particulière n'affecte que le code de celle-ci
5 - Rien ne t'interdit de faire des classes internes si tu as besoin de variables contenues dans la classe principale. Donc tu peux conserver la puissance de ton système actuel.

Note supplémentaire : tu peux utiliser une classe abstraite à la place d'une interface si tu as besoin de méthodes prédéfinies ou proposant une version par défaut utilisables pour toutes les conditions existantes. Tu as le choix pour cet exemple simpliste.

EDIT : Ajout de précisions