#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
+
interface sera stabilisée.
"""
+import types
+import Noyau.N_VALIDATOR
+
class Valid:
"""
Cette classe est la classe mere de toutes les classes complémentaires
"""
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):
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):
