from Extensions import param2
import I_OBJECT
import CONNECTOR
-
-#from I_VALIDATOR import ValidException
+from I_VALIDATOR import ValError,listProto
class MCSIMP(I_OBJECT.OBJECT):
def isoblig(self):
return self.definition.statut=='o'
+ def valid_val(self,valeur):
+ """
+ Verifie que la valeur passee en argument (valeur) est valide
+ sans modifier la valeur courante
+ """
+ lval=listProto.adapt(valeur)
+ if lval is None:
+ valid=0
+ mess="None n'est pas une valeur autorisée"
+ else:
+ try:
+ for val in lval:
+ self.typeProto.adapt(val)
+ self.intoProto.adapt(val)
+ self.cardProto.adapt(lval)
+ if self.definition.validators:
+ self.definition.validators.convert(lval)
+ valid,mess=1,""
+ except ValError,e:
+ mess=str(e)
+ valid=0
+ return valid,mess
+
def valid_valeur(self,new_valeur):
"""
Verifie que la valeur passee en argument (new_valeur) est valide
sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
"""
- old_valeur=self.valeur
- old_val=self.val
- self.valeur = new_valeur
- self.val = new_valeur
- self.state="modified"
- validite=self.isvalid()
- self.valeur = old_valeur
- self.val = old_valeur
- self.state="modified"
- self.isvalid()
+ validite,mess=self.valid_val(new_valeur)
return validite
def valid_valeur_partielle(self,new_valeur):
"""
- Verifie que la valeur passee en argument (new_valeur) est partiellement valide
- sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
+ Verifie que la valeur passee en argument (new_valeur) est une liste partiellement valide
+ sans modifier la valeur courante du mot cle
"""
- old_valeur=self.valeur
- old_val=self.val
-
- self.valeur = new_valeur
- self.val = new_valeur
- self.state="modified"
- validite=0
- if self.isvalid():
- validite=1
- elif self.definition.validators :
- validite=self.definition.validators.valide_liste_partielle(new_valeur)
-
- if validite==0:
- min,max=self.get_min_max()
- if len(new_valeur) < min :
- validite=1
-
- self.valeur = old_valeur
- self.val = old_valeur
- self.state="modified"
- self.isvalid()
+ validite=1
+ try:
+ for val in new_valeur:
+ self.typeProto.adapt(val)
+ self.intoProto.adapt(val)
+ #on ne verifie pas la cardinalité
+ if self.definition.validators:
+ validite=self.definition.validators.valide_liste_partielle(new_valeur)
+ except ValError,e:
+ validite=0
+
return validite
def update_condition_bloc(self):
if "VALE" in genea and "DEFI_FONCTION" in genea : return 2
return 0
+ def valide_item(self,item):
+ """Valide un item isolé. Cet item est candidat à l'ajout à la liste existante"""
+ valid=1
+ try:
+ #on verifie le type
+ self.typeProto.adapt(item)
+ #on verifie les choix possibles
+ self.intoProto.adapt(item)
+ #on ne verifie pas la cardinalité
+ if self.definition.validators:
+ valid=self.definition.validators.verif_item(item)
+ except ValError,e:
+ valid=0
+ return valid
+
+ def verif_type(self,item):
+ """Verifie le type d'un item de liste"""
+ try:
+ #on verifie le type
+ self.typeProto.adapt(item)
+ valid=1
+ except ValError,e:
+ valid=0
+ return valid
+
#--------------------------------------------------------------------------------
#ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation
# Elles doivent etre reintegrees des que possible
- def convert_card(self,valeur):
- """
- Cette methode verifie que la cardinalite de valeur est correcte (comprise entre min et max)
- Si c'est le cas elle retourne valeur eventuellement convertie
- Si ce n'est pas le cas, elle leve une exception
- """
-
- adapt = getattr(valeur, '__adapt__', None)
- if adapt is not None:
- # l'objet valeur peut se verifier lui meme
- return adapt(self.convert_card)
-
- min=self.definition.min
- max=self.definition.max
-
- if type(valeur) == types.TupleType and valeur[0] in ('RI','MP'):
- #il s'agit d'un complexe ancienne mode. La cardinalite vaut 1
- length=1
- elif valeur == None :
- # pas de valeur affecte. La cardinalite vaut 0
- length=0
- elif type(valeur) == types.StringType :
- #il s'agit d'une chaine. La cardinalite vaut 1
- length=1
- else:
- try:
- # si l'objet supporte len, on a la cardinalite
- length=len(valeur)
- except:
- # sinon elle vaut 1
- length=1
-
- if length < min or length >max:
- raise ValidException("Nombre d'arguments de %s incorrect pour %s (min = %s, max = %s)" % (repr(valeur),self.nom,min,max) )
-
- return valeur
-
- def verif_card(self,cr='non'):
- """
- un mot-clé simple ne peut etre répété :
- la cardinalité ici s'entend par la vérification que le nombre d'arguments de self.valeur
- est bien compris entre self.min et self.max dans le cas où il s'agit d'une liste
- """
- card = 1
- try:
- self.convert_card(self.valeur)
- except ValidException,e:
- if cr == 'oui': self.cr.fatal(str(e))
- card = 0
- return card
-
- def convert_into(self,valeur):
- """
- Cette methode verifie que valeur est dans la liste des valeurs possibles donnée
- dans la definition (attribut into) ou dans un intervalle donné dans la definition (attributs
- val_min, val_max)
- Si c'est le cas elle retourne valeur eventuellement convertie
- Si ce n'est pas le cas, elle leve une exception
- """
- adapt = getattr(valeur, '__adapt__', None)
- if adapt is not None:
- # l'objet valeur peut se verifier lui meme
- return adapt(self.convert_into)
-
- if type(valeur) == types.TupleType and not valeur[0] in ('RI','MP') or type(valeur) == types.ListType:
- # Cas d'une liste de valeurs
- # on s'arrete a la premiere erreur
- for val in valeur:
- self.convert_into(val)
- return valeur
-
- # Cas d'un scalaire
- if self.definition.into == None :
- #on est dans le cas d'un ensemble continu de valeurs possibles (intervalle)
- if type(valeur) in (types.IntType,types.FloatType,types.LongType) :
- min = self.definition.val_min
- max = self.definition.val_max
- if min == '**': min = valeur -1
- if max == '**': max = valeur +1
- if valeur < min or valeur > max :
- raise ValidException("La valeur : %s du mot-clé %s est en dehors du domaine de validité [ %s , %s ]" % (repr(valeur),self.nom,min,max) )
- return valeur
- else :
- # on est dans le cas d'un ensemble discret de valeurs possibles (into)
- if valeur not in self.definition.into:
- raise ValidException("La valeur : %s n'est pas permise pour le mot-clé : %s" % (repr(valeur),self.nom) )
- return valeur
-
- 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
- """
- into = 1
- try:
- self.convert_into(self.valeur)
- except ValidException,e:
- if cr == 'oui': self.cr.fatal(str(e))
- into = 0
- return into
-
- def convert_type(self,valeur):
- """
- Cette methode verifie que valeur est du bon type
- Si c'est le cas elle retourne valeur eventuellement convertie
- Si ce n'est pas le cas, elle leve une exception
- """
- if self.definition.type is None: return valeur
-
- if valeur == None :
- raise ValidException("None n'est pas une valeur autorisée")
-
- adapt = getattr(valeur, '__adapt__', None)
- if adapt is not None:
- # l'objet valeur peut se verifier lui meme
- return adapt(self.convert_type)
-
- if type(valeur) == types.TupleType and not valeur[0] in ('RI','MP') or type(valeur) == types.ListType:
- # Cas d'une liste de valeurs
- # on s'arrete a la premiere erreur
- for val in valeur:
- self.convert_type(val)
- return valeur
-
- # Ici, valeur est un scalaire ...il faut tester sur tous les types ou les valeurs possibles
- for type_permis in self.definition.type:
- if self.check_type(valeur,type_permis) : return valeur
- # si on sort de la boucle précédente par ici c'est que l'on n'a trouvé aucun type valable --> valeur refusée
- raise ValidException("%s n'est pas d'un type autorisé" % repr(valeur))
-
- def check_type(self,valeur,type_permis):
- """
- Fonction booléenne qui retourne 1 si valeur est du type type_permis, 0 sinon
- """
- if type_permis == 'R':
- return self.is_reel(valeur)
- elif type_permis == 'I':
- return self.is_entier(valeur)
- elif type_permis == 'C':
- return self.is_complexe(valeur)
- elif type_permis == 'TXM':
- return type(valeur)==types.StringType
- elif type(type_permis) == types.ClassType:
- return self.is_object_from(valeur,type_permis)
- elif type(type_permis) == types.InstanceType:
- try:
- return type_permis.__convert__(valeur) is not None
- except:
- return 0
- elif type_permis == 'shell':
- return self.is_shell(valeur)
- else:
- print "Type non encore géré %s" %`type_permis`
- print self.nom,self.parent.nom,self.jdc.fichier
- return 0
-
- def is_complexe(self,valeur):
- """ Retourne 1 si valeur est un complexe, 0 sinon """
- if type(valeur) in (types.ComplexType,types.IntType,types.FloatType,types.LongType):
- # Pour permettre l'utilisation de complexes Python
- return 1
- elif type(valeur) != types.TupleType :
- # On n'autorise pas les listes pour les complexes
- return 0
- elif len(valeur) != 3:return 0
- else:
- # Un complexe doit etre un tuple de longueur 3 avec 'RI' ou 'MP' comme premiere
- # valeur suivie de 2 reels.
- if string.strip(valeur[0]) in ('RI','MP'):
- try:
- v1=self.convert_reel(valeur[1]),self.convert_reel(valeur[2])
- return 1
- except:
- return 0
- else:
- return 0
-
- def convert_reel(self,valeur):
- try:
- return float(valeur)
- except:
- adapt = getattr(valeur, '__adapt__', None)
- if adapt is not None:
- # l'objet valeur peut se verifier lui meme
- return adapt(self.convert_reel)
- raise ValidException("%s n'est pas un reel" % repr(valeur))
-
- def is_reel(self,valeur):
- """
- Retourne 1 si valeur est un reel, 0 sinon
- """
- if 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) not in (types.IntType,types.LongType):
- # ce n'est pas un entier
- return 0
- else:
- return 1
-
- def is_shell(self,valeur):
- """
- Retourne 1 si valeur est un shell, 0 sinon
- Pour l'instant aucune vérification n'est faite
- On impose juste que valeur soit une string
- """
- if type(valeur) != types.StringType:
- return 0
- else:
- return 1
-
- def is_object_from(self,objet,classe):
- """
- Retourne 1 si objet est une instance de la classe classe, 0 sinon
- """
- convert = getattr(classe, '__convert__', None)
- if convert is not None:
- # classe verifie les valeurs
- try:
- v= convert(objet)
- if v is None:return 0
- else:return 1
- except:
- return 0
- if type(objet) != types.InstanceType :
- return 0
- if isinstance(objet,classe) :
- # On accepte les instances de la classe et des classes derivees
- return 1
-
- return 0
-
- def verif_type(self,val=None,cr='non'):
- """
- FONCTION :
- Cette methode verifie que le type de l'argument val est en conformite avec celui
- qui est declare dans la definition du mot cle simple.
- Elle a plusieurs modes de fonctionnement liés à la valeur de cr.
- Si cr vaut 'oui' : elle remplit le compte-rendu self.cr sinon elle ne le remplit pas.
- PARAMETRE DE RETOUR :
- Cette méthode retourne une valeur booléenne qui vaut 1 si le type de val est correct ou 0 sinon
-
- """
- try:
- self.convert_type(val)
- return 1
- except ValidException,e:
- if cr == 'oui': self.cr.fatal(str(e))
- return 0
-
- def isvalid_BAK(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:
- valid = 1
- v=self.valeur
- # verification 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:
- try:
- self.definition.validators.convert(self.valeur)
- except ValidException,e:
- 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
-
-
def verif_typeihm(self,val,cr='non'):
try :
val.eval()
