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       j_context=self.get_contexte_avant(None)
  90       self.verif_contexte(j_context)
  91       return j_context
  92
  93    def force_contexte(self,contexte):
  94       for nom_sd,sd in contexte.items():
  95         if not isinstance(sd,ASSD):continue
  96         if self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
  97                                                        etape=self.etape_include):
  98            # Il existe un autre concept de meme nom produit par une etape apres self
  99            # on detruit ce concept pour pouvoir inserer les etapes du jdc_include
 100            #print "force_contexte",sd.etape,sd.nom,sd.etape.nom
 101            if sd.etape:
 102               sd.etape.supprime_sdprod(sd)
 103
 104       return contexte
 105
 106    def verif_contexte(self,context):
 107       """
 108          Cette methode verifie si le contexte passé en argument (context)
 109          peut etre inséré dans le jdc pere de l'include.
 110          Elle verifie que les concepts contenus dans ce contexte n'entrent
 111          pas en conflit avec les concepts produits dans le jdc pere
 112          apres l'include.
 113          Si le contexte ne peut pas etre inséré, la méthode leve une
 114          exception sinon elle retourne le contexte inchangé
 115       """
 116       #print "verif_contexte"
 117       for nom_sd,sd in context.items():
 118         if not isinstance(sd,ASSD):continue
 119         if self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
 120                                                        etape=self.etape_include):
 121            # Il existe un concept produit par une etape apres self
 122            # => impossible d'inserer
 123            raise Exception("Impossible d'inclure le fichier. Un concept de nom " +
 124                            "%s existe déjà dans le jeu de commandes." % nom_sd)
 125
 126       return context
 127
 128    def get_liste_cmd(self):
 129       """
 130           Retourne la liste des commandes du catalogue
 131       """
 132       return self.jdc_pere.get_liste_cmd()
 133
 134    def get_groups(self):
 135       """
 136           Retourne la liste des commandes du catalogue par groupes
 137       """
 138       return self.jdc_pere.get_groups()
 139
 140    def init_modif(self):
 141       """
 142          Met l'état de l'étape à : modifié
 143          Propage la modification au parent
 144
 145          Attention : init_modif doit etre appelé avant de réaliser une modification
 146          La validité devra etre recalculée apres cette modification
 147          mais par un appel à fin_modif pour préserver l'état modified
 148          de tous les objets entre temps
 149       """
 150       #print "jdc_include.init_modif",self,self.etape_include
 151       self.state = 'modified'
 152       self.etape_include.init_modif()
 153
 154    def fin_modif(self):
 155       """
 156           Méthode appelée une fois qu'une modification a été faite afin de
 157           déclencher d'éventuels traitements post-modification
 158           ex : INCLUDE et POURSUITE
 159       """
 160       #print "jdc_include.fin_modif",self,self.etape_include
 161
 162       # Mise a jour du contexte en fin d'include
 163       # On suppose que toutes les modifications sont valides
 164       # On recupere le contexte final dans j_context
 165       j_context=self.get_contexte_avant(None) #get_verif_contexte ???
 166       # On remplit le dictionnaire des concepts produits de l'etape macro INCLUDE
 167       # sans y mettre les concepts présents dans le  contexte initial (context_ini)
 168       # On ajoute egalement les concepts produits dans le sds_dict du parent
 169       # sans verification car on est sur (verification integrée) que
 170       # le nommage est possible
 171       self.etape_include.g_context.clear()
 172       for k,v in j_context.items():
 173          if not self.context_ini.has_key(k) or self.context_ini[k] != v:
 174             self.etape_include.g_context[k]=v
 175             self.etape_include.parent.sds_dict[k]=v
 176
 177       CONNECTOR.Emit(self,"valid")
 178       self.etape_include.fin_modif()
 179       #print "jdc_include.fin_modif.context_ini",self.context_ini
 180
 181    def supprime(self):
 182       """
 183           On ne supprime rien pour un jdc auxiliaire d'include ou de poursuite
 184       """
 185       pass
 186
 187    def get_contexte_avant(self,etape):
 188       """
 189          Retourne le dictionnaire des concepts connus avant etape
 190          On tient compte des concepts produits par le jdc pere
 191          en reactualisant le contexte initial context_ini
 192          On tient compte des commandes qui modifient le contexte
 193          comme DETRUIRE ou les macros
 194          Si etape == None, on retourne le contexte en fin de JDC
 195       """
 196       self.context_ini = self.etape_include.parent.get_contexte_avant(self.etape_include).copy()
 197       return JDC.get_contexte_avant(self,etape)
 198
 199    #def get_sd_avant_etape(self,nom_sd,etape):
 200       #sd=self.etape_include.parent.get_sd_avant_etape(nom_sd,self.etape_include)
 201       #if sd:return sd
 202       #return JDC.get_sd_avant_etape(self,nom_sd,etape)
 203
 204    #def get_sd_avant_du_bon_type(self,etape,types_permis):
 205       #"""
 206       #    Retourne la liste des concepts avant etape d'un type acceptable
 207       #"""
 208       #l1=self.etape_include.parent.get_sd_avant_du_bon_type(self.etape_include,types_permis)
 209       #l2=JDC.get_sd_avant_du_bon_type(self,etape,types_permis)
 210       #return l1+l2
 211
 212    def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
 213       """
 214            Cette méthode retourne la SD de nom nom_sd qui est éventuellement
 215            définie apres etape
 216            Si avec vaut 'non' exclut etape de la recherche
 217       """
 218       sd=self.etape_include.parent.get_sd_apres_etape(nom_sd,self.etape_include,'non')
 219       if sd:return sd
 220       return JDC.get_sd_apres_etape(self,nom_sd,etape,avec)
 221
 222    def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
 223       """
 224            On veut savoir ce que devient le concept sd de nom nom_sd apres etape.
 225            Il peut etre detruit, remplacé ou conservé
 226            Cette méthode retourne la SD sd de nom nom_sd qui est éventuellement
 227            définie apres etape en tenant compte des concepts detruits
 228            Si avec vaut 'non' exclut etape de la recherche
 229       """
 230       autre_sd=JDC.get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec)
 231       if autre_sd is None or autre_sd is not sd :return autre_sd
 232       return self.etape_include.parent.get_sd_apres_etape_avec_detruire(nom_sd,sd,self.etape_include,'non')
 233
 234    def delete_concept(self,sd):
 235       """
 236           Fonction : Mettre a jour les etapes du JDC suite à la disparition du
 237           concept sd
 238           Seuls les mots cles simples MCSIMP font un traitement autre
 239           que de transmettre aux fils
 240       """
 241       # Nettoyage des etapes de l'include
 242       JDC.delete_concept(self,sd)
 243       # Nettoyage des etapes du parent
 244       self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd)
 245
 246    def delete_concept_after_etape(self,etape,sd):
 247       """
 248           Fonction : Mettre à jour les étapes du JDC qui sont après etape suite à
 249           la disparition du concept sd
 250       """
 251       # Nettoyage des etapes de l'include
 252       JDC.delete_concept_after_etape(self,etape,sd)
 253       # Nettoyage des etapes du parent
 254       self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd)
 255
 256    def replace_concept_after_etape(self,etape,old_sd,sd):
 257       """
 258           Fonction : Mettre à jour les étapes du JDC qui sont après etape suite au
 259           remplacement du concept old_sd par sd
 260       """
 261       # Nettoyage des etapes de l'include
 262       JDC.replace_concept_after_etape(self,etape,old_sd,sd)
 263       # Nettoyage des etapes du parent
 264       self.etape_include.parent.replace_concept_after_etape(self.etape_include,old_sd,sd)
 265
 266
 267
 268 class JDC_INCLUDE(JDC_POURSUITE):
 269    def active_etapes(self):
 270       for e in self.etapes:
 271          e.active()
 272
 273 class JDC_CATA_INCLUDE(JDC_CATA):
 274    class_instance=JDC_INCLUDE
 275
 276 class JDC_CATA_POURSUITE(JDC_CATA):
 277    class_instance=JDC_POURSUITE
 278
 279 from Accas import AU_MOINS_UN,A_CLASSER
 280
 281 JdC_include=JDC_CATA_INCLUDE(code='ASTER', execmodul=None)
 282
 283 JdC_poursuite=JDC_CATA_POURSUITE(code='ASTER', execmodul=None,
 284                                  regles = (AU_MOINS_UN('DEBUT','POURSUITE'),
 285                                            AU_MOINS_UN('FIN'),
 286                                            A_CLASSER(('DEBUT','POURSUITE'),'FIN')
 287                                           )
 288                                )
 289
 290