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()
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 :
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
+
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):
"""
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):
"""
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):
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
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
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):
