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