From 5cf288c86365cbfd1de55e16600559711ad1c538 Mon Sep 17 00:00:00 2001 From: eficas <> Date: Thu, 23 Oct 2003 12:14:06 +0000 Subject: [PATCH] CCAR: diverses corrections lies aux validateurs --- Ihm/I_ETAPE.py | 2 +- Ihm/I_MACRO_ETAPE.py | 2 +- Ihm/I_MCSIMP.py | 47 +++++++++++++++++-- Ihm/I_PROC_ETAPE.py | 2 +- Ihm/I_VALIDATOR.py | 108 +++++++++++++++++++++++++++++++++---------- 5 files changed, 131 insertions(+), 30 deletions(-) diff --git a/Ihm/I_ETAPE.py b/Ihm/I_ETAPE.py index 1d098585..6bcebd97 100644 --- a/Ihm/I_ETAPE.py +++ b/Ihm/I_ETAPE.py @@ -397,7 +397,7 @@ class ETAPE(I_MCCOMPO.MCCOMPO): """ try: sd=Noyau.N_ETAPE.ETAPE.Build_sd(self,nom) - self.state="changed" + self.state="modified" except AsException,e: # Une erreur s'est produite lors de la construction du concept # Comme on est dans EFICAS, on essaie de poursuivre quand meme diff --git a/Ihm/I_MACRO_ETAPE.py b/Ihm/I_MACRO_ETAPE.py index f4fb5b7a..b87125c9 100644 --- a/Ihm/I_MACRO_ETAPE.py +++ b/Ihm/I_MACRO_ETAPE.py @@ -276,7 +276,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): """ try: sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.Build_sd(self,nom) - self.state="changed" + self.state="modified" except AsException,e: # Une erreur s'est produite lors de la construction du concept # Comme on est dans EFICAS, on essaie de poursuivre quand meme diff --git a/Ihm/I_MCSIMP.py b/Ihm/I_MCSIMP.py index 0654345d..1080104b 100644 --- a/Ihm/I_MCSIMP.py +++ b/Ihm/I_MCSIMP.py @@ -390,7 +390,7 @@ class MCSIMP(I_OBJECT.OBJECT): l.append(sd) else: l.append(sd) - self.valeur=l + self.valeur=tuple(l) # Est ce init_modif ou init_modif_up # Normalement init_modif va avec fin_modif self.init_modif() @@ -428,14 +428,18 @@ class MCSIMP(I_OBJECT.OBJECT): elif valeur.__class__.__name__ in ('PARAMETRE',): # il faut tester si la valeur du parametre est un entier #XXX ne serait ce pas plutot complexe ???? sinon expliquer - return self.is_entier(valeur.valeur) + return self.is_complexe(valeur.valeur) else: print "Objet non reconnu dans is_complexe %s" %`valeur` return 0 # Pour permettre l'utilisation de complexes Python #elif type(valeur) == types.ComplexType: #return 1 - elif type(valeur) != types.TupleType and type(valeur) != types.ListType : + elif type(valeur) == types.ListType : + # On n'autorise pas les listes de complexes + return 0 + elif type(valeur) != types.TupleType : + # Un complexe doit etre un tuple return 0 else: if len(valeur) != 3 : @@ -558,3 +562,40 @@ class MCSIMP(I_OBJECT.OBJECT): self.set_valid(valid) return self.valid + def verif_into(self,cr='non'): + """ + Vérifie si la valeur de self est bien dans l'ensemble discret de valeurs + donné dans le catalogue derrière l'attribut into ou vérifie que valeur est bien compris + entre val_min et val_max + """ + if self.definition.into == None : + #on est dans le cas d'un ensemble continu de valeurs possibles (intervalle) + if type(self.valeur)==types.TupleType : + test = 1 + for val in self.valeur : + if type(val)!=types.StringType and type(val)!=types.InstanceType: + test = test*self.isinintervalle(val,cr=cr) + return test + else : + val = self.valeur + if type(val)!=types.StringType and type(val)!=types.InstanceType: + return self.isinintervalle(self.valeur,cr=cr) + else : + return 1 + else : + # on est dans le cas d'un ensemble discret de valeurs possibles (into) + # PN : pour résoudre le pb du copier /coller de la liste Ordonnee + # if type(self.valeur) == types.TupleType : + if type(self.valeur) in (types.ListType,types.TupleType) : + for e in self.valeur: + if e not in self.definition.into: + if cr=='oui': + self.cr.fatal(string.join(("La valeur :",`e`," n'est pas permise pour le mot-clé :",self.nom))) + return 0 + else: + if self.valeur == None or self.valeur not in self.definition.into: + if cr=='oui': + self.cr.fatal(string.join(("La valeur :",`self.valeur`," n'est pas permise pour le mot-clé :",self.nom))) + return 0 + return 1 + diff --git a/Ihm/I_PROC_ETAPE.py b/Ihm/I_PROC_ETAPE.py index de14e2ee..b3fa648e 100644 --- a/Ihm/I_PROC_ETAPE.py +++ b/Ihm/I_PROC_ETAPE.py @@ -73,7 +73,7 @@ class PROC_ETAPE(I_ETAPE.ETAPE): """ try: sd=Noyau.N_PROC_ETAPE.PROC_ETAPE.Build_sd(self) - self.state="changed" + self.state="modified" except AsException,e: # Une erreur s'est produite lors de la construction du concept # Comme on est dans EFICAS, on essaie de poursuivre quand meme diff --git a/Ihm/I_VALIDATOR.py b/Ihm/I_VALIDATOR.py index c8302746..92c93300 100644 --- a/Ihm/I_VALIDATOR.py +++ b/Ihm/I_VALIDATOR.py @@ -64,7 +64,15 @@ class Valid: return 0 def valide_liste_partielle(self,liste_courante): - return 0 + """ + 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_item(self,valeur): """ @@ -159,27 +167,20 @@ class OrVal(Valid): return 0 def info_erreur_item(self): - chaine="" - a=1 + l=[] for v in self.validators: - if v.info_erreur_item() != " " : - if a==1: - chaine=v.info_erreur_item() - a=0 - else: - chaine=chaine+" \n ou "+ v.info_erreur_item() + err=v.info_erreur_item() + if err != " " : l.append(err) + chaine=" \n ou ".join(l) return chaine def info_erreur_liste(self): - chaine="" - a=1 + l=[] for v in self.validators: - if v.info_erreur_liste() != " " : - if a==1: - chaine=v.info_erreur_liste() - a=0 - else: - chaine=chaine+" \n ou "+v.info_erreur_liste() + err=v.info_erreur_liste() + if err != " " : l.append(err) + chaine=" \n ou ".join(l) + return chaine def is_list(self): """ @@ -224,6 +225,17 @@ class OrVal(Valid): 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): def info(self): @@ -261,6 +273,18 @@ class AndVal(Valid): return 0 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 @@ -321,7 +345,6 @@ class CardVal(Valid): def valide_liste_partielle(self,liste_courante=None): validite=1 - print liste_courante if liste_courante != None : if len(liste_courante) > self.max : validite=0 @@ -405,13 +428,50 @@ class RangeVal(ListVal): def info_erreur_item(self) : return "La valeur doit être comprise entre %s et %s" % (self.low,self.high) +CoercableFuncs = { types.IntType: int, + types.LongType: long, + types.FloatType: float, + types.ComplexType: complex, + types.UnicodeType: unicode } + class TypeVal(ListVal): - def verif_item(self,valeur): - try: - self.coerce(valeur) - except: - return 0 - return 1 + """ + Cette classe est un validateur qui controle qu'une valeur + est bien du type Python attendu. + Pour une liste on verifie que tous les elements sont du bon type. + """ + def __init__(self, aType): + if type(aType) != types.TypeType: + aType=type(aType) + self.aType=aType + try: + self.coerce=CoercableFuncs[ aType ] + except: + self.coerce = self.identity + + def info(self): + return "valeur de %s" % self.aType + + def identity ( self, value ): + if type( value ) == self.aType: + return value + raise ValError + + def verif(self,valeur): + if type(valeur) in (types.ListType,types.TupleType): + for val in valeur: + valid=self.verif_item(val) + if valid == 0:return 0 + return 1 + else: + return self.verif_item(valeur) + + def verif_item(self,valeur): + try: + self.coerce(valeur) + except: + return 0 + return 1 class PairVal(ListVal): -- 2.39.2