+# 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
# Modules Eficas
import I_OBJECT
-from Noyau.N_ASSD import assd
+from Noyau.N_ASSD import ASSD
from Noyau.N_ETAPE import ETAPE
-from Noyau.N_CO import CO
from Noyau.N_Exception import AsException
from Extensions import commentaire,parametre,parametre_eval
self.niveau=self
self.params=[]
self.fonctions=[]
+ self._etape_context=None
def get_cmd(self,nomcmd):
"""
l=[]
for k,v in d.items():
if type(v) != types.InstanceType : continue
- if assd in types_permis or CO in types_permis :
- l.append(k)
- continue
- for type_ok in types_permis:
- if type_ok in ('R','I','C','TXM') and v in self.params : l.append(k)
- elif type_ok == 'R' and v.__class__.__name__ == 'reel' : l.append(k)
- elif type_ok == 'I' and v.__class__.__name__ == 'entier' : l.append(k)
- elif type_ok == 'C' and v.__class__.__name__ == 'complexe' : l.append(k)
- elif type_ok == 'TXM' and v.__class__.__name__ == 'chaine' : l.append(k)
- elif type(type_ok) != types.ClassType : continue
- elif v.__class__ == type_ok or issubclass(v.__class__,type_ok): l.append(k)
+ # On considère que seul assd indique un type quelconque pas CO
+ elif self.assd in types_permis :
+ l.append(k)
+ elif self.est_permis(v,types_permis):
+ l.append(k)
l.sort()
return l
+ def est_permis(self,v,types_permis):
+ for type_ok in types_permis:
+ if type_ok in ('R','I','C','TXM') and v in self.params :
+ return 1
+ elif type_ok == 'R' and v.__class__.__name__ == 'reel' :
+ return 1
+ elif type_ok == 'I' and v.__class__.__name__ == 'entier' :
+ return 1
+ elif type_ok == 'C' and v.__class__.__name__ == 'complexe' :
+ return 1
+ elif type_ok == 'TXM' and v.__class__.__name__ == 'chaine' :
+ return 1
+ elif type(type_ok) != types.ClassType :
+ continue
+ elif v.__class__ == type_ok or issubclass(v.__class__,type_ok):
+ return 1
+ return 0
+
def addentite(self,name,pos):
"""
Ajoute une entite :
if pos == None : pos = 0
self.etapes.insert(pos,objet)
self.editmode=0
+ self.reset_context()
self.active_etapes()
return objet
elif name == "PARAMETRE_EVAL":
if pos == None : pos = 0
self.etapes.insert(pos,objet)
self.editmode=0
+ self.reset_context()
self.active_etapes()
return objet
elif type(name)==types.InstanceType:
# existante (par copie donc)
# on est donc nécessairement en mode editeur ...
objet = name
- objet.jdc = objet.parent = self
- #XXX current_step n'existe plus. A priori le parent devrait etre self
- # ainsi que le step courant.
- #objet.parent = self.current_step
+ # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
+ objet.reparent(self)
self.set_current_step()
if isinstance(objet,ETAPE):
if objet.nom_niveau_definition == 'JDC':
objet.parent.dict_niveaux[objet.nom_niveau_definition].register(objet)
objet.niveau = objet.parent.dict_niveaux[objet.nom_niveau_definition]
self.etapes.insert(pos,objet)
+ # il faut vérifier que les concepts utilisés par objet existent bien
+ # à ce niveau d'arborescence
+ objet.verif_existence_sd()
self.active_etapes()
self.editmode=0
+ self.reset_context()
return objet
else :
# On veut ajouter une nouvelle commande
cmd=self.get_cmd(name)
# L'appel a make_objet n'a pas pour effet d'enregistrer l'étape
# auprès du step courant car editmode vaut 1
+ # Par contre elle a le bon parent grace a set_current_step
e=cmd.make_objet()
if pos == None : pos = 0
self.etapes.insert(pos,e)
self.reset_current_step()
self.editmode=0
+ self.reset_context()
self.active_etapes()
return e
except:
def get_sd_avant_etape(self,nom_sd,etape):
return self.get_contexte_avant(etape).get(nom_sd,None)
- def get_sd_apres_etape(self,nom_sd,etape):
+ def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
"""
Cette méthode retourne la SD de nom nom_sd qui est éventuellement
- définie apres etape
+ définie apres etape
+ Si avec vaut 'non' exclut etape de la recherche
"""
ietap=self.etapes.index(etape)
- for e in self.etapes[ietap+1:]:
+ if avec == 'non':ietap=ietap+1
+ for e in self.etapes[ietap:]:
sd=e.get_sdprods(nom_sd)
if sd:
if hasattr(e,'reuse'):
return sd
return None
- def get_sd_autour_etape(self,nom_sd,etape):
+ def get_sd_autour_etape(self,nom_sd,etape,avec='non'):
"""
Fonction: retourne la SD de nom nom_sd qui est éventuellement
définie avant ou apres etape
Permet de vérifier si un concept de meme nom existe dans le périmètre
d'une étape
+ Si avec vaut 'non' exclut etape de la recherche
"""
sd=self.get_sd_avant_etape(nom_sd,etape)
if sd:return sd
- return self.get_sd_apres_etape(nom_sd,etape)
+ return self.get_sd_apres_etape(nom_sd,etape,avec)
def active_etapes(self):
"""
"""
self.params.append(param)
+ def register_fonction(self,fonction):
+ """
+ Cette méthode sert à ajouter une fonction dans la liste des fonctions
+ """
+ self.fonctions.append(fonction)
+
def delete_param(self,param):
"""
Supprime le paramètre param de la liste des paramètres
nom = form.nom
if not nom : continue
if d.has_key(nom): l_fonctions.append(form.get_formule())
+
+ # on ajoute les concepts produits par DEFI_VALEUR
+ # XXX On pourrait peut etre faire plutot le test sur le type
+ # de concept : entier, reel, complexe, etc.
+ for k,v in d.items():
+ if hasattr(v,'etape') and v.etape.nom in ('DEFI_VALEUR',):
+ l_constantes.append(k)
+
# on retourne les deux listes
return l_constantes,l_fonctions
linecache.cache[file]=0,0,string.split(text,'\n'),file
return file,text
+
+ def get_genealogie(self):
+ """
+ Retourne la liste des noms des ascendants de l'objet self
+ jusqu'à la première ETAPE parent.
+ """
+ return []
+
+ def NommerSdprod(self,sd,sdnom):
+ """
+ Nomme la SD apres avoir verifie que le nommage est possible : nom
+ non utilise
+ Si le nom est deja utilise, leve une exception
+ Met le concept créé dans le concept global g_context
+ """
+ # XXX En mode editeur dans EFICAS, le nommage doit etre géré différemment
+ # Le dictionnaire g_context ne représente pas le contexte
+ # effectif avant une étape.
+ # Il faut utiliser get_contexte_avant avec une indication de l'étape
+ # traitée. Pour le moment, il n'y a pas de moyen de le faire : ajouter
+ # un attribut dans le JDC ???
+ if CONTEXT.debug : print "JDC.NommerSdprod ",sd,sdnom
+ if self._etape_context:
+ o=self.get_contexte_avant(self._etape_context).get(sdnom,None)
+ else:
+ o=self.g_context.get(sdnom,None)
+ if isinstance(o,ASSD):
+ raise AsException("Nom de concept deja defini : %s" % sdnom)
+
+ # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
+ # Ajoute a la creation (appel de reg_sd).
+ self.g_context[sdnom]=sd
+ sd.nom=sdnom
+
+ def set_etape_context(self,etape):
+ """
+ Positionne l'etape qui sera utilisee dans NommerSdProd pour
+ decider si le concept passé pourra etre nommé
+ """
+ self._etape_context=etape
+
+ def reset_context(self):
+ """
+ Cette methode reinitialise le contexte glissant pour pouvoir
+ tenir compte des modifications de l'utilisateur : création
+ de commandes, nommage de concepts, etc.
+ """
+ self.current_context={}
+ self.index_etape_courante=0
+
+ def del_param(self,param):
+ """
+ Supprime le paramètre param de la liste des paramètres
+ et du contexte gobal
+ """
+ if param in self.params : self.params.remove(param)
+ if self.g_context.has_key(param.nom) : del self.g_context[param.nom]
+
+ def del_fonction(self,fonction):
+ """
+ Supprime la fonction fonction de la liste des fonctions
+ et du contexte gobal
+ """
+ if fonction in self.fonctions : self.fonctions.remove(fonction)
+ if self.g_context.has_key(fonction.nom) : del self.g_context[fonction.nom]
+