Ihm/I_ETAPE.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 """
  22 # Modules Python
  23 import string,types
  24 from copy import copy
  25
  26 # import rajoutés suite à l'ajout de Build_sd --> à résorber
  27 import traceback
  28 import Noyau
  29 from Noyau import N_Exception
  30 from Noyau.N_Exception import AsException
  31 # fin import à résorber
  32
  33 # Modules EFICAS
  34 import I_MCCOMPO
  35
  36 class ETAPE(I_MCCOMPO.MCCOMPO):
  37
  38    def ident(self):
  39       return self.nom
  40
  41    def get_sdname(self):
  42       if CONTEXT.debug : print "SDNAME ",self.reuse,self.sd,self.sd.get_name()
  43       if self.reuse != None:
  44         sdname= self.reuse.get_name()
  45       else:
  46         sdname=self.sd.get_name()
  47       if string.find(sdname,'sansnom') != -1 or string.find(sdname,'SD_') != -1:
  48         # dans le cas où la SD est 'sansnom' ou 'SD_' on retourne la chaîne vide
  49         return ''
  50       return sdname
  51
  52    def is_reentrant(self):
  53       """
  54           Indique si la commande est reentrante
  55       """
  56       return self.definition.reentrant == 'o'
  57
  58    def init_modif(self):
  59       """
  60          Met l'état de l'étape à : modifié
  61          Propage la modification au parent
  62          Si la fonction op_init existe, l'active
  63       """
  64       # Une action
  65       # doit etre realisée apres init_modif et la validite reevaluée
  66       # apres cette action. L'état modified de tous les objets doit etre
  67       # preservé.
  68       self.state = 'modified'
  69       if self.parent:
  70         self.parent.init_modif()
  71
  72    def fin_modif(self):
  73       """
  74           Méthode appelée une fois qu'une modification a été faite afin de
  75           déclencher d'éventuels traitements post-modification
  76           ex : INCLUDE et POURSUITE
  77       """
  78       if self.isvalid() :
  79          if type(self.definition.op_init) == types.FunctionType :
  80             # XXX Normalement en mode editeur g_context ne peut pas etre utilisé
  81             apply(self.definition.op_init,(self,self.parent.g_context))
  82       self.state = 'modified'
  83
  84    def nomme_sd(self,nom) :
  85       """
  86           Cette méthode a pour fonction de donner un nom (nom) au concept
  87           produit par l'étape (self).
  88           - si le concept n'existe pas, on essaye de le créer (à condition que l'étape soit valide ET non réentrante)
  89           - si il existe déjà, on le renomme et on répercute les changements dans les autres étapes
  90           Les valeurs de retour sont :
  91            0 si le nommage n'a pas pu etre mené à son terme,
  92            1 dans le cas contraire
  93       """
  94       if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
  95         return 0,"Nom de concept trop long (maxi 8 caractères)"
  96       self.init_modif()
  97       #
  98       # On verifie d'abord si les mots cles sont valides
  99       #
 100       if not self.isvalid(sd='non') : return 0,"Nommage du concept refusé : l'opérateur n'est pas valide"
 101       #
 102       # Cas particulier des opérateurs obligatoirement réentrants
 103       #
 104       if self.definition.reentrant == 'o':
 105         self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
 106         if self.sd != None :
 107           self.sdnom=self.sd.nom
 108           return 1,"Concept existant"
 109         else:
 110           return 0,"Opérateur réentrant mais concept non existant"
 111       #
 112       # Cas particulier des opérateurs facultativement réentrants
 113       #
 114       old_reuse=None
 115       if self.definition.reentrant == 'f' :
 116         sd = self.jdc.get_sd_avant_etape(nom,self)
 117         if sd != None :
 118           # FR : il faut tester que la sd trouvée est du bon type !!!!!!!!!!!!!!!!!
 119           if isinstance(sd,self.get_type_produit()) :
 120              self.sd = self.reuse = sd
 121              self.sdnom = sd.nom
 122              return 1,"Opérateur facultativement réentrant et concept existant trouvé"
 123           else:
 124              return 0,"Concept déjà existant et de mauvais type"
 125         else :
 126           # il faut enlever le lien vers une SD existante car si on passe ici
 127           # cela signifie que l'opérateur n'est pas utilisé en mode réentrant.
 128           # Si on ne fait pas cela, on risque de modifier une SD produite par un autre opérateur
 129           if self.reuse :
 130              old_reuse=self.reuse
 131              self.sd = self.reuse = self.sdnom = None
 132       #
 133       # On est dans le cas ou l'opérateur n'est pas réentrant ou est facultativement reentrant
 134       # mais est utilisé en mode non réentrant
 135       #
 136       if self.sd == None :
 137           if self.parent.get_sd_autour_etape(nom,self):
 138             # Un concept de ce nom existe dans le voisinage de l'etape courante
 139             # On retablit l'ancien concept reentrant s'il existait
 140             if old_reuse:
 141                self.sd=self.reuse=old_reuse
 142                self.sdnom=old_reuse.nom
 143             return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
 144           else:
 145             # Il n'existe pas de concept de ce nom dans le voisinage de l'etape courante
 146             # On peut donc créer le concept retourné.
 147             # Il est créé sans nom mais enregistré dans la liste des concepts existants
 148             self.get_sd_prod()
 149             # Il suffit de changer son attribut nom pour le nommer
 150             self.sd.nom = nom
 151             self.sdnom=nom
 152             return 1,"Nommage du concept effectué"
 153       else :
 154           old_nom=self.sd.nom
 155           if string.find(old_nom,'sansnom') :
 156             # Dans le cas où old_nom == sansnom, isvalid retourne 0 alors que ...
 157             # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
 158             # on peut donc le nommer sans test préalable
 159             if self.parent.get_sd_autour_etape(nom,self):
 160               return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
 161             else:
 162               self.sd.nom=nom
 163               self.sdnom=nom
 164               return 1,"Nommage du concept effectué"
 165           if self.isvalid() :
 166             # Normalement l appel de isvalid a mis a jour le concept produit (son type)
 167             # Il suffit de spécifier l attribut nom de sd pour le nommer si le nom n est pas
 168             # deja attribué
 169             if self.parent.get_sd_autour_etape(nom,self):
 170               return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
 171             else:
 172               self.sd.nom=nom
 173               self.sdnom=nom
 174               return 1,"Nommage du concept effectué"
 175           else:
 176             # Normalement on ne devrait pas passer ici
 177             return 0,'Normalement on ne devrait pas passer ici'
 178
 179    def get_sdprods(self,nom_sd):
 180       """
 181          Fonction : retourne le concept produit par l etape de nom nom_sd
 182                     s il existe sinon None
 183       """
 184       if self.sd:
 185         if self.sd.nom == nom_sd:return self.sd
 186
 187    def active(self):
 188       """
 189           Rend l'etape courante active.
 190           Il faut ajouter la sd si elle existe au contexte global du JDC
 191           et à la liste des sd
 192       """
 193       self.actif = 1
 194       if not self.sd : return
 195       # XXX Pourquoi faut-il faire ce qui suit ??? par defaut les etapes sont actives
 196       try:
 197         self.jdc.append_sdprod(self.sd)
 198       except:
 199         pass
 200
 201    def inactive(self):
 202       """
 203           Rend l'etape courante inactive
 204           Il faut supprimer la sd du contexte global du JDC
 205           et de la liste des sd
 206       """
 207       self.actif = 0
 208       if not self.sd : return
 209       self.jdc.del_sdprod(self.sd)
 210       self.jdc.delete_concept_after_etape(self,self.sd)
 211
 212    def supprime_sdprods(self):
 213       """
 214           Fonction:
 215             Lors d'une destruction d'etape, detruit tous les concepts produits
 216             Un opérateur n a qu un concept produit
 217             Une procedure n'en a aucun
 218             Une macro en a en général plus d'un
 219       """
 220       # XXX pour les macros il faudrait peut etre aussi
 221       #     supprimer les concepts a droite du = ???
 222       if not self.is_reentrant() :
 223         # l'étape n'est pas réentrante
 224         # le concept retourné par l'étape est à supprimer car il était
 225         # créé par l'étape
 226         if self.sd != None :
 227           self.parent.del_sdprod(self.sd)
 228           self.parent.delete_concept(self.sd)
 229
 230    def delete_concept(self,sd):
 231       """
 232           Inputs :
 233              sd=concept detruit
 234           Fonction :
 235              Mettre a jour les mots cles de l etape et eventuellement
 236              le concept produit si reuse
 237              suite à la disparition du concept sd
 238              Seuls les mots cles simples MCSIMP font un traitement autre
 239              que de transmettre aux fils
 240       """
 241       if self.reuse and self.reuse == sd:
 242         self.sd=self.reuse=None
 243         self.init_modif()
 244       for child in self.mc_liste :
 245         child.delete_concept(sd)
 246
 247    def make_register(self):
 248       """
 249          Initialise les attributs jdc, id, niveau et réalise les
 250          enregistrements nécessaires
 251          Pour EFICAS, on tient compte des niveaux
 252          Surcharge la methode make_register du package Noyau
 253       """
 254       if self.parent :
 255          self.jdc = self.parent.get_jdc_root()
 256          self.id=   self.parent.register(self)
 257          if self.definition.niveau :
 258             # La définition est dans un niveau. En plus on
 259             # l'enregistre dans le niveau
 260             self.nom_niveau_definition = self.definition.niveau.nom
 261             self.niveau = self.parent.dict_niveaux[self.nom_niveau_definition]
 262             self.niveau.register(self)
 263          else:
 264             # La définition est au niveau global
 265             self.nom_niveau_definition = 'JDC'
 266             self.niveau=self.parent
 267       else:
 268          self.jdc = self.parent =None
 269          self.id=None
 270          self.niveau=None
 271
 272    def copy(self):
 273       """ Méthode qui retourne une copie de self non enregistrée auprès du JDC
 274           et sans sd
 275       """
 276       etape = copy(self)
 277       etape.sd = None
 278       etape.state = 'modified'
 279       etape.reuse = None
 280       etape.sdnom = None
 281       etape.etape=etape
 282       etape.mc_liste=[]
 283       for objet in self.mc_liste:
 284         new_obj = objet.copy()
 285         new_obj.reparent(etape)
 286         etape.mc_liste.append(new_obj)
 287       return etape
 288
 289    def get_noms_sd_oper_reentrant(self):
 290       """
 291           Retourne la liste des noms de concepts utilisés à l'intérieur de la commande
 292           qui sont du type que peut retourner cette commande
 293       """
 294       liste_sd = self.get_sd_utilisees()
 295       l_noms = []
 296       if type(self.definition.sd_prod) == types.FunctionType:
 297         d=self.cree_dict_valeurs(self.mc_liste)
 298         try:
 299           classe_sd_prod = apply(self.definition.sd_prod,(),d)
 300         except:
 301           return []
 302       else:
 303         classe_sd_prod = self.definition.sd_prod
 304       for sd in liste_sd :
 305         if sd.__class__ is classe_sd_prod : l_noms.append(sd.nom)
 306       l_noms.sort()
 307       return l_noms
 308
 309    def get_sd_utilisees(self):
 310       """
 311           Retourne la liste des concepts qui sont utilisés à l'intérieur d'une commande
 312           ( comme valorisation d'un MCS)
 313       """
 314       l=[]
 315       for child in self.mc_liste:
 316         l.extend(child.get_sd_utilisees())
 317       return l
 318
 319    def get_genealogie(self):
 320       """
 321           Retourne la liste des noms des ascendants de l'objet self
 322           en s'arretant à la première ETAPE rencontrée
 323       """
 324       return [self.nom]
 325
 326    def reparent(self,parent):
 327      """
 328          Cette methode sert a reinitialiser la parente de l'objet
 329      """
 330      self.parent=parent
 331      self.jdc=parent.get_jdc_root()
 332      self.etape=self
 333      for mocle in self.mc_liste:
 334         mocle.reparent(self)
 335
 336    def verif_existence_sd(self):
 337      """
 338         Vérifie que les structures de données utilisées dans self existent bien dans le contexte
 339         avant étape, sinon enlève la référence à ces concepts
 340      """
 341      for motcle in self.mc_liste :
 342          motcle.verif_existence_sd()
 343
 344    def Build_sd(self,nom):
 345       """
 346          Construit le concept produit de l'opérateur. Deux cas
 347          peuvent se présenter :
 348
 349          - le parent n'est pas défini. Dans ce cas, l'étape prend en charge la création
 350            et le nommage du concept.
 351
 352          - le parent est défini. Dans ce cas, l'étape demande au parent la création et
 353            le nommage du concept.
 354
 355       """
 356       if not self.isactif():return
 357       # FR : attention cette méthode ne devrait pas se trouver là car elle surcharge celle qui
 358       # se trouve dans N_ETAPE.py et elle est partie intégrante du noyau, mais, suite à l'absence de
 359       # test de validité de l'opérateur avant d'essayer de déterminer la sd produite, on n'arrivait
 360       # pas à relire avec EFICAS un fichier contenant une étape encore incomplète du style :
 361       #  sansnom = AFFE_CHAR_CINE(MODELE=None)
 362       # Suite à la stabilisation du noyau d'Aster, je n'ai pas eu d'autre solution que de surcharger
 363       # cette méthode ici en rajoutant le test manquant ...
 364       # CCAR : cette modification ne corrige le probleme qu'en partie. Il faudrait probablement
 365       # supprimer les erreurs fatales (exception ) et retourner systematiquement un objet produit
 366       # meme en cas d'erreur et reporter l'emission du message d'erreur a la phase de validation
 367       #
 368       if not self.isvalid(sd='non') : return
 369       self.sdnom=nom
 370       try:
 371          if self.parent:
 372             sd= self.parent.create_sdprod(self,nom)
 373             if type(self.definition.op_init) == types.FunctionType:
 374                apply(self.definition.op_init,(self,self.parent.g_context))
 375          else:
 376             sd=self.get_sd_prod()
 377             # On n'utilise pas self.definition.op_init car self.parent
 378             # n'existe pas
 379             if sd != None and self.reuse == None:
 380                # On ne nomme le concept que dans le cas de non reutilisation
 381                # d un concept
 382                sd.nom=nom
 383          if self.jdc and self.jdc.par_lot == "NON" :
 384             self.Execute()
 385          return sd
 386       except AsException,e:
 387          # Une erreur s'est produite lors de la construction du concept
 388          # Comme on est dans EFICAS, on essaie de poursuivre quand meme
 389          # Si on poursuit, on a le choix entre deux possibilités :
 390          # 1. on annule la sd associée à self
 391          # 2. on la conserve mais il faut la retourner
 392          # En plus il faut rendre coherents sdnom et sd.nom
 393          self.sd=None
 394          self.sdnom=None
 395          self.valid=0
 396          return self.sd
 397          #raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
 398          #                     'fichier : ',self.appel[1],e)
 399       except EOFError:
 400          # XXX Normalement le contexte courant doit etre le parent.
 401          # Il n'y a pas de raison de remettre le contexte au parent
 402          #self.reset_current_step()
 403          raise
 404       except :
 405          l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2])
 406          raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
 407                            'fichier : ',self.appel[1]+'\n',
 408                             string.join(l))
 409
 410
 411
 412
 413
 414
 415
 416
 417
 418
 419
 420
 421
 422
 423
 424
 425
 426
 427
 428
 429