CCAR: correction probleme de destruction de commande avec concept reuse

amelioration du changement de fichier INCLUDE avec concepts existants (force_fichier)

diff --git a/Extensions/jdc_include.py b/Extensions/jdc_include.py
index 07a6c94e330e8c7b2512679abdcaabc124ba4960..1e38f9f246e1f02f112b4498749b52cc8aeb2dc7 100644 (file)
--- a/Extensions/jdc_include.py
+++ b/Extensions/jdc_include.py
@@ -90,6 +90,19 @@ class JDC_POURSUITE(JDC):
       self.verif_contexte(j_context)
       return j_context
 
+   def force_contexte(self,contexte):
+      for nom_sd,sd in contexte.items():
+        if not isinstance(sd,ASSD):continue
+        if self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
+                                                       etape=self.etape_include):
+           # Il existe un autre concept de meme nom produit par une etape apres self 
+           # on detruit ce concept pour pouvoir inserer les etapes du jdc_include
+           #print "force_contexte",sd.etape,sd.nom,sd.etape.nom
+           if sd.etape:
+              sd.etape.supprime_sdprod(sd)
+
+      return contexte
+
    def verif_contexte(self,context):
       """
          Cette methode verifie si le contexte passé en argument (context)

diff --git a/Ihm/I_ETAPE.py b/Ihm/I_ETAPE.py
index 642964f4d7a0b9fabff4b86b137e50368a1bb39a..4106b468cea96ba4a9aa793ed34993b7970e95fd 100644 (file)
--- a/Ihm/I_ETAPE.py
+++ b/Ihm/I_ETAPE.py
@@ -268,6 +268,18 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
            # Le concept n'est pas defini, on peut updater d
            d[self.sd.nom]=self.sd
 
+   def supprime_sdprod(self,sd):
+      """
+         Supprime le concept produit sd s'il est produit par l'etape
+      """
+      if sd is not self.sd:return
+      if self.sd != None :
+         self.init_modif()
+         self.parent.del_sdprod(sd)
+         self.sd=None
+         self.fin_modif()
+         self.parent.delete_concept(sd)
+
    def supprime_sdprods(self):
       """ 
             Fonction:
@@ -277,13 +289,13 @@ class ETAPE(I_MCCOMPO.MCCOMPO):
             Une macro en a en général plus d'un
       """
       #print "supprime_sdprods",self
-      if not self.is_reentrant() :
-        # l'étape n'est pas réentrante
-        # le concept retourné par l'étape est à supprimer car il était 
-        # créé par l'étape
-        if self.sd != None :
-          self.parent.del_sdprod(self.sd)
-          self.parent.delete_concept(self.sd)
+      if self.reuse is self.sd :return
+      # l'étape n'est pas réentrante
+      # le concept retourné par l'étape est à supprimer car il était 
+      # créé par l'étape
+      if self.sd != None :
+         self.parent.del_sdprod(self.sd)
+         self.parent.delete_concept(self.sd)
 
    def delete_concept(self,sd):
       """ 

diff --git a/Ihm/I_MACRO_ETAPE.py b/Ihm/I_MACRO_ETAPE.py
index c79ae36b93ff930f36b3d4cca0275d979db41b64..87f5e0e35c12ded54b576a5a716b27cc6bf98670 100644 (file)
--- a/Ihm/I_MACRO_ETAPE.py
+++ b/Ihm/I_MACRO_ETAPE.py
@@ -237,6 +237,25 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
         else:
            d[co.nom]=co
        
+  def supprime_sdprod(self,sd):
+      """
+         Supprime le concept produit sd s'il est produit par l'etape
+      """
+      if sd in self.sdprods:
+         self.init_modif()
+         self.parent.del_sdprod(sd)
+         self.sdprods.remove(sd)
+         self.fin_modif()
+         self.parent.delete_concept(sd)
+         return
+
+      if sd is not self.sd :return
+      if self.sd is not None :
+         self.init_modif()
+         self.parent.del_sdprod(sd)
+         self.sd=None
+         self.fin_modif()
+         self.parent.delete_concept(sd)
 
   def supprime_sdprods(self):
       """
@@ -246,7 +265,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
           Une macro en a en général plus d'un
       """
       #print "supprime_sdprods"
-      if not self.is_reentrant() :
+      if self.reuse is not self.sd :
          # l'étape n'est pas réentrante
          # le concept retourné par l'étape est à supprimer car il était
          # créé par l'étape
@@ -285,7 +304,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
       #print "replace_concept",old_sd,sd
       I_ETAPE.ETAPE.replace_concept(self,old_sd,sd)
       for etape in self.etapes:
-         etape.replace_concept(sd)
+         etape.replace_concept(old_sd,sd)
          
   def change_fichier_init(self,new_fic,text):
     """
@@ -353,23 +372,43 @@ class MACRO_ETAPE(I_ETAPE.ETAPE):
     """
        Force le fichier init en erreur
     """
+    j_context=self.jdc_aux.get_contexte_avant(None)
+    # On remplit le dictionnaire des concepts produits inclus
+    # en retirant les concepts présents dans le  contexte initial
+    # On ajoute egalement le concept produit dans le sds_dict du parent
+    # sans verification car on est sur (verification integrée) que
+    # le nommage est possible
+    self.g_context.clear()
+    context_ini=self.jdc_aux.context_ini
+    for k,v in j_context.items():
+       if not context_ini.has_key(k) or context_ini[k] != v:
+           self.g_context[k]=v
+           self.parent.sds_dict[k]=v
+    # On recupere le contexte courant
+    self.current_context=self.jdc_aux.current_context
+    self.index_etape_courante=self.jdc_aux.index_etape_courante
+    self.contexte_fichier_init = j_context
+
     # On conserve la memoire du nouveau fichier
     # mais on n'utilise pas les concepts crees par ce fichier
     # on met l'etape en erreur : fichier_err=string.join(l)
     self.init_modif()
+    self.state="undetermined"
     # On enregistre la modification de fichier
     self.record_unite()
     #self.etapes=[]
-    self.g_context={}
+    #self.g_context={}
     # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
     self.parent.reset_context()
 
     self.old_contexte_fichier_init=self.old_context
-    self.contexte_fichier_init={}
+    #self.contexte_fichier_init={}
     self.reevalue_sd_jdc()
-
     self.fin_modif()
 
+    self.jdc_aux.force_contexte(self.g_context)
+
+
   def make_contexte_include(self,fichier,text):
     """
         Cette méthode sert à créer un contexte en interprétant un texte source