From dda6e68ee6d7aedd4434e807515b696cc17cedf3 Mon Sep 17 00:00:00 2001 From: eficas <> Date: Tue, 7 Oct 2003 14:26:13 +0000 Subject: [PATCH] CCAR: surcharge des methodes is_xxx et isvalid de V_MCSIMP dans I_MCSIMP et tentative de protection des validateurs par surcharge de la methode verif mais pose des problemes car ne protege pas les listes --- Ihm/I_MCSIMP.py | 141 +++++++++++++++++++++++++++++++++++++++++++++ Ihm/I_VALIDATOR.py | 29 +++++++++- 2 files changed, 169 insertions(+), 1 deletion(-) diff --git a/Ihm/I_MCSIMP.py b/Ihm/I_MCSIMP.py index b72c63e9..060eefd6 100644 --- a/Ihm/I_MCSIMP.py +++ b/Ihm/I_MCSIMP.py @@ -418,3 +418,144 @@ class MCSIMP(I_OBJECT.OBJECT): #ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation # Elles doivent etre reintegrees des que possible + + def is_complexe(self,valeur): + """ Retourne 1 si valeur est un complexe, 0 sinon """ + if type(valeur) == types.InstanceType : + #XXX je n'y touche pas pour ne pas tout casser mais il serait + #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('C'), par exemple + if valeur.__class__.__name__ in ('EVAL','complexe','PARAMETRE_EVAL'): + return 1 + 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) + 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 : + return 0 + else: + if len(valeur) != 3 : + return 0 + else: + if type(valeur[0]) != types.StringType : return 0 + if string.strip(valeur[0]) not in ('RI','MP'): + return 0 + else: + if not self.is_reel(valeur[1]) or not self.is_reel(valeur[2]) : return 0 + else: return 1 + + def is_reel(self,valeur): + """ + Retourne 1 si valeur est un reel, 0 sinon + """ + if type(valeur) == types.InstanceType : + #XXX je n'y touche pas pour ne pas tout casser mais il serait + #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('R'), par exemple + #XXX ou valeur.is_reel() + #XXX ou encore valeur.compare(self.is_reel) + if valeur.__class__.__name__ in ('EVAL','reel','PARAMETRE_EVAL') : + return 1 + elif valeur.__class__.__name__ in ('PARAMETRE',): + # il faut tester si la valeur du parametre est un réel + return self.is_reel(valeur.valeur) + else: + print "Objet non reconnu dans is_reel %s" %`valeur` + return 0 + elif type(valeur) not in (types.IntType,types.FloatType,types.LongType): + # ce n'est pas un réel + return 0 + else: + return 1 + + def is_entier(self,valeur): + """ Retourne 1 si valeur est un entier, 0 sinon """ + if type(valeur) == types.InstanceType : + #XXX je n'y touche pas pour ne pas tout casser mais il serait + #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('I'), par exemple + if valeur.__class__.__name__ in ('EVAL','entier','PARAMETRE_EVAL') : + return 1 + elif valeur.__class__.__name__ in ('PARAMETRE',): + # il faut tester si la valeur du parametre est un entier + return self.is_entier(valeur.valeur) + else: + print "Objet non reconnu dans is_reel %s" %`valeur` + return 0 + elif type(valeur) not in (types.IntType,types.LongType): + # ce n'est pas un entier + return 0 + else: + return 1 + + def is_object_from(self,objet,classe): + """ + Retourne 1 si valeur est un objet de la classe classe ou d'une + sous-classe de classe, 0 sinon + """ + if type(objet) != types.InstanceType : + return 0 + if not objet.__class__ == classe and not issubclass(objet.__class__,classe): + return 0 + else: + return 1 + + def get_valid(self): + if hasattr(self,'valid'): + return self.valid + else: + self.valid=None + return None + + def set_valid(self,valid): + old_valid=self.get_valid() + self.valid = valid + self.state = 'unchanged' + if not old_valid or old_valid != self.valid : + self.init_modif_up() + + def isvalid(self,cr='non'): + """ + Cette méthode retourne un indicateur de validité de l'objet de type MCSIMP + + - 0 si l'objet est invalide + - 1 si l'objet est valide + + Le paramètre cr permet de paramétrer le traitement. Si cr == 'oui' + la méthode construit également un comte-rendu de validation + dans self.cr qui doit avoir été créé préalablement. + """ + if self.state == 'unchanged': + return self.valid + else: + v=self.valeur + valid = 1 + # verifiaction presence + if self.isoblig() and v == None : + if cr == 'oui' : + self.cr.fatal(string.join(("Mot-clé : ",self.nom," obligatoire non valorisé"))) + valid = 0 + + if v is None: + valid=0 + if cr == 'oui' : + self.cr.fatal("None n'est pas une valeur autorisée") + else: + # type,into ... + valid = self.verif_type(val=v,cr=cr)*self.verif_into(cr=cr)*self.verif_card(cr=cr) + # + # On verifie les validateurs s'il y en a et si necessaire (valid == 1) + # + if valid and self.definition.validators and not self.definition.validators.verif(self.valeur): + if cr == 'oui' : + self.cr.fatal(string.join(("Mot-clé : ",self.nom,"devrait avoir ",self.definition.validators.info()))) + valid=0 + # fin des validateurs + # + + self.set_valid(valid) + return self.valid + diff --git a/Ihm/I_VALIDATOR.py b/Ihm/I_VALIDATOR.py index d968e8a0..f9002c3a 100644 --- a/Ihm/I_VALIDATOR.py +++ b/Ihm/I_VALIDATOR.py @@ -9,6 +9,9 @@ interface sera stabilisée. """ +import types +import Noyau.N_VALIDATOR + class Valid: """ Cette classe est la classe mere de toutes les classes complémentaires @@ -80,6 +83,24 @@ class Valid: """ return into_courant + def surcharge_verif(self,methode_verif_initiale,valeur): + if type(valeur) == types.InstanceType : + #CCAR: pour le moment on fait comme dans is_entier de V_MCSIMP.py + # mais il serait préférable d'appeler une méthode de valeur : valeur.AsType() + # qui donnerait le type générique de l'objet. + # Pour un objet de "type" entier on obtiendrait par exemple 'I' + if valeur.__class__.__name__ in ('EVAL','entier','reel','chaine','complexe','liste','PARAMETRE_EVAL') : + # On ne vérifie pas le type d'un EVAL ou d'un objet de classe entier, .... C'est toujours valide + return 1 + elif valeur.__class__.__name__ in ('PARAMETRE',): + # Dans le cas d'un parametre, il faut tester si la valeur du parametre est un entier + valeur=valeur.valeur + return methode_verif_initiale(self,valeur) + else: + # Objet inconnu : invalide + print "Objet non reconnu dans surcharge_verif : %s" %`valeur` + return 0 + class FunctionVal(Valid):pass class OrVal(Valid): @@ -226,7 +247,13 @@ class EnumVal(ListVal): class LongStr(ListVal):pass class RangeVal(ListVal):pass class TypeVal(ListVal):pass -class PairVal(ListVal):pass +class PairVal(ListVal): + + #ATTENTION METHODE SURCHARGEE: a resorber dans une future version + def verif(self,valeur): + print "Ihm.I_MCSIMP.PairVal.verif: ",valeur + return self.surcharge_verif(Noyau.N_VALIDATOR.PairVal.verif,valeur) + class InstanceVal(ListVal):pass class NoRepeat(ListVal): -- 2.39.2