-#@ MODIF N_MCCOMPO Noyau DATE 03/09/2002 AUTEUR GNICOLAS G.NICOLAS
+#@ MODIF N_MCCOMPO Noyau DATE 28/10/2003 AUTEUR DURAND C.DURAND
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
# A ce stade, mc_liste ne contient que les fils de l'objet courant
# args ne contient plus que des mots-clés qui n'ont pas été attribués car ils sont
# à attribuer à des blocs du niveau inférieur ou bien sont des mots-clés erronés
- dico_valeurs = self.cree_dict_valeurs(mc_liste)
+ dico_valeurs = self.cree_dict_condition(mc_liste,condition=1)
for k,v in self.definition.entites.items():
if v.label != 'BLOC':continue
# condition and a or b : Equivalent de l'expression : condition ? a : b du langage C
bloc = v(nom=k,val=args,parent=self)
mc_liste.append(bloc)
args=bloc.reste_val
- dico_valeurs = self.cree_dict_valeurs(mc_liste)
+ # On ne recalcule pas le contexte car on ne tient pas compte des blocs
+ # pour évaluer les conditions de présence des blocs
+ #dico_valeurs = self.cree_dict_valeurs(mc_liste)
# On conserve les arguments superflus dans l'attribut reste_val
self.reste_val=args
else:
return mc_liste
- def cree_dict_valeurs(self,liste=[]):
+ def cree_dict_valeurs(self,liste=[],condition=0):
"""
- Cette méthode crée le contexte de l'objet courant sous la forme
- d'un dictionnaire.
- L'opération consiste à transformer une liste d'OBJECT en un
- dictionnaire.
- Ce dictionnaire servira de contexte pour évaluer les conditions des
- blocs fils.
+ Cette méthode crée un contexte (sous la forme d'un dictionnaire)
+ à partir des valeurs des mots clés contenus dans l'argument liste.
+ L'opération consiste à parcourir la liste (d'OBJECT) et à la
+ transformer en un dictionnaire dont les clés sont les noms des
+ mots clés et les valeurs dépendent du type d'OBJECT.
+ Ce dictionnaire servira de liste d'arguments d'appel pour les
+ fonctions sd_prod de commandes et ops de macros ou de contexte
+ d'évaluation des conditions de présence de BLOC.
+
+ Si l'argument condition de la méthode vaut 1, on ne
+ remonte pas les valeurs des mots clés contenus dans des blocs
+ pour eviter les bouclages.
Cette méthode réalise les opérations suivantes en plus de transformer
la liste en dictionnaire :
- - ajouter tous les mots-clés non présents avec la valeur None
-
- - ajouter tous les mots-clés globaux (attribut position = 'global'
- et 'global_jdc')
-
- ATTENTION : -- on ne remonte pas (semble en contradiction avec la
- programmation de la méthode get_valeur du bloc) les
- mots-clé fils d'un bloc au niveau du
- contexte car celà peut générer des erreurs.
+ - ajouter tous les mots-clés non présents avec la valeur None
+ - ajouter tous les mots-clés globaux (attribut position = 'global'
+ et 'global_jdc')
L'argument liste est, en général, une mc_liste en cours de
construction, contenant les mots-clés locaux et les blocs déjà créés.
"""
dico={}
for v in liste:
- k=v.nom
- val = v.get_valeur()
- # Si val est un dictionnaire, on inclut ses items dans le dictionnaire
- # représentatif du contexte. Les blocs sont retournés par get_valeur
- # sous la forme d'un dictionnaire : les mots-clés fils de blocs sont
- # donc remontés au niveau du contexte.
- if type(val)==types.DictionaryType:
- for i,w in val.items():
- dico[i]=w
+ if v.isBLOC():
+ # Si v est un BLOC, on inclut ses items dans le dictionnaire
+ # représentatif du contexte. Les blocs sont retournés par get_valeur
+ # sous la forme d'un dictionnaire : les mots-clés fils de blocs sont
+ # donc remontés au niveau du contexte.
+ if not condition:dico.update(v.get_valeur())
else:
- dico[k]=val
- # on rajoute tous les autres mots-clés locaux possibles avec la valeur
+ dico[v.nom]=v.get_valeur()
+
+ # On rajoute tous les autres mots-clés locaux possibles avec la valeur
# par défaut ou None
- # Pour les mots-clés facteurs, on ne tient pas compte du défaut
- # (toujours None)
+ # Pour les mots-clés facteurs, on ne traite que ceux avec statut défaut ('d')
+ # et caché ('c')
+ # On n'ajoute aucune information sur les blocs. Ils n'ont pas de défaut seulement
+ # une condition.
for k,v in self.definition.entites.items():
if not dico.has_key(k):
if v.label == 'SIMP':
+ # Mot clé simple
dico[k]=v.defaut
- # S il est declare global il n est pas necessaire de l ajouter
- # aux mots cles globaux de l'etape
- # car la methode recherche_mc_globaux les rajoutera
- elif v.label == 'FACT' and v.statut in ('c','d') :
- dico[k]=v(val=None,nom=k,parent=self)
- # On demande la suppression des pointeurs arrieres
- # pour briser les eventuels cycles
- dico[k].supprime()
- elif v.label != 'BLOC':
- dico[k]=None
+ elif v.label == 'FACT' :
+ if v.statut in ('c','d') :
+ # Mot clé facteur avec défaut ou caché provisoire
+ dico[k]=v(val=None,nom=k,parent=self)
+ # On demande la suppression des pointeurs arrieres
+ # pour briser les eventuels cycles
+ dico[k].supprime()
+ else:
+ dico[k]=None
# A ce stade on a rajouté tous les mots-clés locaux possibles (fils directs) avec leur
# valeur par défaut ou la valeur None
- # on rajoute les mots-clés globaux ...
+
+ # On rajoute les mots-clés globaux sans écraser les clés existantes
dico_mc = self.recherche_mc_globaux()
- for nom,mc in dico_mc.items() :
- if not dico.has_key(nom) : dico[nom]=mc.valeur
- # Il nous reste à évaluer la présence des blocs en fonction du contexte qui a changé
- for k,v in self.definition.entites.items():
- if v.label != 'BLOC' : continue
- # condition and a or b : Equivalent de l'expression : condition ? a : b du langage C
- globs= self.jdc and self.jdc.condition_context or {}
- if v.verif_presence(dico,globs):
- # le bloc k doit etre présent : on crée temporairement l'objet MCBLOC correspondant
- # on lui passe un parent égal à None pour qu'il ne soit pas enregistré
- bloc = v(nom=k,val=None,parent=None)
- dico_bloc = bloc.cree_dict_valeurs()
- bloc.supprime()
- # on va updater dico avec dico_bloc en veillant à ne pas écraser
- # des valeurs déjà présentes
- for cle in dico_bloc.keys():
- if not dico.has_key(cle):
- dico[cle]=dico_bloc[cle]
+ dico_mc.update(dico)
+ dico=dico_mc
+
+ return dico
+
+ def cree_dict_condition(self,liste=[],condition=0):
+ """
+ Methode pour construire un contexte qui servira dans l'évaluation
+ des conditions de présence de blocs. Si une commande a un concept
+ produit réutilisé, on ajoute la clé 'reuse'
+ """
+ dico=self.cree_dict_valeurs(liste,condition=1)
+ # On ajoute la cle "reuse" pour les MCCOMPO qui ont un attribut reuse. A destination
+ # uniquement des commandes. Ne devrait pas etre dans cette classe mais dans une classe dérivée
+ if not dico.has_key('reuse') and hasattr(self,'reuse'):
+ dico['reuse']=self.reuse
return dico
def recherche_mc_globaux(self):
for v in self.mc_liste:
if v.nom == name : return v
if restreint == 'non' :
- for k,v in self.definition.entites.items():
- if k == name:
- if v.valeur != None : return v(None,k,None)
+ try:
+ entite=self.definition.entites[name]
+ if entite.label == 'SIMP' or (entite.label == 'FACT' and entite.statut in ( 'c', 'd')):
+ return entite(None,name,None)
+ except:
+ pass
+
return None
def append_mc_global(self,mc):
"""
Cette classe est la classe mere des validateurs Accas
Elle doit etre derivee
- Elle ne presente que la signature des methodes
- indispensables pour son bon fonctionnement
+ Elle presente la signature des methodes indispensables pour son bon
+ fonctionnement et dans certains cas leur comportement par défaut.
@ivar cata_info: raison de la validite ou de l'invalidite du validateur meme
@type cata_info: C{string}
raise "Must be implemented"
def info(self):
+ """
+ Cette methode retourne une chaine de caractères informative sur
+ la validation demandée par le validateur. Elle est utilisée
+ pour produire le compte-rendu de validité du mot clé associé.
+ """
return "valeur valide"
+ def aide(self):
+ """
+ Cette methode retourne une chaine de caractère qui permet
+ de construire un message d'aide en ligne.
+ En général, le message retourné est le meme que celui retourné par la
+ méthode info.
+ """
+ return self.info()
+
+ def info_erreur_item(self):
+ """
+ Cette méthode permet d'avoir un message d'erreur pour un item
+ dans une liste dans le cas ou le validateur fait des vérifications
+ sur les items d'une liste. Si le validateur fait seulement des
+ vérifications sur la liste elle meme et non sur ses items, la méthode
+ doit retourner une chaine vide.
+ """
+ return " "
+
+ def info_erreur_liste(self):
+ """
+ Cette méthode a un comportement complémentaire de celui de
+ info_erreur_item. Elle retourne un message d'erreur lié uniquement
+ aux vérifications sur la liste elle meme et pas sur ses items.
+ Dans le cas où le validateur ne fait pas de vérification sur des
+ listes, elle retourne une chaine vide
+ """
+ return " "
+
def verif(self,valeur):
"""
Cette methode sert a verifier si la valeur passee en argument est consideree
"""
raise "Must be implemented"
- def error(self,valeur):
+ def verif_item(self,valeur):
+ """
+ La methode verif du validateur effectue une validation complete de
+ la valeur. valeur peut etre un scalaire ou une liste. Le validateur
+ doit traiter les 2 aspects s'il accepte des listes (dans ce cas la
+ methode is_list doit retourner 1).
+ La methode valid_item sert pour effectuer des validations partielles
+ de liste. Elle doit uniquement verifier la validite d'un item de
+ liste mais pas les caracteristiques de la liste.
+ """
return 0
+ def valide_liste_partielle(self,liste_courante):
+ """
+ Cette methode retourne un entier qui indique si liste_courante est partiellement valide (valeur 1)
+ ou invalide (valeur 0). La validation partielle concerne les listes en cours de construction : on
+ veut savoir si la liste en construction peut etre complétée ou si elle peut déjà etre considérée
+ comme invalide.
+ En général un validateur effectue la meme validation pour les listes partielles et les
+ listes complètes.
+ """
+ return self.verif(liste_courante)
+
def verif_cata(self):
"""
Cette methode sert a realiser des verifications du validateur lui meme.
"""
return 1
-class RangeVal(Valid):
+ def is_list(self):
+ """
+ Cette méthode retourne un entier qui indique si le validateur
+ permet les listes (valeur 1) ou ne les permet pas (valeur 0).
+ Par défaut, un validateur n'autorise que des scalaires.
+ """
+ return 0
+
+ def has_into(self):
+ """
+ Cette méthode retourne un entier qui indique si le validateur
+ propose une liste de choix (valeur 1) ou n'en propose pas.
+ Par défaut, un validateur n'en propose pas.
+ """
+ return 0
+
+ def get_into(self,liste_courante=None,into_courant=None):
+ """
+ Cette méthode retourne la liste de choix proposée par le validateur.
+ Si le validateur ne propose pas de liste de choix, la méthode
+ retourne None.
+ L'argument d'entrée liste_courante, s'il est différent de None, donne
+ la liste des choix déjà effectués par l'utilisateur. Dans ce cas, la
+ méthode get_into doit calculer la liste des choix en en tenant
+ compte. Par exemple, si le validateur n'autorise pas les répétitions,
+ la liste des choix retournée ne doit pas contenir les choix déjà
+ contenus dans liste_courante.
+ L'argument d'entrée into_courant, s'il est différent de None, donne
+ la liste des choix proposés par d'autres validateurs. Dans ce cas,
+ la méthode get_into doit calculer la liste des choix à retourner
+ en se limitant à cette liste initiale. Par exemple, si into_courant
+ vaut (1,2,3) et que le validateur propose la liste de choix (3,4,5),
+ la méthode ne doit retourner que (3,).
+
+ La méthode get_into peut retourner une liste vide [], ce qui veut
+ dire qu'il n'y a pas (ou plus) de choix possible. Cette situation
+ peut etre normale : l''utilisateur a utilisé tous les choix, ou
+ résulter d'une incohérence des validateurs :
+ choix parmi (1,2,3) ET choix parmi (4,5,6). Il est impossible de
+ faire la différence entre ces deux situations.
+ """
+ return into_courant
+
+ def is_eval(self,valeur):
+ """
+ Cette méthode indique si valeur est un objet de type EVAL ou autre
+ que l'on ne cherchera pas à evaluer et qui doit etre considere
+ comme toujours valide. Si c'est un objet de ce type elle retourne
+ la valeur 1 sinon la valeur 0
+ """
+ return type(valeur) == types.InstanceType and valeur.__class__.__name__ in ('EVAL',
+ 'entier','reel','chaine', 'complexe','liste','PARAMETRE_EVAL')
+
+ def is_param(self,valeur):
+ """
+ Cette méthode indique si valeur est un objet de type PARAMETRE
+ dont on cherchera à evaluer la valeur (valeur.valeur)
+ """
+ return type(valeur) == types.InstanceType and valeur.__class__.__name__ in ('PARAMETRE',)
+
+ def is_unknown(self,valeur):
+ """
+ Cette méthode indique si valeur est un objet de type inconnu
+ c'est à dire ni de type EVAL ni de type PARAMETRE
+ """
+ return type(valeur) == types.InstanceType and valeur.__class__.__name__ not in ('EVAL',
+ 'entier','reel','chaine', 'complexe','liste','PARAMETRE_EVAL','PARAMETRE')
+
+class ListVal(Valid):
+ """
+ Cette classe sert de classe mère pour tous les validateurs qui acceptent
+ des listes.
+ """
+ def is_list(self):
+ return 1
+
+ def get_into(self,liste_courante=None,into_courant=None):
+ """
+ Cette méthode get_into effectue un traitement général qui consiste
+ a filtrer la liste de choix into_courant, si elle existe, en ne
+ conservant que les valeurs valides (appel de la méthode valid).
+ """
+ if into_courant is None:
+ return None
+ else:
+ liste_choix=[]
+ for e in into_courant:
+ if self.verif(e):
+ liste_choix.append(e)
+ return liste_choix
+
+ def verif(self,valeur):
+ """
+ Méthode verif pour les validateurs de listes. Cette méthode
+ fait appel à la méthode verif_item sur chaque élément de la
+ liste. Si valeur est un paramètre, on utilise sa valeur effective
+ valeur.valeur.
+ """
+ if self.is_param(valeur):
+ valeur=valeur.valeur
+ if type(valeur) in (types.ListType,types.TupleType):
+ for val in valeur:
+ if not self.verif_item(val):
+ return 0
+ return 1
+ else:
+ return self.verif_item(valeur)
+
+class RangeVal(ListVal):
"""
Exemple de classe validateur : verification qu'une valeur
est dans un intervalle.
def info(self):
return "valeur dans l'intervalle %s , %s" %(self.low,self.high)
- def verif(self,valeur):
- if type(valeur) in (types.ListType,types.TupleType):
- for val in valeur:
- if val < self.low :return 0
- if val > self.high:return 0
- return 1
- else:
- if valeur < self.low :return 0
- if valeur > self.high:return 0
- return 1
+ def verif_item(self,valeur):
+ return valeur > self.low and valeur < self.high
+
+ def info_erreur_item(self) :
+ return "La valeur doit être comprise entre %s et %s" % (self.low,
+ self.high)
def verif_cata(self):
if self.low > self.high : return 0
self.cata_info="%s doit etre inferieur a %s" % (min,max)
def info(self):
- return "longueur comprise entre %s et %s" % (self.min,self.max)
+ return "longueur de liste comprise entre %s et %s" % (self.min,self.max)
+
+ def info_erreur_liste(self):
+ return "La cardinalité de la liste doit être comprise entre %s et %s" % (self.min,self.max)
+
+ def is_list(self):
+ return self.max == '**' or self.max > 1
+
+ def get_into(self,liste_courante=None,into_courant=None):
+ if into_courant is None:
+ return None
+ elif liste_courante is None:
+ return into_courant
+ elif self.max == '**':
+ return into_courant
+ elif len(liste_courante) < self.max:
+ return into_courant
+ else:
+ return []
+
+ def verif_item(self,valeur):
+ return 1
def verif(self,valeur):
if type(valeur) in (types.ListType,types.TupleType):
if self.min != '**' and self.max != '**' and self.min > self.max : return 0
return 1
-class PairVal(Valid):
+ def valide_liste_partielle(self,liste_courante=None):
+ validite=1
+ if liste_courante != None :
+ if len(liste_courante) > self.max :
+ validite=0
+ return validite
+
+class PairVal(ListVal):
"""
Exemple de classe validateur : verification qu'une valeur
est paire.
def info(self):
return "valeur paire"
+ def info_erreur_item(self):
+ return "La valeur saisie doit être paire"
+
+ def verif_item(self,valeur):
+ if type(valeur) == types.InstanceType:
+ if self.is_eval(valeur):
+ return 1
+ elif self.is_param(valeur):
+ valeur=valeur.valeur
+ else:
+ return 0
+ return valeur % 2 == 0
+
def verif(self,valeur):
if type(valeur) in (types.ListType,types.TupleType):
for val in valeur:
if valeur % 2 != 0:return 0
return 1
-class EnumVal(Valid):
+class EnumVal(ListVal):
"""
Exemple de classe validateur : verification qu'une valeur
est prise dans une liste de valeurs.
def info(self):
return "valeur dans %s" % `self.into`
- def verif(self,valeur):
- if type(valeur) in (types.ListType,types.TupleType):
- for val in valeur:
- if val not in self.into:return 0
- return 1
+ def verif_item(self,valeur):
+ if valeur not in self.into:return 0
+ return 1
+
+ def has_into(self):
+ return 1
+
+ def get_into(self,liste_courante=None,into_courant=None):
+ if into_courant is None:
+ liste_choix= list(self.into)
else:
- if valeur not in self.into:return 0
- return 1
+ liste_choix=[]
+ for e in into_courant:
+ if e in self.into:
+ liste_choix.append(e)
+ return liste_choix
+
+ def info_erreur_item(self):
+ return "La valeur n'est pas dans la liste des choix possibles"
-class NoRepeat(Valid):
+class NoRepeat(ListVal):
"""
Verification d'absence de doublons dans la liste.
"""
self.cata_info=""
def info(self):
- return ": présence de doublon dans la liste"
+ return ": pas de présence de doublon dans la liste"
+
+ def info_erreur_liste(self):
+ return "Les doublons ne sont pas permis"
+
+ def verif_item(self,valeur):
+ return 1
def verif(self,valeur):
if type(valeur) in (types.ListType,types.TupleType):
else:
return 1
-class LongStr(Valid):
+ def get_into(self,liste_courante=None,into_courant=None):
+ """
+ Methode get_into spécifique pour validateur NoRepeat, on retourne
+ une liste de choix qui ne contient aucune valeur de into_courant
+ déjà contenue dans liste_courante
+ """
+ if into_courant is None:
+ liste_choix=None
+ else:
+ liste_choix=[]
+ for e in into_courant:
+ if e in liste_choix: continue
+ if liste_courante is not None and e in liste_courante: continue
+ liste_choix.append(e)
+ return liste_choix
+
+class LongStr(ListVal):
"""
Verification de la longueur d une chaine
"""
def info(self):
return "longueur de la chaine entre %s et %s" %(self.low,self.high)
- def verif(self,valeur):
- if type(valeur) in (types.ListType,types.TupleType):
- for val in valeur:
- if len(val) < self.low :return 0
- if len(val) > self.high:return 0
- return 1
- else:
- if len(valeur) < self.low :return 0
- if len(valeur) > self.high:return 0
- return 1
+ def info_erreur_item(self):
+ return "Longueur de la chaine incorrecte"
+
+ def verif_item(self,valeur):
+ low=self.low
+ high=self.high
+ if valeur[0]=="'" and valeur[-1]=="'" :
+ low=low+2
+ high=high+2
+ if len(valeur) < low :return 0
+ if len(valeur) > high:return 0
+ return 1
-class OrdList(Valid):
+class OrdList(ListVal):
"""
Verification qu'une liste est croissante ou decroissante
"""
def info(self):
return "liste %s" % self.ord
+ def info_erreur_liste(self) :
+ return "La liste doit être en ordre "+self.ord
+
def verif(self,valeur):
if type(valeur) in (types.ListType,types.TupleType):
if self.ord=='croissant':
else:
return 1
+ def verif_item(self,valeur):
+ return 1
+
+ def get_into(self,liste_courante=None,into_courant=None):
+ """
+ Methode get_into spécifique pour validateur OrdList, on retourne
+ une liste de choix qui ne contient aucune valeur de into_courant
+ dont la valeur est inférieure à la dernière valeur de
+ liste_courante, si elle est différente de None.
+ """
+ if into_courant is None:
+ return None
+ elif not liste_courante :
+ return into_courant
+ else:
+ liste_choix=[]
+ last_val=liste_choix[-1]
+ for e in into_courant:
+ if self.ord=='croissant' and e <= last_val:continue
+ if self.ord=='decroissant' and e >= last_val:continue
+ liste_choix.append(e)
+ return liste_choix
CoercableFuncs = { types.IntType: int,
types.LongType: long,
types.ComplexType: complex,
types.UnicodeType: unicode }
-class TypeVal(Valid):
+class TypeVal(ListVal):
"""
Cette classe est un validateur qui controle qu'une valeur
est bien du type Python attendu.
return value
raise ValError
- def verif(self,valeur):
- if type(valeur) in (types.ListType,types.TupleType):
- for val in valeur:
- try:
- self.coerce(val)
- except:
- return 0
- return 1
- else:
- try:
- self.coerce(valeur)
- except:
- return 0
- return 1
+ def verif_item(self,valeur):
+ try:
+ self.coerce(valeur)
+ except:
+ return 0
+ return 1
-class InstanceVal(Valid):
+class InstanceVal(ListVal):
"""
Cette classe est un validateur qui controle qu'une valeur est
bien une instance (au sens Python) d'une classe
def info(self):
return "valeur d'instance de %s" % self.aClass.__name__
- def verif(self,valeur):
- if type(valeur) in (types.ListType,types.TupleType):
- for val in valeur:
- if not isinstance(val,self.aClass): return 0
- return 1
+ def verif_item(self,valeur):
if not isinstance(valeur,self.aClass): return 0
return 1
class OrVal(Valid):
"""
Cette classe est un validateur qui controle une liste de validateurs
- Elle verifie qu'au moins un des validateurs de la liste a valide la valeur
+ Elle verifie qu'au moins un des validateurs de la liste valide la valeur
"""
def __init__(self,validators=()):
- if type(validators) not in (types.ListType,types.TupleType): validators=(validators,)
+ if type(validators) not in (types.ListType,types.TupleType):
+ validators=(validators,)
self.validators=[]
for validator in validators:
if type(validator) == types.FunctionType:
def info(self):
return "\n ou ".join([v.info() for v in self.validators])
+ def info_erreur_item(self):
+ l=[]
+ for v in self.validators:
+ err=v.info_erreur_item()
+ if err != " " : l.append(err)
+ chaine=" \n ou ".join(l)
+ return chaine
+
+ def info_erreur_liste(self):
+ l=[]
+ for v in self.validators:
+ err=v.info_erreur_liste()
+ if err != " " : l.append(err)
+ chaine=" \n ou ".join(l)
+ return chaine
+
+ def is_list(self):
+ """
+ Si plusieurs validateurs sont reliés par un OU
+ il suffit qu'un seul des validateurs attende une liste
+ pour qu'on considère que leur union attend une liste.
+ """
+ for validator in self.validators:
+ v=validator.is_list()
+ if v :
+ return 1
+ return 0
+
def verif(self,valeur):
for validator in self.validators:
v=validator.verif(valeur)
return 1
return 0
+ def verif_item(self,valeur):
+ for validator in self.validators:
+ v=validator.verif_item(valeur)
+ if v :
+ return 1
+ return 0
+
def verif_cata(self):
infos=[]
for validator in self.validators:
self.cata_info=""
return 1
+ def has_into(self):
+ """
+ Dans le cas ou plusieurs validateurs sont reliés par un OU
+ il faut que tous les validateurs proposent un choix pour
+ qu'on considère que leur union propose un choix.
+ Exemple : Enum(1,2,3) OU entier pair, ne propose pas de choix
+ En revanche, Enum(1,2,3) OU Enum(4,5,6) propose un choix (1,2,3,4,5,6)
+ """
+ for validator in self.validators:
+ v=validator.has_into()
+ if not v :
+ return 0
+ return 1
+
+ def get_into(self,liste_courante=None,into_courant=None):
+ """
+ Dans le cas ou plusieurs validateurs sont reliés par un OU
+ tous les validateurs doivent proposer un choix pour
+ qu'on considère que leur union propose un choix. Tous les choix
+ proposés par les validateurs sont réunis (opérateur d'union).
+ Exemple : Enum(1,2,3) OU entier pair, ne propose pas de choix
+ En revanche, Enum(1,2,3) OU Enum(4,5,6) propose un
+ choix (1,2,3,4,5,6)
+ """
+ validator_into=[]
+ for validator in self.validators:
+ v_into=validator.get_into(liste_courante,into_courant)
+ if v_into is None:
+ return v_into
+ validator_into.extend(v_into)
+ return validator_into
+
+ def valide_liste_partielle(self,liste_courante=None):
+ """
+ Méthode de validation de liste partielle pour le validateur Or.
+ Si un des validateurs gérés par le validateur Or considère la
+ liste comme valide, le validateur Or la considère comme valide.
+ """
+ for validator in self.validators:
+ v=validator.valide_liste_partielle(liste_courante)
+ if v :
+ return 1
+ return 0
+
class AndVal(Valid):
"""
Cette classe est un validateur qui controle une liste de validateurs
- Elle verifie que tous les validateurs de la liste sont positifs
+ Elle verifie que tous les validateurs de la liste valident la valeur
"""
def __init__(self,validators=()):
- if type(validators) not in (types.ListType,types.TupleType): validators=(validators,)
+ if type(validators) not in (types.ListType,types.TupleType):
+ validators=(validators,)
self.validators=[]
for validator in validators:
if type(validator) == types.FunctionType:
self.cata_info=""
def info(self):
- return " et ".join([v.info() for v in self.validators])
+ return "\n et ".join([v.info() for v in self.validators])
+
+ def info_erreur_item(self):
+ chaine=""
+ a=1
+ for v in self.validators:
+ if v.info_erreur_item() != " " :
+ if a==1:
+ chaine=v.info_erreur_item()
+ a=0
+ else:
+ chaine=chaine+" \n et "+v.info_erreur_item()
+ return chaine
+
+ def info_erreur_liste(self):
+ a=1
+ for v in self.validators:
+ if v.info_erreur_liste() != " " :
+ if a==1:
+ chaine=v.info_erreur_liste()
+ a=0
+ else:
+ chaine=chaine+" \n et "+v.info_erreur_liste()
+ return chaine
def verif(self,valeur):
for validator in self.validators:
return 0
return 1
+ def verif_item(self,valeur):
+ for validator in self.validators:
+ v=validator.verif_item(valeur)
+ if not v :
+ # L'info n'est probablement pas la meme que pour verif ???
+ self.local_info=validator.info()
+ return 0
+ return 1
+
def verif_cata(self):
infos=[]
for validator in self.validators:
self.cata_info=""
return 1
+ def valide_liste_partielle(self,liste_courante=None):
+ """
+ Méthode de validation de liste partielle pour le validateur And.
+ Tous les validateurs gérés par le validateur And doivent considérer
+ la liste comme valide, pour que le validateur And la considère
+ comme valide.
+ """
+ for validator in self.validators:
+ v=validator.valide_liste_partielle(liste_courante)
+ if not v :
+ return 0
+ return 1
+
+ def is_list(self):
+ """
+ Si plusieurs validateurs sont reliés par un ET
+ il faut que tous les validateurs attendent une liste
+ pour qu'on considère que leur intersection attende une liste.
+ Exemple Range(2,5) ET Card(1) n'attend pas une liste
+ Range(2,5) ET Pair attend une liste
+ """
+ for validator in self.validators:
+ v=validator.is_list()
+ if v == 0 :
+ return 0
+ return 1
+
+ def has_into(self):
+ """
+ Dans le cas ou plusieurs validateurs sont reliés par un ET
+ il suffit qu'un seul validateur propose un choix pour
+ qu'on considère que leur intersection propose un choix.
+ Exemple : Enum(1,2,3) ET entier pair, propose un choix
+ En revanche, entier pair ET superieur à 10 ne propose pas de choix
+ """
+ for validator in self.validators:
+ v=validator.has_into()
+ if v :
+ return 1
+ return 0
+
+ def get_into(self,liste_courante=None,into_courant=None):
+ """
+ Dans le cas ou plusieurs validateurs sont reliés par un ET
+ il suffit qu'un seul validateur propose un choix pour
+ qu'on considère que leur intersection propose un choix. Tous les
+ choix proposés par les validateurs sont croisés (opérateur
+ d'intersection)
+ Exemple : Enum(1,2,3) ET entier pair, propose un choix (2,)
+ En revanche, Enum(1,2,3) ET Enum(4,5,6) ne propose pas de choix.
+ """
+ for validator in self.validators:
+ into_courant=validator.get_into(liste_courante,into_courant)
+ if into_courant in ([],None):break
+ return into_courant
+
def do_liste(validators):
"""
Convertit une arborescence de validateurs en OrVal ou AndVal
