Extensions/parametre.py

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