import Noyau
from Noyau import N_Exception
from Noyau.N_Exception import AsException
+import Validation
# fin import à résorber
# Modules EFICAS
import I_MCCOMPO
+import CONNECTOR
+from Extensions import commande_comm
class ETAPE(I_MCCOMPO.MCCOMPO):
Met l'état de l'étape à : modifié
Propage la modification au parent
"""
- # Une action
- # doit etre realisée apres init_modif et la validite reevaluée
- # apres cette action. L'état modified de tous les objets doit etre
- # preservé.
+ # init_modif doit etre appelé avant de réaliser une modification
+ # La validité devra etre recalculée apres cette modification
+ # mais dans l'appel à fin_modif pour préserver l'état modified
+ # de tous les objets entre temps
+ #print "init_modif",self,self.parent
self.state = 'modified'
if self.parent:
self.parent.init_modif()
déclencher d'éventuels traitements post-modification
ex : INCLUDE et POURSUITE
"""
- if self.isvalid() :
- d=self.parent.get_contexte_apres(self)
+ #print "fin_modif",self,self.parent
+ if self.nom == "DETRUIRE":
+ #Il n'est pas conseillé de mettre des traitements dans fin_modif. Ceci est une
+ # exception qu'il faut supprimer à terme.
+ #une commande DETRUIRE a été modifiée. Il faut verifier les commandes
+ #suivantes
+ #ATTENTION: aux eventuelles recursions
+ self.parent.control_context_apres(self)
+ pass
+
+ CONNECTOR.Emit(self,"valid")
if self.parent:
self.parent.fin_modif()
# Cas particulier des opérateurs obligatoirement réentrants
#
if self.definition.reentrant == 'o':
- self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
+ self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
if self.sd != None :
self.sdnom=self.sd.nom
+ self.fin_modif()
return 1,"Concept existant"
else:
return 0,"Opérateur réentrant mais concept non existant"
if self.definition.reentrant == 'f' :
sd = self.jdc.get_sd_avant_etape(nom,self)
if sd != None :
- # FR : il faut tester que la sd trouvée est du bon type !!!!!!!!!!!!!!!!!
- if isinstance(sd,self.get_type_produit()) :
+ # FR : il faut tester que la sd trouvée est du bon type !!!!!!!!!!!!!!!!!
+ if isinstance(sd,self.get_type_produit()) :
self.sd = self.reuse = sd
self.sdnom = sd.nom
+ self.fin_modif()
return 1,"Opérateur facultativement réentrant et concept existant trouvé"
- else:
- return 0,"Concept déjà existant et de mauvais type"
+ else:
+ return 0,"Concept déjà existant et de mauvais type"
else :
# il faut enlever le lien vers une SD existante car si on passe ici
- # cela signifie que l'opérateur n'est pas utilisé en mode réentrant.
- # Si on ne fait pas cela, on risque de modifier une SD produite par un autre opérateur
- if self.reuse :
+ # cela signifie que l'opérateur n'est pas utilisé en mode réentrant.
+ # Si on ne fait pas cela, on risque de modifier une SD produite par un autre opérateur
+ if self.reuse :
old_reuse=self.reuse
- self.sd = self.reuse = self.sdnom = None
+ self.sd = self.reuse = self.sdnom = None
#
# On est dans le cas ou l'opérateur n'est pas réentrant ou est facultativement reentrant
# mais est utilisé en mode non réentrant
#
if self.sd == None :
+ #Pas de concept produit preexistant
if self.parent.get_sd_autour_etape(nom,self):
# Un concept de ce nom existe dans le voisinage de l'etape courante
# On retablit l'ancien concept reentrant s'il existait
# Il est créé sans nom mais enregistré dans la liste des concepts existants
try:
self.get_sd_prod()
- # Il suffit de changer son attribut nom pour le nommer
+ # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
self.sd.nom = nom
self.sdnom=nom
+ self.parent.update_concept_after_etape(self,self.sd)
+ self.fin_modif()
return 1,"Nommage du concept effectué"
except:
return 0,"Nommage impossible"+str(sys.exc_info()[1])
else :
+ #Un concept produit preexiste
old_nom=self.sd.nom
if string.find(old_nom,'sansnom') :
# Dans le cas où old_nom == sansnom, isvalid retourne 0 alors que ...
- # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
- # on peut donc le nommer sans test préalable
+ # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
+ # on peut donc le nommer sans test préalable
if self.parent.get_sd_autour_etape(nom,self):
return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
else:
- self.sd.nom=nom
+ # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
+ self.sd.nom=nom
self.sdnom=nom
+ self.parent.update_concept_after_etape(self,self.sd)
+ self.fin_modif()
return 1,"Nommage du concept effectué"
if self.isvalid() :
# Normalement l appel de isvalid a mis a jour le concept produit (son type)
if self.parent.get_sd_autour_etape(nom,self):
return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
else:
+ # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
self.sd.nom=nom
self.sdnom=nom
+ self.parent.update_concept_after_etape(self,self.sd)
+ self.fin_modif()
return 1,"Nommage du concept effectué"
else:
# Normalement on ne devrait pas passer ici
"""
if self.actif:return
self.actif = 1
- if not self.sd : return
- try:
- self.jdc.append_sdprod(self.sd)
- except:
- pass
+ self.init_modif()
+ if self.sd :
+ try:
+ self.jdc.append_sdprod(self.sd)
+ except:
+ pass
+ CONNECTOR.Emit(self,"add",None)
+ CONNECTOR.Emit(self,"valid")
def inactive(self):
"""
et de la liste des sd
"""
self.actif = 0
- if not self.sd : return
- self.jdc.del_sdprod(self.sd)
- self.jdc.delete_concept_after_etape(self,self.sd)
+ self.init_modif()
+ if self.sd :
+ self.jdc.del_sdprod(self.sd)
+ self.jdc.delete_concept_after_etape(self,self.sd)
+ CONNECTOR.Emit(self,"supp",None)
+ CONNECTOR.Emit(self,"valid")
def control_sdprods(self,d):
"""
- Cette methode doit updater le contexte fournit par
- l'appelant en argument (d) en fonction de sa definition
- tout en verifiant que ses concepts produits ne sont pas
+ Cette methode doit verifier que ses concepts produits ne sont pas
deja definis dans le contexte
+ Si c'est le cas, les concepts produits doivent etre supprimes
"""
- if type(self.definition.op_init) == types.FunctionType:
- apply(self.definition.op_init,(self,d))
+ #print "control_sdprods",d.keys(),self.sd and self.sd.nom,self.nom
if self.sd:
if d.has_key(self.sd.nom):
# Le concept est deja defini
# Redefinition du concept, on l'annule
#XXX on pourrait simplement annuler son nom pour conserver les objets
# l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
- self.sd=self.reuse=self.sdnom=None
self.init_modif()
- else:
- # Le concept n'est pas defini, on peut updater d
- d[self.sd.nom]=self.sd
+ sd=self.sd
+ self.sd=self.reuse=self.sdnom=None
+ #supprime les references a sd dans les etapes suivantes
+ self.parent.delete_concept_after_etape(self,sd)
+ self.fin_modif()
+
+ 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):
"""
Une procedure n'en a aucun
Une macro en a en général plus d'un
"""
- 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)
+ #print "supprime_sdprods",self
+ 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 close(self):
+ return
+
+ def update_concept(self,sd):
+ for child in self.mc_liste :
+ child.update_concept(sd)
def delete_concept(self,sd):
"""
for child in self.mc_liste :
child.replace_concept(old_sd,sd)
+ def reset_context(self):
+ pass
+
def get_noms_sd_oper_reentrant(self):
"""
Retourne la liste des noms de concepts utilisés à l'intérieur de la commande
def verif_existence_sd(self):
"""
Vérifie que les structures de données utilisées dans self existent bien dans le contexte
- avant étape, sinon enlève la référence à ces concepts
+ avant étape, sinon enlève la référence à ces concepts
"""
+ #print "verif_existence_sd",self.sd
for motcle in self.mc_liste :
motcle.verif_existence_sd()
+
+ def update_mc_global(self):
+ """
+ Met a jour les mots cles globaux enregistrés dans l'étape
+ et dans le jdc parent.
+ Une etape ne peut pas etre globale. Elle se contente de passer
+ la requete a ses fils apres avoir reinitialisé le dictionnaire
+ des mots cles globaux.
+ """
+ self.mc_globaux={}
+ I_MCCOMPO.MCCOMPO.update_mc_global(self)
+
+ def update_condition_bloc(self):
+ """
+ Realise l'update des blocs conditionnels fils de self
+ """
+ self._update_condition_bloc()
+
+ def get_objet_commentarise(self,format):
+ """
+ Cette méthode retourne un objet commande commentarisée
+ representant la commande self
+ """
+ import generator
+ g=generator.plugins[format]()
+ texte_commande = g.gener(self,format='beautifie')
+ # Il faut enlever la première ligne vide de texte_commande que
+ # rajoute le generator
+ #rebut,texte_commande = string.split(texte_commande,'\n',1)
+ # on construit l'objet COMMANDE_COMM repésentatif de self mais non
+ # enregistré dans le jdc (pas ajouté dans jdc.etapes)
+ parent=self.parent
+ pos=self.parent.etapes.index(self)
+ commande_comment = commande_comm.COMMANDE_COMM(texte=texte_commande,
+ reg='non',
+ parent=parent)
+ self.parent.suppentite(self)
+ parent.addentite(commande_comment,pos)
+
+ return commande_comment
+
#ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau
def Build_sd(self,nom):
"""
try:
sd=Noyau.N_ETAPE.ETAPE.Build_sd(self,nom)
- self.state="modified"
except AsException,e:
# Une erreur s'est produite lors de la construction du concept
# Comme on est dans EFICAS, on essaie de poursuivre quand meme
if self.parent :
self.jdc = self.parent.get_jdc_root()
self.id= self.parent.register(self)
+ self.UserError=self.jdc.UserError
if self.definition.niveau :
# La définition est dans un niveau. En plus on
# l'enregistre dans le niveau
self.jdc = self.parent =None
self.id=None
self.niveau=None
+ self.UserError="UserError"
+
+ def report(self):
+ cr= Validation.V_ETAPE.ETAPE.report(self)
+ #rafraichissement de la validité de l'etape (probleme avec l'ordre dans les macros : etape puis mots cles)
+ self.isvalid()
+ return cr
