+# 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.
+#
+#
+# ======================================================================
import types,string
import traceback
from copy import copy
myrepr.maxother = 100
from Noyau.N_utils import repr_float
+
+# Attention : les classes ASSD,.... peuvent etre surchargées
+# dans le package Accas. Il faut donc prendre des précautions si
+# on utilise les classes du Noyau pour faire des tests (isxxxx, ...)
+# Si on veut créer des objets comme des CO avec les classes du noyau
+# ils n'auront pas les conportements des autres packages (pb!!!)
+# Il vaut mieux les importer d'Accas mais problème d'import circulaire,
+# on ne peut pas les importer au début.
+# On fait donc un import local quand c'est nécessaire (peut occasionner
+# des pbs de prformance).
from Noyau.N_ASSD import ASSD,assd
from Noyau.N_GEOM import GEOM,geom
from Noyau.N_CO import CO
-from Noyau.N_EVAL import EVAL
+# fin attention
+
from Extensions import parametre
import I_OBJECT
if self.valeur == None :
return None
elif type(self.valeur) == types.FloatType :
- txt = repr_float(self.valeur)
+ #txt = repr_float(self.valeur)
+ # Normalement str fait un travail correct
+ txt = str(self.valeur)
elif type(self.valeur) in (types.ListType,types.TupleType) :
txt='('
i=0
for val in self.valeur:
if type(val) == types.FloatType :
- txt=txt + i*',' + repr_float(val)
+ # Normalement str fait un travail correct
+ #txt=txt + i*',' + repr_float(val)
+ txt=txt + i*',' + str(val)
elif type(val) == types.InstanceType and isinstance(val,ASSD):
txt = txt + i*',' + val.get_name()
else:
if isinstance(txt,parametre.PARAMETRE):
return str(txt)
return repr(txt)
- # il faut tronquer txt au delà d'un certain nombre de caractères
- # et avant tout retour chariot (txt peut être une chaîne de caractères
+ # txt peut etre une longue chaine sur plusieurs lignes.
+ # Il est possible de tronquer cette chaine au premier \n et
+ # de limiter la longueur de la chaine a 30 caracteres. Cependant
+ # ceci provoque une perte d'information pour l'utilisateur
+ # Pour le moment on retourne la chaine telle que
+ return txt
+
+ # Partie de code inaccessible (pour memoire)
+ # txt est tronquee au dela d'un certain nombre de caractères
+ # et avant tout retour chariot (txt peut etre une chaine de caractères
# sur plusieurs lignes (ex:shell)
txt = string.split(txt,'\n')[0]
if len(txt) < 30 :
"""
for typ in self.definition.type:
if type(typ) == types.ClassType :
- if typ is CO : return 1
+ if issubclass(typ,CO) :
+ return 1
return 0
def wait_assd(self):
"""
for typ in self.definition.type:
if type(typ) == types.ClassType :
- if typ in (GEOM,ASSD,geom,assd) or issubclass(typ,GEOM) :
+ if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) :
return 1
return 0
# type de nom new_valeur
if self.wait_co():
try:
+ # Pour avoir la classe CO avec tous ses comportements
+ from Accas import CO
self.valeur=CO(new_valeur)
except:
traceback.print_exc()
return sd,1
else:
d={}
+ # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
+ from Accas import EVAL
d['EVAL']=EVAL
try :
objet = eval(new_valeur,d)
def copy(self):
""" Retourne une copie de self """
objet = self.makeobjet()
- #XXX est ce utile ??
- objet.valeur = copy(self.valeur)
- objet.val = copy(self.val)
+ # il faut copier les listes et les tuples mais pas les autres valeurs
+ # possibles (réel,SD,...)
+ if type(self.valeur) in (types.ListType,types.TupleType):
+ objet.valeur = copy(self.valeur)
+ else:
+ objet.valeur = self.valeur
+ objet.val = objet.valeur
return objet
def makeobjet(self):
if issubclass(self.valeur.__class__,ASSD) : l.append(self.valeur)
return l
+
+ def set_valeur_co(self,nom_co):
+ """
+ Affecte à self l'objet de type CO et de nom nom_co
+ """
+ step=self.etape.parent
+ if nom_co == None or nom_co == '':
+ new_objet=None
+ else:
+ # Pour le moment on importe en local le CO de Accas.
+ # Si problème de perfs, il faudra faire autrement
+ from Accas import CO
+ # Avant de créer un concept il faut s'assurer du contexte : step
+ # courant
+ sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui')
+ if sd:
+ # Si un concept du meme nom existe deja dans la portée de l'étape
+ # on ne crée pas le concept
+ return 0,"un concept de meme nom existe deja"
+ # Il n'existe pas de concept de meme nom. On peut donc le créer
+ # Il faut néanmoins que la méthode NommerSdProd de step gère les
+ # contextes en mode editeur
+ # Normalement la méthode du Noyau doit etre surchargée
+ # On déclare l'étape du mot clé comme etape courante pour NommerSdprod
+ cs= CONTEXT.get_current_step()
+ CONTEXT.unset_current_step()
+ CONTEXT.set_current_step(step)
+ step.set_etape_context(self.etape)
+ new_objet = CO(nom_co)
+ CONTEXT.unset_current_step()
+ CONTEXT.set_current_step(cs)
+ self.valeur = new_objet
+ self.val = new_objet
+ self.init_modif()
+ step.reset_context()
+ # On force l'enregistrement de new_objet en tant que concept produit
+ # de la macro en appelant get_type_produit avec force=1
+ self.etape.get_type_produit(force=1)
+ return 1,"Concept créé"
+
+ def reparent(self,parent):
+ """
+ Cette methode sert a reinitialiser la parente de l'objet
+ """
+ self.parent=parent
+ self.jdc=parent.jdc
+ self.etape=parent.etape
+
+ 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
+ """
+ l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values()
+ if type(self.valeur) in (types.TupleType,types.ListType) :
+ l=[]
+ for sd in self.valeur:
+ if isinstance(sd,ASSD) :
+ if sd in l_sd_avant_etape :
+ l.append(sd)
+ else:
+ l.append(sd)
+ self.valeur=l
+ self.init_modif()
+ else:
+ if isinstance(self.valeur,ASSD) :
+ if self.valeur not in l_sd_avant_etape :
+ self.valeur = None
+ self.init_modif()
+
+
+ def get_min_max(self):
+ """
+ Retourne les valeurs min et max admissibles pour la valeur de self
+ """
+ return self.definition.min,self.definition.max
+
+
+ def get_type(self):
+ """
+ Retourne le type attendu par le mot-clé simple
+ """
+ return self.definition.type
+
+
+
+
+
+
+
+
+
+
+
+
+
+
