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 from Accas import JDC,ASSD,AsException,JDC_CATA
  31 from Ihm import CONNECTOR
  32
  33 class JDC_POURSUITE(JDC):
  34    def __init__(self,definition=None,procedure=None,cata=None,
  35                      cata_ord_dico=None,parent=None,
  36                      nom='SansNom',appli=None,context_ini=None,
  37                      jdc_pere=None,etape_include=None,prefix_include=None,
  38                      recorded_units=None,old_recorded_units=None,**args):
  39
  40       JDC.__init__(self, definition=definition,
  41                          procedure=procedure,
  42                          cata=cata,
  43                          cata_ord_dico=cata_ord_dico,
  44                          parent=parent,
  45                          nom=nom,
  46                          appli=appli,
  47                          context_ini=context_ini,
  48                          **args
  49                          )
  50       self.jdc_pere=jdc_pere
  51       self.etape_include=etape_include
  52       self.prefix_include=prefix_include
  53       if recorded_units is not None:self.recorded_units=recorded_units
  54       if old_recorded_units is not None:self.old_recorded_units=old_recorded_units
  55
  56    def NommerSdprod(self,sd,sdnom,restrict='non'):
  57       """
  58           Nomme la SD apres avoir verifie que le nommage est possible : nom
  59           non utilise
  60           Ajoute un prefixe s'il est specifie (INCLUDE_MATERIAU)
  61           Si le nom est deja utilise, leve une exception
  62           Met le concept créé dans le contexe global g_context
  63       """
  64       #print "NommerSdprod",sd,sdnom,restrict
  65       if self.prefix_include:
  66           if sdnom != self.prefix_include:sdnom=self.prefix_include+sdnom
  67       o=self.sds_dict.get(sdnom,None)
  68       if isinstance(o,ASSD):
  69          raise AsException("Nom de concept deja defini : %s" % sdnom)
  70
  71       # On pourrait verifier que le jdc_pere apres l'etape etape_include
  72       # ne contient pas deja un concept de ce nom
  73       #if self.jdc_pere.get_sd_apres_etape_avec_detruire(sdnom,etape=self.etape_include):
  74          # Il existe un concept apres self => impossible d'inserer
  75       #   raise AsException("Nom de concept deja defini : %s" % sdnom)
  76       # On a choisi de ne pas faire ce test ici mais de le faire en bloc
  77       # si necessaire apres en appelant la methode verif_contexte
  78
  79       # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
  80       # Ajoute a la creation (appel de reg_sd).
  81       self.sds_dict[sdnom]=sd
  82       sd.nom=sdnom
  83
  84       # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
  85       if restrict == 'non':
  86          self.g_context[sdnom]=sd
  87
  88    def get_verif_contexte(self):
  89       #print "get_verif_contexte"
  90       j_context=self.get_contexte_avant(None)
  91       self.verif_contexte(j_context)
  92       return j_context
  93
  94    def force_contexte(self,contexte):
  95       for nom_sd,sd in contexte.items():
  96         if not isinstance(sd,ASSD):continue
  97         if self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
  98                                                        etape=self.etape_include):
  99            # Il existe un autre concept de meme nom produit par une etape apres self
 100            # on detruit ce concept pour pouvoir inserer les etapes du jdc_include
 101            #print "force_contexte",sd.etape,sd.nom,sd.etape.nom
 102            if sd.etape:
 103               sd.etape.supprime_sdprod(sd)
 104
 105       return contexte
 106
 107    def verif_contexte(self,context):
 108       """
 109          Cette methode verifie si le contexte passé en argument (context)
 110          peut etre inséré dans le jdc pere de l'include.
 111          Elle verifie que les concepts contenus dans ce contexte n'entrent
 112          pas en conflit avec les concepts produits dans le jdc pere
 113          apres l'include.
 114          Si le contexte ne peut pas etre inséré, la méthode leve une
 115          exception sinon elle retourne le contexte inchangé
 116       """
 117       #print "verif_contexte"
 118       for nom_sd,sd in context.items():
 119         if not isinstance(sd,ASSD):continue
 120         autre_sd= self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
 121                                                        etape=self.etape_include)
 122         if sd and sd is not autre_sd:
 123            # Il existe un concept produit par une etape apres self
 124            # => impossible d'inserer
 125            raise Exception("Impossible d'inclure le fichier. Un concept de nom " +
 126                            "%s existe déjà dans le jeu de commandes." % nom_sd)
 127
 128       return context
 129
 130    def get_liste_cmd(self):
 131       """
 132           Retourne la liste des commandes du catalogue
 133       """
 134       if self.jdc_pere is None:
 135          return JDC.get_liste_cmd(self)
 136       return self.jdc_pere.get_liste_cmd()
 137
 138    def get_groups(self):
 139       """
 140           Retourne la liste des commandes du catalogue par groupes
 141       """
 142       if self.jdc_pere is None:
 143          return JDC.get_groups(self)
 144       return self.jdc_pere.get_groups()
 145
 146    def init_modif(self):
 147       """
 148          Met l'état de l'étape à : modifié
 149          Propage la modification au parent
 150
 151          Attention : init_modif doit etre appelé avant de réaliser une modification
 152          La validité devra etre recalculée apres cette modification
 153          mais par un appel à fin_modif pour préserver l'état modified
 154          de tous les objets entre temps
 155       """
 156       #print "jdc_include.init_modif",self,self.etape_include
 157       self.state = 'modified'
 158       if self.etape_include:
 159          self.etape_include.init_modif()
 160
 161    def fin_modif(self):
 162       """
 163           Méthode appelée une fois qu'une modification a été faite afin de
 164           déclencher d'éventuels traitements post-modification
 165           ex : INCLUDE et POURSUITE
 166       """
 167       #print "jdc_include.fin_modif",self,self.etape_include
 168       if not self.etape_include:
 169          CONNECTOR.Emit(self,"valid")
 170          return
 171       # Mise a jour du contexte en fin d'include
 172       # On suppose que toutes les modifications sont valides
 173       # On recupere le contexte final dans j_context
 174       j_context=self.get_contexte_avant(None) #get_verif_contexte ???
 175       # On remplit le dictionnaire des concepts produits de l'etape macro INCLUDE
 176       # sans y mettre les concepts présents dans le  contexte initial (context_ini)
 177       # On ajoute egalement les concepts produits dans le sds_dict du parent
 178       # sans verification car on est sur (verification integrée) que
 179       # le nommage est possible
 180       self.etape_include.g_context.clear()
 181       for k,v in j_context.items():
 182          if not self.context_ini.has_key(k) or self.context_ini[k] != v:
 183             self.etape_include.g_context[k]=v
 184             self.etape_include.parent.sds_dict[k]=v
 185
 186       CONNECTOR.Emit(self,"valid")
 187       self.etape_include.fin_modif()
 188       #print "jdc_include.fin_modif.context_ini",self.context_ini
 189
 190    def supprime(self):
 191       """
 192           On ne supprime rien pour un jdc auxiliaire d'include ou de poursuite
 193       """
 194       pass
 195
 196    def get_contexte_avant(self,etape):
 197       """
 198          Retourne le dictionnaire des concepts connus avant etape
 199          On tient compte des concepts produits par le jdc pere
 200          en reactualisant le contexte initial context_ini
 201          On tient compte des commandes qui modifient le contexte
 202          comme DETRUIRE ou les macros
 203          Si etape == None, on retourne le contexte en fin de JDC
 204       """
 205       if self.etape_include:
 206          self.context_ini = self.etape_include.parent.get_contexte_avant(self.etape_include).copy()
 207       return JDC.get_contexte_avant(self,etape)
 208
 209    #def get_sd_avant_etape(self,nom_sd,etape):
 210       #sd=self.etape_include.parent.get_sd_avant_etape(nom_sd,self.etape_include)
 211       #if sd:return sd
 212       #return JDC.get_sd_avant_etape(self,nom_sd,etape)
 213
 214    #def get_sd_avant_du_bon_type(self,etape,types_permis):
 215       #"""
 216       #    Retourne la liste des concepts avant etape d'un type acceptable
 217       #"""
 218       #l1=self.etape_include.parent.get_sd_avant_du_bon_type(self.etape_include,types_permis)
 219       #l2=JDC.get_sd_avant_du_bon_type(self,etape,types_permis)
 220       #return l1+l2
 221
 222    def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
 223       """
 224            Cette méthode retourne la SD de nom nom_sd qui est éventuellement
 225            définie apres etape
 226            Si avec vaut 'non' exclut etape de la recherche
 227       """
 228       if self.etape_include:
 229          sd=self.etape_include.parent.get_sd_apres_etape(nom_sd,self.etape_include,'non')
 230          if sd:return sd
 231       return JDC.get_sd_apres_etape(self,nom_sd,etape,avec)
 232
 233    def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
 234       """
 235            On veut savoir ce que devient le concept sd de nom nom_sd apres etape.
 236            Il peut etre detruit, remplacé ou conservé
 237            Cette méthode retourne la SD sd de nom nom_sd qui est éventuellement
 238            définie apres etape en tenant compte des concepts detruits
 239            Si avec vaut 'non' exclut etape de la recherche
 240       """
 241       #print "jdc_include.get_sd_apres_etape_avec_detruire",nom_sd,sd,id(sd)
 242       autre_sd=JDC.get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec)
 243       #print autre_sd,id(autre_sd)
 244       # si autre_sd vaut None le concept sd a ete detruit. On peut terminer
 245       # la recherche en retournant None
 246       # Si autre_sd ne vaut pas sd, le concept a ete redefini. On peut terminer
 247       # la recherche en retournant le concept nouvellement defini
 248       # Sinon, on poursuit la recherche dans les etapes du niveau superieur.
 249       if autre_sd is None or autre_sd is not sd :return autre_sd
 250       return self.etape_include.parent.get_sd_apres_etape_avec_detruire(nom_sd,sd,self.etape_include,'non')
 251
 252    def delete_concept(self,sd):
 253       """
 254           Fonction : Mettre a jour les etapes du JDC suite à la disparition du
 255           concept sd
 256           Seuls les mots cles simples MCSIMP font un traitement autre
 257           que de transmettre aux fils
 258       """
 259       # Nettoyage des etapes de l'include
 260       JDC.delete_concept(self,sd)
 261       # Nettoyage des etapes du parent
 262       if self.etape_include:
 263          self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd)
 264
 265    def delete_concept_after_etape(self,etape,sd):
 266       """
 267           Fonction : Mettre à jour les étapes du JDC qui sont après etape suite à
 268           la disparition du concept sd
 269       """
 270       # Nettoyage des etapes de l'include
 271       JDC.delete_concept_after_etape(self,etape,sd)
 272       # Nettoyage des etapes du parent
 273       if self.etape_include:
 274          self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd)
 275
 276    def replace_concept_after_etape(self,etape,old_sd,sd):
 277       """
 278           Fonction : Mettre à jour les étapes du JDC qui sont après etape suite au
 279           remplacement du concept old_sd par sd
 280       """
 281       # Nettoyage des etapes de l'include
 282       JDC.replace_concept_after_etape(self,etape,old_sd,sd)
 283       # Nettoyage des etapes du parent
 284       if self.etape_include:
 285          self.etape_include.parent.replace_concept_after_etape(self.etape_include,old_sd,sd)
 286
 287 class JDC_INCLUDE(JDC_POURSUITE):
 288    def get_liste_cmd(self):
 289       """
 290           Retourne la liste des commandes du catalogue
 291       """
 292       if self.jdc_pere is None:
 293          return JDC.get_liste_cmd(self)
 294       return [e for e in self.jdc_pere.get_liste_cmd() if e not in ("DEBUT","POURSUITE","FIN") ]
 295
 296    def active_etapes(self):
 297       for e in self.etapes:
 298          e.active()
 299
 300 class JDC_CATA_INCLUDE(JDC_CATA):
 301    class_instance=JDC_INCLUDE
 302
 303 class JDC_CATA_POURSUITE(JDC_CATA):
 304    class_instance=JDC_POURSUITE
 305
 306 from Accas import AU_MOINS_UN,A_CLASSER
 307
 308 JdC_include=JDC_CATA_INCLUDE(code='ASTER', execmodul=None)
 309
 310 JdC_poursuite=JDC_CATA_POURSUITE(code='ASTER', execmodul=None,
 311                                  regles = (AU_MOINS_UN('DEBUT','POURSUITE'),
 312                                            AU_MOINS_UN('FIN'),
 313                                            A_CLASSER(('DEBUT','POURSUITE'),'FIN')
 314                                           )
 315                                )
 316
 317