+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
"""
"""
# Modules Python
+import sys
import string,types
from copy import copy
class ETAPE(I_MCCOMPO.MCCOMPO):
- def __init__(self):
- self.niveau=self.jdc
-
def ident(self):
return self.nom
- def get_fr(self):
- """
- Retourne l'attribut fr de self.definition
- """
- try:
- return self.definition.fr
- except:
- return ''
-
def get_sdname(self):
if CONTEXT.debug : print "SDNAME ",self.reuse,self.sd,self.sd.get_name()
+ sdname=''
if self.reuse != None:
sdname= self.reuse.get_name()
else:
- sdname=self.sd.get_name()
+ if self.sd:sdname=self.sd.get_name()
if string.find(sdname,'sansnom') != -1 or string.find(sdname,'SD_') != -1:
# dans le cas où la SD est 'sansnom' ou 'SD_' on retourne la chaîne vide
return ''
"""
Met l'état de l'étape à : modifié
Propage la modification au parent
- Si la fonction op_init existe, l'active
"""
# Une action
# doit etre realisée apres init_modif et la validite reevaluée
ex : INCLUDE et POURSUITE
"""
if self.isvalid() :
- if type(self.definition.op_init) == types.FunctionType :
- # XXX Normalement en mode editeur g_context ne peut pas etre utilisé
- apply(self.definition.op_init,(self,self.parent.g_context))
- self.state = 'modified'
-
+ d=self.parent.get_contexte_apres(self)
+ if self.parent:
+ self.parent.fin_modif()
+
def nomme_sd(self,nom) :
"""
Cette méthode a pour fonction de donner un nom (nom) au concept
if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
return 0,"Nom de concept trop long (maxi 8 caractères)"
self.init_modif()
- # Cas particulier des opérateurs réentrants
+ #
+ # On verifie d'abord si les mots cles sont valides
+ #
if not self.isvalid(sd='non') : return 0,"Nommage du concept refusé : l'opérateur n'est pas valide"
+ #
+ # Cas particulier des opérateurs obligatoirement réentrants
+ #
if self.definition.reentrant == 'o':
- # FR : appel à get_sdprod incorrect : il faut appeler get_sd_avant_etape
- #self.sd = self.reuse = self.jdc.get_sdprod(nom)
self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
if self.sd != None :
+ self.sdnom=self.sd.nom
return 1,"Concept existant"
else:
return 0,"Opérateur réentrant mais concept non existant"
+ #
+ # Cas particulier des opérateurs facultativement réentrants
+ #
+ old_reuse=None
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()) :
self.sd = self.reuse = sd
+ self.sdnom = sd.nom
return 1,"Opérateur facultativement réentrant et concept existant trouvé"
else:
return 0,"Concept déjà existant et de mauvais type"
else :
- # il faut éventuellement enlever le lien vers une SD existante car si on passe ici
+ # 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, le nom de l'opérateur réutilisé est aussi modifié
- # et on ne peut plus modifier la SD de l'opérateur
+ # Si on ne fait pas cela, on risque de modifier une SD produite par un autre opérateur
if self.reuse :
- self.sd = self.reuse = None
- # l'opérateur n'est pas réentrant ou facultativement reentrant mais pas dans ce cas
+ old_reuse=self.reuse
+ 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 :
if self.parent.get_sd_autour_etape(nom,self):
- # On force self.valid a 0 car l appel a isvalid precedent l a mis a 1
- # mais ceci indique seulement une validité partielle
- # isvalid ne devrait peut etre pas mettre l attribut valid à 1 si sd == 'non'
- self.valid=0
- return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
- # Il n'existe pas de sd de nom sdnom. On peut donc créer le concept retourné.
- # Il est créé sans nom mais enregistré dans la liste des concepts existants
- self.get_sd_prod()
- self.sd.nom = nom
- return 1,"Nommage du concept effectué"
- else :
- 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
- self.sd.nom=nom
- return 1,"Nommage du concept effectué"
- if self.isvalid() :
- # Normalement l appel de isvalid a mis a jour le concept produit (son type)
- # Il suffit de spécifier l attribut nom de sd pour le nommer si le nom n est pas
- # deja attribué
- 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
+ if old_reuse:
+ self.sd=self.reuse=old_reuse
+ self.sdnom=old_reuse.nom
return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
else:
- self.sd.nom=nom
+ # Il n'existe pas de concept de ce nom dans le voisinage de l'etape courante
+ # On peut donc créer le concept retourné.
+ # Il est créé sans nom mais enregistré dans la liste des concepts existants
+ self.get_sd_prod()
+ # Il suffit de changer son attribut nom pour le nommer
+ self.sd.nom = nom
+ self.sdnom=nom
return 1,"Nommage du concept effectué"
- else:
- # Normalement on ne devrait pas passer ici
- return 0,'Normalement on ne devrait pas passer ici'
+ else :
+ 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
+ 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
+ self.sdnom=nom
+ return 1,"Nommage du concept effectué"
+ if self.isvalid() :
+ # Normalement l appel de isvalid a mis a jour le concept produit (son type)
+ # Il suffit de spécifier l attribut nom de sd pour le nommer si le nom n est pas
+ # deja attribué
+ 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
+ self.sdnom=nom
+ return 1,"Nommage du concept effectué"
+ else:
+ # Normalement on ne devrait pas passer ici
+ return 0,'Normalement on ne devrait pas passer ici'
def get_sdprods(self,nom_sd):
"""
Il faut ajouter la sd si elle existe au contexte global du JDC
et à la liste des sd
"""
+ if self.actif:return
self.actif = 1
if not self.sd : return
- # XXX Pourquoi faut-il faire ce qui suit ??? par defaut les etapes sont actives
try:
self.jdc.append_sdprod(self.sd)
except:
self.jdc.del_sdprod(self.sd)
self.jdc.delete_concept_after_etape(self,self.sd)
+ 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
+ deja definis dans le contexte
+ """
+ if type(self.definition.op_init) == types.FunctionType:
+ apply(self.definition.op_init,(self,d))
+ if self.sd:
+ if d.has_key(self.sd.nom):
+ # Le concept est deja defini
+ if self.reuse and self.reuse is d[self.sd.nom]:
+ # Le concept est reutilise : situation normale
+ pass
+ else:
+ # 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
+
def supprime_sdprods(self):
"""
Fonction:
Une procedure n'en a aucun
Une macro en a en général plus d'un
"""
- # XXX pour les macros il faudrait peut etre aussi
- # supprimer les concepts a droite du = ???
if not self.is_reentrant() :
# l'étape n'est pas réentrante
# le concept retourné par l'étape est à supprimer car il était
for child in self.mc_liste :
child.delete_concept(sd)
+ def replace_concept(self,old_sd,sd):
+ """
+ Inputs :
+ old_sd=concept remplace
+ sd = nouveau concept
+ Fonction :
+ Mettre a jour les mots cles de l etape et eventuellement
+ le concept produit si reuse
+ suite au remplacement du concept old_sd
+ """
+ if self.reuse and self.reuse == old_sd:
+ self.sd=self.reuse=sd
+ self.init_modif()
+ for child in self.mc_liste :
+ child.replace_concept(old_sd,sd)
+
def make_register(self):
"""
Initialise les attributs jdc, id, niveau et réalise les
enregistrements nécessaires
Pour EFICAS, on tient compte des niveaux
+ Surcharge la methode make_register du package Noyau
"""
if self.parent :
self.jdc = self.parent.get_jdc_root()
# CCAR : cette modification ne corrige le probleme qu'en partie. Il faudrait probablement
# supprimer les erreurs fatales (exception ) et retourner systematiquement un objet produit
# meme en cas d'erreur et reporter l'emission du message d'erreur a la phase de validation
+ #
if not self.isvalid(sd='non') : return
- else:self.state='undetermined'
+ self.sdnom=nom
try:
if self.parent:
sd= self.parent.create_sdprod(self,nom)
self.Execute()
return sd
except AsException,e:
- raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
- 'fichier : ',self.appel[1],e)
+ # Une erreur s'est produite lors de la construction du concept
+ # Comme on est dans EFICAS, on essaie de poursuivre quand meme
+ # Si on poursuit, on a le choix entre deux possibilités :
+ # 1. on annule la sd associée à self
+ # 2. on la conserve mais il faut la retourner
+ # En plus il faut rendre coherents sdnom et sd.nom
+ self.sd=None
+ self.sdnom=None
+ self.state="unchanged"
+ self.valid=0
+ return self.sd
+
+ #raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
+ # 'fichier : ',self.appel[1],e)
except EOFError:
# XXX Normalement le contexte courant doit etre le parent.
# Il n'y a pas de raison de remettre le contexte au parent