Extensions/parametre.py

   1 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   2 # ======================================================================
   3 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   4 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   5 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   6 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   7 # (AT YOUR OPTION) ANY LATER VERSION.
   8 #
   9 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  10 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  11 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  12 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  13 #
  14 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  15 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  16 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  17 #
  18 #
  19 # ======================================================================
  20 """
  21     Ce module contient la classe PARAMETRE qui sert à définir
  22     des objets paramètres qui sont compréhensibles et donc affichables
  23     par EFICAS.
  24     Ces objets sont créés à partir de la modification du fichier de commandes
  25     de l'utilisateur par le parseur de fichiers Python
  26 """
  27
  28 # import de modules Python
  29 import string,types
  30
  31 # import de modules Eficas
  32 from Noyau.N_CR import CR
  33
  34 class PARAMETRE :
  35   """
  36      Cette classe permet de créer des objets de type PARAMETRE
  37      cad des affectations directes dans le jeu de commandes (ex: a=10.)
  38      qui sont interprétées par le parseur de fichiers Python.
  39      Les objets ainsi créés constituent des paramètres pour le jdc
  40   """
  41
  42   nature = 'PARAMETRE'
  43   idracine = 'param'
  44
  45   def __init__(self,nom,valeur=None):
  46     # parent ne peut être qu'un objet de type JDC
  47     self.valeur = self.interprete_valeur(valeur)
  48     self.val=valeur
  49     self.nom = nom
  50     # La classe PARAMETRE n'a pas de définition : on utilise self pour
  51     # complétude
  52     self.definition=self
  53     self.jdc = self.parent = CONTEXT.get_current_step()
  54     self.niveau=self.parent.niveau
  55     self.actif=1
  56     self.state='undetermined'
  57     self.register()
  58
  59   def interprete_valeur(self,val):
  60     """
  61     Essaie d'interpréter val (chaîne de caractères)comme :
  62     - un entier
  63     - un réel
  64     - une chaîne de caractères
  65     - une liste d'items d'un type qui précède
  66     Retourne la valeur interprétée
  67     """
  68     if not val : return None
  69     valeur = None
  70     #  on vérifie si val est un entier
  71     try :
  72         valeur = string.atoi(val)       # on a un entier
  73         return valeur
  74     except :
  75         pass
  76     #  on vérifie si val est un réel
  77     try:
  78         valeur = string.atof(val)   # on a un réel
  79         return valeur
  80     except :
  81         pass
  82     # on vérifie si val est un tuple
  83     try :
  84         valeur = eval(val)
  85     except:
  86         pass
  87     if valeur != None :
  88         if type(valeur) == types.TupleType:
  89             l_new_val = []
  90             typ = None
  91             for v in valeur :
  92                 if not typ:
  93                     typ = type(v)
  94                 else:
  95                     if type(v) != typ :
  96                         # la liste est hétérogène --> on refuse d'interpréter
  97                         #  self comme une liste
  98                         # on retourne la string initiale
  99                         print 'liste hétérogène ',val
 100                         return val
 101                 l_new_val.append(v)
 102             return tuple(l_new_val)
 103         else:
 104             # on a réussi à évaluer val en autre chose qu'un tuple ...
 105             print "on a réussi à évaluer %s en autre chose qu'un tuple ..." %val
 106             print 'on trouve : ',str(valeur),' de type : ',type(valeur)
 107     # on retourne val comme une string car on n'a pas su l'interpréter
 108     return val
 109
 110   def set_valeur(self,new_valeur):
 111     """
 112     Remplace la valeur de self par new_valeur interprétée
 113     """
 114     self.valeur = self.interprete_valeur(new_valeur)
 115     self.init_modif()
 116
 117   def init_modif(self):
 118     """
 119     Méthode qui déclare l'objet courant comme modifié et propage
 120     cet état modifié à ses ascendants
 121     """
 122     self.state = 'modified'
 123     if self.parent:
 124       self.parent.init_modif()
 125
 126   def register(self):
 127     """
 128     Enregistre le paramètre dans la liste des étapes de son parent (JDC)
 129     """
 130     self.parent.register_parametre(self)
 131     self.parent.register(self)
 132
 133   def isvalid(self,cr='non'):
 134     """
 135     Retourne 1 si self est valide, 0 sinon
 136     Un paramètre est considéré comme valide si :
 137       - il a un nom
 138       - il a une valeur
 139     """
 140     if self.nom == '' :
 141         if cr == 'oui':
 142            self.cr.fatal("Pas de nom donné au paramètre ")
 143         return 0
 144     else:
 145         if self.valeur == None :
 146             if cr == 'oui' :
 147                self.cr.fatal("Le paramètre %s ne peut valoir None" % self.nom)
 148             return 0
 149     return 1
 150
 151   def isoblig(self):
 152     """
 153     Indique si self est obligatoire ou non : retourne toujours 0
 154     """
 155     return 0
 156
 157   def isrepetable(self):
 158     """
 159     Indique si self est répétable ou non : retourne toujours 1
 160     """
 161     return 1
 162
 163   def liste_mc_presents(self):
 164     return []
 165
 166   def supprime(self):
 167     """
 168     Méthode qui supprime toutes les boucles de références afin que
 169     l'objet puisse être correctement détruit par le garbage collector
 170     """
 171     self.parent = None
 172     self.jdc = None
 173     self.definition=None
 174
 175   def active(self):
 176     """
 177     Rend l'etape courante active.
 178     Il faut ajouter le paramètre au contexte global du JDC
 179     """
 180     self.actif = 1
 181     try:
 182         self.jdc.append_param(self)
 183     except:
 184         pass
 185
 186   def inactive(self):
 187     """
 188     Rend l'etape courante inactive
 189     Il faut supprimer le paramètre du contexte global du JDC
 190     """
 191     self.actif = 0
 192     self.jdc.del_param(self)
 193     self.jdc.delete_concept_after_etape(self,self)
 194
 195   def isactif(self):
 196     """
 197     Booléenne qui retourne 1 si self est actif, 0 sinon
 198     """
 199     return self.actif
 200
 201   def set_attribut(self,nom_attr,new_valeur):
 202     """
 203     Remplace la valeur de self.nom_attr par new_valeur)
 204     """
 205     if hasattr(self,nom_attr):
 206       setattr(self,nom_attr,new_valeur)
 207       self.init_modif()
 208
 209   def supprime_sdprods(self):
 210     """
 211     Il faut supprimer le paramètre qui a été entré dans la liste des
 212     paramètres du JDC
 213     """
 214     self.jdc.delete_param(self)
 215
 216   def update_context(self,d):
 217     """
 218     Update le dictionnaire d avec le paramètre que produit self
 219     """
 220     d[self.nom]=self
 221
 222   def __repr__(self):
 223     """
 224         Donne un echo de self sous la forme nom = valeur
 225     """
 226     return self.nom+' = '+str(self.valeur)
 227
 228   def __str__(self):
 229     """
 230         Retourne le nom du paramètre comme représentation de self
 231     """
 232     return self.nom
 233
 234   def get_sdprods(self,nom_sd):
 235      """
 236          Retourne les concepts produits par la commande
 237      """
 238      return None
 239
 240   def report(self):
 241     """ Génère l'objet rapport (classe CR) """
 242     self.cr=CR()
 243     self.isvalid(cr='oui')
 244     return self.cr
 245
 246   def ident(self):
 247     """
 248     Retourne le nom interne associé à self
 249     Ce nom n'est jamais vu par l'utilisateur dans EFICAS
 250     """
 251     return self.nom
 252
 253   def delete_concept(self,sd):
 254     pass
 255
 256   def replace_concept(self,old_sd,sd):
 257     pass
 258
 259   def verif_condition_bloc(self):
 260     """
 261         Evalue les conditions de tous les blocs fils possibles
 262         (en fonction du catalogue donc de la définition) de self et
 263         retourne deux listes :
 264           - la première contient les noms des blocs à rajouter
 265           - la seconde contient les noms des blocs à supprimer
 266     """
 267     return [],[]
 268
 269   def verif_condition_regles(self,liste_presents):
 270     """
 271         Retourne la liste des mots-clés à rajouter pour satisfaire les règles
 272         en fonction de la liste des mots-clés présents
 273     """
 274     return []
 275
 276   def verif_existence_sd(self):
 277      pass
 278
 279   def control_sdprods(self,d):
 280       """sans objet """
 281       pass
 282
 283
 284
 285