Extensions/jdc_include.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 """
  23    Ce module contient la classe JDC_INCLUDE qui sert a inclure
  24    dans un jeu de commandes une partie de jeu de commandes
  25    au moyen de la fonctionnalite INCLUDE ou INCLUDE_MATERIAU
  26    Quand l'utilisateur veut inclure un fichier il faut versifier
  27    que le jeu de commandes inclus est valide et compatible
  28    avec le contexte avant et apres l'insertion
  29 """
  30 import string
  31 from Accas import JDC,ASSD,AsException,JDC_CATA
  32 from Ihm import CONNECTOR
  33
  34 class JDC_POURSUITE(JDC):
  35    def __init__(self,definition=None,procedure=None,cata=None,
  36                      cata_ord_dico=None,parent=None,
  37                      nom='SansNom',appli=None,context_ini=None,
  38                      jdc_pere=None,etape_include=None,prefix_include=None,
  39                      recorded_units=None,old_recorded_units=None,**args):
  40
  41       JDC.__init__(self, definition=definition,
  42                          procedure=procedure,
  43                          cata=cata,
  44                          cata_ord_dico=cata_ord_dico,
  45                          parent=parent,
  46                          nom=nom,
  47                          appli=appli,
  48                          context_ini=context_ini,
  49                          **args
  50                          )
  51       self.jdc_pere=jdc_pere
  52       self.etape_include=etape_include
  53       self.prefix_include=prefix_include
  54       if recorded_units is not None:self.recorded_units=recorded_units
  55       if old_recorded_units is not None:self.old_recorded_units=old_recorded_units
  56
  57    def o_register(self,sd):
  58       return self.jdc_pere.o_register(sd)
  59
  60    def NommerSdprod(self,sd,sdnom,restrict='non'):
  61       """
  62           Nomme la SD apres avoir verifie que le nommage est possible : nom
  63           non utilise
  64           Ajoute un prefixe s'il est specifie (INCLUDE_MATERIAU)
  65           Si le nom est deja utilise, leve une exception
  66           Met le concept créé dans le contexe global g_context
  67       """
  68       #print "NommerSdprod",sd,sdnom,restrict
  69       if self.prefix_include:
  70           if sdnom != self.prefix_include:sdnom=self.prefix_include+sdnom
  71
  72       if sdnom != '' and sdnom[0] == '_':
  73         # Si le nom du concept commence par le caractere _ on lui attribue
  74         # un identificateur automatique comme dans JEVEUX (voir gcncon)
  75         #
  76         # nom commencant par __ : il s'agit de concepts qui seront detruits
  77         # nom commencant par _ : il s'agit de concepts intermediaires qui seront gardes
  78         # ATTENTION : il faut traiter différemment les concepts dont le nom
  79         # commence par _ mais qui sont des concepts nommés automatiquement par
  80         # une éventuelle sous macro.
  81         if sdnom[1] in string.digits:
  82           # Ce concept provient probablement d'une sous macro (cas improbable)
  83           #pas de renommage
  84           pass
  85         elif sdnom[1] == '_':
  86           #cas d'un concept à ne pas conserver apres execution de la commande
  87           sdnom=sd.id[2:]
  88           pass
  89         else:
  90           sdnom=sd.id[2:]
  91           pass
  92
  93       o=self.sds_dict.get(sdnom,None)
  94       if isinstance(o,ASSD):
  95          raise AsException("Nom de concept deja defini : %s" % sdnom)
  96
  97       # On pourrait verifier que le jdc_pere apres l'etape etape_include
  98       # ne contient pas deja un concept de ce nom
  99       #if self.jdc_pere.get_sd_apres_etape_avec_detruire(sdnom,etape=self.etape_include):
 100          # Il existe un concept apres self => impossible d'inserer
 101       #   raise AsException("Nom de concept deja defini : %s" % sdnom)
 102       # On a choisi de ne pas faire ce test ici mais de le faire en bloc
 103       # si necessaire apres en appelant la methode verif_contexte
 104
 105       # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
 106       # Ajoute a la creation (appel de reg_sd).
 107       self.sds_dict[sdnom]=sd
 108       sd.nom=sdnom
 109
 110       # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
 111       if restrict == 'non':
 112          self.g_context[sdnom]=sd
 113
 114    def get_verif_contexte(self):
 115       #print "get_verif_contexte"
 116       j_context=self.get_contexte_avant(None)
 117       self.verif_contexte(j_context)
 118       return j_context
 119
 120    def force_contexte(self,contexte):
 121       for nom_sd,sd in contexte.items():
 122         if not isinstance(sd,ASSD):continue
 123         autre_sd= self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
 124                                                        etape=self.etape_include)
 125         if autre_sd is None:continue
 126         if sd is not autre_sd:
 127            # Il existe un autre concept de meme nom produit par une etape apres self
 128            # on detruit ce concept pour pouvoir inserer les etapes du jdc_include
 129            if sd.etape:
 130               sd.etape.supprime_sdprod(sd)
 131
 132       return contexte
 133
 134    def verif_contexte(self,context):
 135       """
 136          Cette methode verifie si le contexte passé en argument (context)
 137          peut etre inséré dans le jdc pere de l'include.
 138          Elle verifie que les concepts contenus dans ce contexte n'entrent
 139          pas en conflit avec les concepts produits dans le jdc pere
 140          apres l'include.
 141          Si le contexte ne peut pas etre inséré, la méthode leve une
 142          exception sinon elle retourne le contexte inchangé
 143       """
 144       #print "verif_contexte"
 145       for nom_sd,sd in context.items():
 146         if not isinstance(sd,ASSD):continue
 147         autre_sd= self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
 148                                                        etape=self.etape_include)
 149         if autre_sd is None:continue
 150         if sd is not autre_sd:
 151            # Il existe un concept produit par une etape apres self
 152            # => impossible d'inserer
 153            raise Exception("Impossible d'inclure le fichier. Un concept de nom " +
 154                            "%s existe déjà dans le jeu de commandes." % nom_sd)
 155
 156       return context
 157
 158    def get_liste_cmd(self):
 159       """
 160           Retourne la liste des commandes du catalogue
 161       """
 162       if self.jdc_pere is None:
 163          return JDC.get_liste_cmd(self)
 164       return self.jdc_pere.get_liste_cmd()
 165
 166    def get_groups(self):
 167       """
 168           Retourne la liste des commandes du catalogue par groupes
 169       """
 170       if self.jdc_pere is None:
 171          return JDC.get_groups(self)
 172       return self.jdc_pere.get_groups()
 173
 174    def init_modif(self):
 175       """
 176          Met l'état de l'étape à : modifié
 177          Propage la modification au parent
 178
 179          Attention : init_modif doit etre appelé avant de réaliser une modification
 180          La validité devra etre recalculée apres cette modification
 181          mais par un appel à fin_modif pour préserver l'état modified
 182          de tous les objets entre temps
 183       """
 184       #print "jdc_include.init_modif",self,self.etape_include
 185       self.state = 'modified'
 186       if self.etape_include:
 187          self.etape_include.init_modif()
 188
 189    def fin_modif(self):
 190       """
 191           Méthode appelée une fois qu'une modification a été faite afin de
 192           déclencher d'éventuels traitements post-modification
 193           ex : INCLUDE et POURSUITE
 194       """
 195       #print "jdc_include.fin_modif",self,self.etape_include
 196       CONNECTOR.Emit(self,"valid")
 197       if self.etape_include:
 198          self.etape_include.fin_modif()
 199
 200    def supprime(self):
 201       """
 202           On ne supprime rien directement pour un jdc auxiliaire d'include ou de poursuite
 203           Utiliser supprime_aux
 204       """
 205       pass
 206
 207    def supprime_aux(self):
 208       #print "supprime_aux",self
 209       JDC.supprime(self)
 210       self.jdc_pere=None
 211       self.etape_include=None
 212    #   self.cata_ordonne_dico={}
 213       self.appli=None
 214    #   self.context_ini={}
 215    #   self.procedure=None
 216
 217    def get_contexte_avant(self,etape):
 218       """
 219          Retourne le dictionnaire des concepts connus avant etape
 220          On tient compte des concepts produits par le jdc pere
 221          en reactualisant le contexte initial context_ini
 222          On tient compte des commandes qui modifient le contexte
 223          comme DETRUIRE ou les macros
 224          Si etape == None, on retourne le contexte en fin de JDC
 225       """
 226       #print "jdc_include.get_contexte_avant",etape,etape and etape.nom
 227       if self.etape_include:
 228          new_context=self.etape_include.parent.get_contexte_avant(self.etape_include).copy()
 229          self.context_ini=new_context
 230       d= JDC.get_contexte_avant(self,etape)
 231       return d
 232
 233    def reset_context(self):
 234       #print "jdc_include.reset_context",self,self.nom
 235       if self.etape_include:
 236          self.etape_include.parent.reset_context()
 237          new_context=self.etape_include.parent.get_contexte_avant(self.etape_include).copy()
 238          self.context_ini=new_context
 239       JDC.reset_context(self)
 240
 241    def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
 242       """
 243            Cette méthode retourne la SD de nom nom_sd qui est éventuellement
 244            définie apres etape
 245            Si avec vaut 'non' exclut etape de la recherche
 246       """
 247       if self.etape_include:
 248          sd=self.etape_include.parent.get_sd_apres_etape(nom_sd,self.etape_include,'non')
 249          if sd:return sd
 250       return JDC.get_sd_apres_etape(self,nom_sd,etape,avec)
 251
 252    def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
 253       """
 254            On veut savoir ce que devient le concept sd de nom nom_sd apres etape.
 255            Il peut etre detruit, remplacé ou conservé
 256            Cette méthode retourne la SD sd de nom nom_sd qui est éventuellement
 257            définie apres etape en tenant compte des concepts detruits
 258            Si avec vaut 'non' exclut etape de la recherche
 259       """
 260       #print "jdc_include.get_sd_apres_etape_avec_detruire",nom_sd,sd,id(sd)
 261       autre_sd=JDC.get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec)
 262       # si autre_sd vaut None le concept sd a ete detruit. On peut terminer
 263       # la recherche en retournant None
 264       # Si autre_sd ne vaut pas sd, le concept a ete redefini. On peut terminer
 265       # la recherche en retournant le concept nouvellement defini
 266       # Sinon, on poursuit la recherche dans les etapes du niveau superieur.
 267       if autre_sd is None or autre_sd is not sd :return autre_sd
 268       return self.etape_include.parent.get_sd_apres_etape_avec_detruire(nom_sd,sd,self.etape_include,'non')
 269
 270    def delete_concept(self,sd):
 271       """
 272           Fonction : Mettre a jour les etapes du JDC suite à la disparition du
 273           concept sd
 274           Seuls les mots cles simples MCSIMP font un traitement autre
 275           que de transmettre aux fils
 276       """
 277       # Nettoyage des etapes de l'include
 278       JDC.delete_concept(self,sd)
 279       # Nettoyage des etapes du parent
 280       if self.etape_include:
 281          self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd)
 282
 283    def delete_concept_after_etape(self,etape,sd):
 284       """
 285           Fonction : Mettre à jour les étapes du JDC qui sont après etape suite à
 286           la disparition du concept sd
 287       """
 288       # Nettoyage des etapes de l'include
 289       JDC.delete_concept_after_etape(self,etape,sd)
 290       # Nettoyage des etapes du parent
 291       if self.etape_include:
 292          self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd)
 293
 294    def update_concept_after_etape(self,etape,sd):
 295       """
 296           Fonction : mettre a jour les etapes du JDC suite a une modification
 297           du concept sd (principalement renommage)
 298       """
 299       JDC.update_concept_after_etape(self,etape,sd)
 300       if self.etape_include:
 301          self.etape_include.parent.update_concept_after_etape(self.etape_include,sd)
 302
 303    def replace_concept_after_etape(self,etape,old_sd,sd):
 304       """
 305           Fonction : Mettre à jour les étapes du JDC qui sont après etape suite au
 306           remplacement du concept old_sd par sd
 307       """
 308       # Nettoyage des etapes de l'include
 309       JDC.replace_concept_after_etape(self,etape,old_sd,sd)
 310       # Nettoyage des etapes du parent
 311       if self.etape_include:
 312          self.etape_include.parent.replace_concept_after_etape(self.etape_include,old_sd,sd)
 313
 314    def changefichier(self,fichier):
 315       if self.etape_include:
 316          self.etape_include.fichier_ini=fichier
 317       self.fin_modif()
 318
 319    def control_context_apres(self,etape):
 320       """
 321          Cette méthode verifie que les etapes apres l'etape etape
 322          ont bien des concepts produits acceptables (pas de conflit de
 323          nom principalement)
 324          Si des concepts produits ne sont pas acceptables ils sont supprimés.
 325          Effectue les verifications sur les etapes du jdc mais aussi sur les
 326          jdc parents s'ils existent.
 327       """
 328       #print "jdc_include.control_context_apres",self,etape
 329       #Regularise les etapes du jdc apres l'etape etape
 330       self.control_jdc_context_apres(etape)
 331       if self.etape_include:
 332          #print "CONTROL_INCLUDE:",self.etape_include,self.etape_include.nom
 333          # il existe un jdc pere. On propage la regularisation
 334          self.etape_include.parent.control_context_apres(self.etape_include)
 335
 336 class JDC_INCLUDE(JDC_POURSUITE):
 337    def get_liste_cmd(self):
 338       """
 339           Retourne la liste des commandes du catalogue
 340       """
 341       if self.jdc_pere is None:
 342          return JDC.get_liste_cmd(self)
 343       return [e for e in self.jdc_pere.get_liste_cmd() if e not in ("DEBUT","POURSUITE","FIN") ]
 344
 345    def active_etapes(self):
 346       for e in self.etapes:
 347          e.active()
 348
 349 class JDC_CATA_INCLUDE(JDC_CATA):
 350    class_instance=JDC_INCLUDE
 351
 352 class JDC_CATA_POURSUITE(JDC_CATA):
 353    class_instance=JDC_POURSUITE
 354
 355 from Accas import AU_MOINS_UN,A_CLASSER
 356
 357 JdC_include=JDC_CATA_INCLUDE(code='ASTER', execmodul=None)
 358
 359 JdC_poursuite=JDC_CATA_POURSUITE(code='ASTER', execmodul=None,
 360                                  regles = (AU_MOINS_UN('DEBUT','POURSUITE'),
 361                                            AU_MOINS_UN('FIN'),
 362                                            A_CLASSER(('DEBUT','POURSUITE'),'FIN')
 363                                           )
 364                                )
 365
 366