Validation/V_MCSIMP.py

   1 #@ MODIF V_MCSIMP Validation  DATE 06/10/2003   AUTEUR DURAND C.DURAND
   2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   8 # (AT YOUR OPTION) ANY LATER VERSION.
   9 #
  10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  14 #
  15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  17 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  18 #
  19 #
  20 # ======================================================================
  21 """
  22    Ce module contient la classe mixin MCSIMP qui porte les méthodes
  23    nécessaires pour réaliser la validation d'un objet de type MCSIMP
  24    dérivé de OBJECT.
  25
  26    Une classe mixin porte principalement des traitements et est
  27    utilisée par héritage multiple pour composer les traitements.
  28 """
  29 # Modules Python
  30 import string,types
  31 import traceback
  32
  33 # Modules EFICAS
  34 from Noyau import N_CR
  35 from Noyau.N_Exception import AsException
  36
  37 class MCSIMP:
  38    """
  39       COMMENTAIRE CCAR
  40         Cette classe est quasiment identique à la classe originale d'EFICAS
  41         a part quelques changements cosmétiques et des chagements pour la
  42         faire fonctionner de facon plus autonome par rapport à l'environnement
  43         EFICAS
  44
  45         A mon avis, il faudrait aller plus loin et réduire les dépendances
  46         amont au strict nécessaire.
  47
  48         - Est il indispensable de faire l'évaluation de la valeur dans le contexte
  49           du jdc dans cette classe.
  50
  51         - Ne pourrait on pas doter les objets en présence des méthodes suffisantes
  52           pour éviter les tests un peu particuliers sur GEOM, PARAMETRE et autres. J'ai
  53           d'ailleurs modifié la classe pour éviter l'import de GEOM
  54    """
  55
  56    CR=N_CR.CR
  57
  58    def __init__(self):
  59       self.state='undetermined'
  60
  61    def isvalid(self,cr='non'):
  62       """
  63          Cette méthode retourne un indicateur de validité de l'objet
  64          de type MCSIMP
  65
  66          - 0 si l'objet est invalide
  67
  68          - 1 si l'objet est valide
  69
  70          Le pramètre cr permet de paramétrer le traitement. Si cr == 'oui'
  71          la méthode construit également un comte-rendu de validation
  72          dans self.cr qui doit avoir été créé préalablement.
  73       """
  74       if self.state == 'unchanged':
  75         return self.valid
  76       else:
  77         valid = 1
  78         if hasattr(self,'valid'):
  79           old_valid = self.valid
  80         else:
  81           old_valid = None
  82         v=self.valeur
  83         #  presence
  84         if self.isoblig() and v == None :
  85           if cr == 'oui' :
  86             self.cr.fatal(string.join(("Mot-clé : ",self.nom," obligatoire non valorisé")))
  87           valid = 0
  88         if v is None:
  89            if cr == 'oui' :
  90               self.cr.fatal("None n'est pas une valeur autorisée")
  91            valid=0
  92         else:
  93            # type,into ...
  94            valid = self.verif_type(val=v,cr=cr)*self.verif_into(cr=cr)*self.verif_card(cr=cr)
  95            #
  96            # On verifie les validateurs s'il y en a
  97            #
  98            if self.definition.validators and not self.definition.validators.verif(self.valeur):
  99               if cr == 'oui' :
 100                  self.cr.fatal(string.join(("Mot-clé : ",self.nom,"devrait avoir ",self.definition.validators.info())))
 101               valid=0
 102            # fin des validateurs
 103            #
 104         self.valid = valid
 105         self.state = 'unchanged'
 106         # Si la validité du mot clé a changé, on le signale à l'objet parent
 107         if not old_valid or old_valid != self.valid :
 108            self.init_modif_up()
 109         return self.valid
 110
 111    def isoblig(self):
 112       """ indique si le mot-clé est obligatoire
 113       """
 114       return self.definition.statut=='o'
 115
 116    def verif_card(self,cr='non'):
 117       """
 118          un mot-clé simple ne peut etre répété :
 119            la cardinalité ici s'entend par la vérification que le nombre d'arguments de self.valeur
 120            est bien compris entre self.min et self.max dans le cas où il s'agit d'une liste
 121       """
 122       card = 1
 123       min=self.definition.min
 124       max=self.definition.max
 125       if type(self.valeur) in (types.ListType,types.TupleType) and 'C' not in self.definition.type :
 126         if len(self.valeur) < min or len(self.valeur)>max:
 127           if cr == 'oui':
 128             self.cr.fatal("Nombre d'arguments %s incorrects pour %s (min = %s, max = %s)" %(`self.valeur`,self.nom,min,max))
 129           card = 0
 130       else:
 131         if self.valeur == None :
 132           if min >= 1 :
 133             # on n'a pas d'objet et on en attend au moins un
 134             card=0
 135         else :
 136           if min > 1:
 137             # on n'a qu'un objet et on en attend plus d'1
 138             card = 0
 139       return card
 140
 141    def verif_type(self,val=None,cr='non'):
 142       """
 143         FONCTION :
 144          Cette methode verifie que le type de l'argument val est en conformite avec celui
 145          qui est declare dans la definition du mot cle simple.
 146          Elle a plusieurs modes de fonctionnement liés à la valeur de cr.
 147          Si cr vaut 'oui' : elle remplit le compte-rendu self.cr sinon elle ne le remplit pas.
 148         PARAMETRE DE RETOUR :
 149          Cette méthode retourne une valeur booléenne qui vaut 1 si le type de val est correct ou 0 sinon
 150
 151       """
 152       valeur = val
 153       if valeur == None :
 154         if cr == 'oui':
 155           self.cr.fatal("None n'est pas une valeur autorisée")
 156         return 0
 157       if type(valeur) == types.TupleType:
 158         # on peut avoir à faire à un complexe ou une liste de valeurs ...
 159         if self.is_complexe(valeur) : return 1
 160         else:
 161           for val in valeur:
 162             if not self.verif_type(val=val,cr=cr) : return 0
 163           return 1
 164       elif type(valeur) == types.ListType:
 165         for val in valeur:
 166             if not self.verif_type(val=val,cr=cr) : return 0
 167         return 1
 168       else:
 169         # on n'a pas de tuple ...il faut tester sur tous les types ou les valeurs possibles
 170         # XXX Pourquoi into est il traité ici et pas seulement dans verif_into ???
 171         if self.definition.into != None :
 172           try:
 173             if valeur in self.definition.into :
 174               return 1
 175             else:
 176               if cr == 'oui':
 177                 self.cr.fatal("%s n'est pas une valeur autorisée" %valeur)
 178               return 0
 179           except:
 180             print "problème avec :",self.nom
 181             print 'valeur =',valeur
 182             return 0
 183         for type_permis in self.definition.type:
 184           if self.compare_type(valeur,type_permis) : return 1
 185         # 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
 186         if cr =='oui':
 187           self.cr.fatal("%s n'est pas d'un type autorisé" %`valeur`)
 188         return 0
 189
 190    def verif_into(self,cr='non'):
 191       """
 192       Vérifie si la valeur de self est bien dans l'ensemble discret de valeurs
 193       donné dans le catalogue derrière l'attribut into ou vérifie que valeur est bien compris
 194       entre val_min et val_max
 195       """
 196       if self.definition.into == None :
 197         #on est dans le cas d'un ensemble continu de valeurs possibles (intervalle)
 198         if type(self.valeur)==types.TupleType :
 199           test = 1
 200           for val in self.valeur :
 201             if type(val)!=types.StringType and type(val)!=types.InstanceType:
 202               test = test*self.isinintervalle(val,cr=cr)
 203           return test
 204         else :
 205           val = self.valeur
 206           if type(val)!=types.StringType and type(val)!=types.InstanceType:
 207             return self.isinintervalle(self.valeur,cr=cr)
 208           else :
 209             return 1
 210       else :
 211         # on est dans le cas d'un ensemble discret de valeurs possibles (into)
 212         if type(self.valeur) == types.TupleType :
 213           for e in self.valeur:
 214             if e not in self.definition.into:
 215               if cr=='oui':
 216                 self.cr.fatal(string.join(("La valeur :",`e`," n'est pas permise pour le mot-clé :",self.nom)))
 217               return 0
 218         else:
 219           if self.valeur == None or self.valeur not in self.definition.into:
 220             if cr=='oui':
 221               self.cr.fatal(string.join(("La valeur :",`self.valeur`," n'est pas permise pour le mot-clé :",self.nom)))
 222             return 0
 223         return 1
 224
 225    def is_complexe(self,valeur):
 226       """ Retourne 1 si valeur est un complexe, 0 sinon """
 227       if type(valeur) == types.StringType :
 228         # on teste une valeur issue d'une entry (valeur saisie depuis EFICAS)
 229         #XXX Il serait peut etre plus judicieux d'appeler une méthode de self.jdc
 230         #XXX qui retournerait l'objet résultat de l'évaluation
 231         #XXX ou meme de faire cette evaluation a l'exterieur de cette classe ??
 232         if not self.jdc :return 0
 233         try :
 234           valeur = eval(valeur,self.jdc.g_context)
 235         except:
 236           return 0
 237       if type(valeur) == types.InstanceType :
 238         #XXX je n'y touche pas pour ne pas tout casser mais il serait
 239         #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('C'), par exemple
 240         if valeur.__class__.__name__ in ('EVAL','complexe'):
 241           return 1
 242         elif valeur.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
 243           # il faut tester si la valeur du parametre est un entier
 244           #XXX ne serait ce pas plutot complexe ???? sinon expliquer
 245           return self.is_entier(valeur.valeur)
 246         else:
 247           print "Objet non reconnu dans is_complexe %s" %`valeur`
 248           return 0
 249       # Pour permettre l'utilisation de complexes Python
 250       #elif type(valeur) == types.ComplexType:
 251         #return 1
 252       elif type(valeur) != types.TupleType :
 253         return 0
 254       else:
 255         if len(valeur) != 3 :
 256           return 0
 257         else:
 258           if type(valeur[0]) != types.StringType : return 0
 259           if string.strip(valeur[0]) not in ('RI','MP'):
 260             return 0
 261           else:
 262             if not self.is_reel(valeur[1]) or not self.is_reel(valeur[2]) : return 0
 263             else: return 1
 264
 265    def is_reel(self,valeur):
 266       """
 267       Retourne 1 si valeur est un reel, 0 sinon
 268       """
 269       if type(valeur) == types.StringType :
 270         # on teste une valeur issue d'une entry (valeur saisie depuis EFICAS)
 271         if not self.jdc :return 0
 272         try :
 273           valeur = eval(valeur,self.jdc.g_context)
 274         except:
 275           return 0
 276       if type(valeur) == types.InstanceType :
 277         #XXX je n'y touche pas pour ne pas tout casser mais il serait
 278         #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('R'), par exemple
 279         #XXX ou valeur.is_reel()
 280         #XXX ou encore valeur.compare(self.is_reel)
 281         if valeur.__class__.__name__ in ('EVAL','reel') :
 282           return 1
 283         elif valeur.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
 284           # il faut tester si la valeur du parametre est un réel
 285           return self.is_reel(valeur.valeur)
 286         else:
 287           print "Objet non reconnu dans is_reel %s" %`valeur`
 288           return 0
 289       elif type(valeur) not in (types.IntType,types.FloatType,types.LongType):
 290         # ce n'est pas un réel
 291         return 0
 292       else:
 293         return 1
 294
 295    def is_entier(self,valeur):
 296       """ Retourne 1 si valeur est un entier, 0 sinon """
 297       if type(valeur) == types.StringType :
 298         # on teste une valeur issue d'une entry (valeur saisie depuis EFICAS)
 299         if not self.jdc :return 0
 300         try :
 301           valeur = eval(valeur,self.jdc.g_context)
 302         except:
 303           return 0
 304       if type(valeur) == types.InstanceType :
 305         #XXX je n'y touche pas pour ne pas tout casser mais il serait
 306         #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('I'), par exemple
 307         if valeur.__class__.__name__ in ('EVAL','entier') :
 308           return 1
 309         elif valeur.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
 310           # il faut tester si la valeur du parametre est un entier
 311           return self.is_entier(valeur.valeur)
 312         else:
 313           print "Objet non reconnu dans is_reel %s" %`valeur`
 314           return 0
 315       elif type(valeur) not in (types.IntType,types.LongType):
 316         # ce n'est pas un entier
 317         return 0
 318       else:
 319         return 1
 320
 321    def is_shell(self,valeur):
 322       """
 323           Retourne 1 si valeur est un shell, 0 sinon
 324           Pour l'instant aucune vérification n'est faite
 325           On impose juste que valeur soit une string
 326       """
 327       if type(valeur) != types.StringType:
 328         return 0
 329       else:
 330         return 1
 331
 332    def is_object_from(self,objet,classe):
 333       """
 334            Retourne 1 si valeur est un objet de la classe classe ou d'une sous-classe de classe,
 335            0 sinon
 336       """
 337       if type(objet) != types.InstanceType :
 338         if type(objet) == types.StringType:
 339           if not self.jdc :return 0
 340           try :
 341             objet = eval(objet,self.jdc.g_context)
 342             if type(objet) != types.InstanceType : return 0
 343           except:
 344             return 0
 345         else:
 346           return 0
 347       if not objet.__class__ == classe and not issubclass(objet.__class__,classe):
 348         return 0
 349       else:
 350         return 1
 351
 352    def compare_type(self,valeur,type_permis):
 353       """
 354           Fonction booléenne qui retourne 1 si valeur est du type type_permis, 0 sinon
 355       """
 356       if type(valeur) == types.InstanceType and valeur.__class__.__name__ == 'PARAMETRE':
 357         if type(valeur.valeur) == types.TupleType :
 358           # on a à faire à un PARAMETRE qui définit une liste d'items
 359           # --> on teste sur la première car on n'accepte que les liste homogènes
 360           valeur = valeur.valeur[0]
 361       if type_permis == 'R':
 362         return self.is_reel(valeur)
 363       elif type_permis == 'I':
 364         return self.is_entier(valeur)
 365       elif type_permis == 'C':
 366         return self.is_complexe(valeur)
 367       elif type_permis == 'shell':
 368         return self.is_shell(valeur)
 369       elif type_permis == 'TXM':
 370         if type(valeur) != types.InstanceType:
 371           return type(valeur)==types.StringType
 372         else:
 373           #XXX je n'y touche pas pour ne pas tout casser mais il serait
 374           #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('TXM'), par exemple
 375           if valeur.__class__.__name__ == 'chaine' :
 376             return 1
 377           elif valeur.__class__.__name__ == 'PARAMETRE':
 378             # il faut tester si la valeur du parametre est une string
 379             return type(valeur.valeur)==types.StringType
 380           else:
 381             return 0
 382       elif type(type_permis) == types.ClassType:
 383         # on ne teste pas certains objets de type GEOM , assd, ...
 384         # On appelle la méthode de classe is_object de type_permis.
 385         # Comme valeur peut etre de n'importe quel type on utilise la fonction (is_object.im_func)
 386         # et non pas la methode (is_object) ce qui risquerait de provoquer des erreurs
 387         if type_permis.is_object.im_func(valeur):
 388           return 1
 389         else :
 390           return self.is_object_from(valeur,type_permis)
 391       else:
 392         print "Type non encore géré %s" %`type_permis`
 393         print self.nom,self.parent.nom,self.jdc.fichier
 394
 395    def isinintervalle(self,valeur,cr='non'):
 396       """
 397       Booléenne qui retourne 1 si la valeur passée en argument est comprise dans
 398       le domaine de définition donné dans le catalogue, 0 sinon.
 399       """
 400       if type(valeur) not in (types.IntType,types.FloatType,types.LongType) :
 401         return 1
 402       else :
 403         min = self.definition.val_min
 404         max = self.definition.val_max
 405         if min == '**': min = valeur -1
 406         if max == '**': max = valeur +1
 407         if valeur < min or valeur > max :
 408           if cr=='oui':
 409             self.cr.fatal(string.join(("La valeur :",`valeur`," du mot-clé ",self.nom,\
 410                                        " est en dehors du domaine de validité [",`min`,",",`max`,"]")))
 411           return 0
 412         else :
 413           return 1
 414
 415    def init_modif_up(self):
 416       """
 417          Propage l'état modifié au parent s'il existe et n'est l'objet
 418          lui-meme
 419       """
 420       if self.parent and self.parent != self :
 421         self.parent.state = 'modified'
 422
 423    def report(self):
 424       """ génère le rapport de validation de self """
 425       self.cr=self.CR()
 426       self.cr.debut = "Mot-clé simple : "+self.nom
 427       self.cr.fin = "Fin Mot-clé simple : "+self.nom
 428       self.state = 'modified'
 429       try:
 430         self.isvalid(cr='oui')
 431       except AsException,e:
 432         if CONTEXT.debug : traceback.print_exc()
 433         self.cr.fatal(string.join(("Mot-clé simple : ",self.nom,str(e))))
 434       return self.cr
 435
 436
 437
 438
 439
 440