+# -*- coding: utf-8 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
if self.valeur == None :
return None
elif type(self.valeur) == types.FloatType :
+ # Traitement d'un flottant isolé
#txt = repr_float(self.valeur)
# Normalement str fait un travail correct
txt = str(self.valeur)
elif type(self.valeur) in (types.ListType,types.TupleType) :
+ # Traitement des listes
txt='('
i=0
for val in self.valeur:
if type(val) == types.FloatType :
- # Normalement str fait un travail correct
+ # CCAR : 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):
+ elif isinstance(val,ASSD):
txt = txt + i*',' + val.get_name()
+ #PN
+ # ajout du elif
+ elif type(val) == types.InstanceType and val.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
+ txt = txt + i*','+ str(val)
else:
txt = txt + i*','+ myrepr.repr(val)
i=1
txt=txt+')'
+ elif isinstance(self.valeur,ASSD):
+ # Cas des ASSD
+ txt=self.getval()
+ elif type(self.valeur) == types.InstanceType and self.valeur.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
+ # Cas des PARAMETRES
+ txt=str(self.valeur)
else:
- txt = self.getval()
- if type(txt) != types.StringType:
- if type(txt) == types.InstanceType:
- if isinstance(txt,parametre.PARAMETRE):
- return str(txt)
- return repr(txt)
+ # Traitement des autres cas
+ txt = myrepr.repr(self.valeur)
+
# 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
# 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 :
- return txt
- else:
- return txt[0:29]
-
def getval(self):
"""
Retourne une chaîne de caractère représentant la valeur de self
s=s+' )'
return s
- def get_min_max(self):
- return self.definition.min,self.definition.max
-
def wait_co(self):
"""
Méthode booléenne qui retourne 1 si l'objet attend un objet ASSD
def wait_assd_or_geom(self):
"""
Retourne 1 si le mot-clé simple attend un objet de type
- assd, ASSD, geom ou GEOM
+ assd, ASSD, geom ou GEOM
Retourne 0 dans le cas contraire
"""
for typ in self.definition.type:
return self.definition.statut=='o'
def set_valeur(self,new_valeur,evaluation='oui'):
- """
- Remplace la valeur de self(si elle existe) par new_valeur
- - si evaluation = 'oui' :
- essaie d'évaluer new_valeur dans le contexte
- - si evaluation = 'non' :
- n'essaie pas d'évaluer (on stocke une string ou
- une valeur de la liste into )
- """
- if evaluation == 'oui' and not self.wait_assd_or_geom():
- valeur,test = self.eval_valeur(new_valeur)
- if test :
- self.val = new_valeur
- self.valeur = valeur
self.init_modif()
- self.fin_modif()
- return 1
- else:
- # On n'a pas trouve de concept ni réussi à évaluer la valeur
- # dans le contexte
- # Si le mot cle simple attend un type CO on crée un objet de ce
- # 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 0
- self.init_modif()
- self.val=self.valeur
- self.fin_modif()
- return 1
- elif type(new_valeur)==types.StringType and self.wait_TXM():
- self.init_modif()
- self.val = new_valeur
- self.valeur = new_valeur
- self.fin_modif()
- return 1
- else:
- return 0
- else :
- # on ne fait aucune vérification ...
- self.init_modif()
- try:
- self.valeur = eval(new_valeur)
- self.val = eval(new_valeur)
- self.fin_modif()
- return 1
- except:
self.valeur = new_valeur
self.val = new_valeur
self.fin_modif()
def eval_valeur(self,new_valeur):
"""
Essaie d'évaluer new_valeur comme une SD, une déclaration Python
- ou un EVAL:
- Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
+ ou un EVAL: Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
"""
- #sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
if sd :
return sd,1
objet = eval(new_valeur,d)
return objet,1
except Exception:
-# PN :
-# - Ajout de quote autour de la valeur en cas de chaine de caracteres
- if type(new_valeur)==types.StringType and self.wait_TXM():
- new_valeur="'"+new_valeur+"'"
- try :
- objet = eval(new_valeur,d)
- return objet,1
- except :
- return None,0
+ itparam=self.cherche_item_parametre(new_valeur)
+ if itparam:
+ return itparam,1
if CONTEXT.debug : traceback.print_exc()
return None,0
+ def cherche_item_parametre (self,new_valeur):
+ try:
+ nomparam=new_valeur[0:new_valeur.find("[")]
+ indice=new_valeur[new_valeur.find("[")+1:new_valeur.find("]")]
+ for p in self.jdc.params:
+ if p.nom == nomparam :
+ if int(indice) < len(p.get_valeurs()):
+ itparam=parametre.ITEM_PARAMETRE(p,int(indice))
+ return itparam
+ return None
+ except:
+ return None
+
+
def delete_concept(self,sd):
"""
Inputs :
- sd=concept detruit
+ - sd=concept detruit
Fonction :
- Met a jour la valeur du mot cle simple suite à la disparition
- du concept sd
+ Met a jour la valeur du mot cle simple suite à la disparition
+ du concept sd
"""
if type(self.valeur) == types.TupleType :
if sd in self.valeur:
def replace_concept(self,old_sd,sd):
"""
Inputs :
- old_sd=concept remplacé
- sd=nouveau concept
+ - old_sd=concept remplacé
+ - sd=nouveau concept
Fonction :
- Met a jour la valeur du mot cle simple suite au remplacement
- du concept old_sd
+ Met a jour la valeur du mot cle simple suite au remplacement
+ du concept old_sd
"""
if type(self.valeur) == types.TupleType :
if old_sd in self.valeur:
self.val=sd
self.init_modif()
- def copy(self):
- """ Retourne une copie de self """
- objet = self.makeobjet()
- # 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):
- return self.definition(val = None, nom = self.nom,parent = self.parent)
-
- def get_sd_utilisees(self):
- """
- Retourne une liste qui contient la SD utilisée par self si c'est le cas
- ou alors une liste vide
- """
- l=[]
- if type(self.valeur) == types.InstanceType:
- #XXX Est ce différent de isinstance(self.valeur,ASSD) ??
- 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
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
l.append(sd)
else:
l.append(sd)
- self.valeur=l
+ self.valeur=tuple(l)
# Est ce init_modif ou init_modif_up
# Normalement init_modif va avec fin_modif
self.init_modif()
Retourne le type attendu par le mot-clé simple
"""
return self.definition.type
+
+#--------------------------------------------------------------------------------
+# PN : ajout pour Salome des methodes suivantes (jusqu aux méthodes surchargees)
+#--------------------------------------------------------------------------------
+ def get_salome_valeurs(self):
+ l=[]
+ if not hasattr(self,'list_salome_valeurs'):
+ self.list_salome_valeurs=[]
+ if self.list_salome_valeurs != [] :
+ for val in self.list_salome_valeurs:
+ l.append(val)
+ return l
+
+ def put_salome_valeurs(self,list):
+ self.list_salome_valeurs=[]
+ for val in list:
+ self.list_salome_valeurs.append(val)
+
+ def add_salome_valeurs(self,val):
+ if not hasattr(self,'list_salome_valeurs'):
+ self.list_salome_valeurs=[]
+ try:
+ self.list_salome_valeurs.append(val)
+ except :
+ try:
+ for uneval in val :
+ self.list_salome_valeurs.append(uneval)
+ except :
+ pass
+
+ def has_salome_valeurs(self):
+ if not hasattr(self,'list_salome_valeurs'):
+ self.list_salome_valeurs=[]
+ if self.list_salome_valeurs != []:
+ return true
+ else:
+ return false
+
+#--------------------------------------------------------------------------------
+# PN : fin ajout pour Salome
+#--------------------------------------------------------------------------------
#ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation
# Elles doivent etre reintegrees des que possible
+
+
+ def isvalid(self,cr='non'):
+ """
+ Cette méthode retourne un indicateur de validité de l'objet de type MCSIMP
+
+ - 0 si l'objet est invalide
+ - 1 si l'objet est valide
+
+ Le paramètre cr permet de paramétrer le traitement. Si cr == 'oui'
+ la méthode construit également un comte-rendu de validation
+ dans self.cr qui doit avoir été créé préalablement.
+ """
+ if self.state == 'unchanged':
+ return self.valid
+ else:
+ valid = 1
+ v=self.valeur
+ # verification presence
+ if self.isoblig() and v == None :
+ if cr == 'oui' :
+ self.cr.fatal(string.join(("Mot-clé : ",self.nom," obligatoire non valorisé")))
+ valid = 0
+
+ if v is None:
+ valid=0
+ if cr == 'oui' :
+ self.cr.fatal("None n'est pas une valeur autorisée")
+ else:
+ # type,into ...
+ if v.__class__.__name__=='PARAMETRE' or v.__class__.__name__ == 'ITEM_PARAMETRE':
+ verif_type=1
+ else:
+ verif_type=self.verif_type(val=v,cr=None)
+ # cas des tuples avec un ITEM_PARAMETRE
+ if verif_type == 0:
+ if type(v) == types.TupleType :
+ new_val=[]
+ for i in v:
+ if i.__class__.__name__ != 'PARAMETRE':
+ if i.__class__.__name__ != 'ITEM_PARAMETRE':
+ new_val.append(i)
+ if new_val != [] :
+ verif_type=self.verif_type(val=new_val,cr=cr)
+ else :
+ # Cas d une liste de paramétre
+ verif_type= 1
+ else:
+ verif_type=self.verif_type(val=v,cr=None)
+ valid = verif_type*self.verif_into(cr=cr)*self.verif_card(cr=cr)
+ #
+ # On verifie les validateurs s'il y en a et si necessaire (valid == 1)
+ #
+ if valid and self.definition.validators and not self.definition.validators.verif(self.valeur):
+ if cr == 'oui' :
+ self.cr.fatal(string.join(("Mot-clé : ",self.nom,"devrait avoir ",self.definition.validators.info())))
+ valid=0
+ # fin des validateurs
+ #
+ # cas d un item Parametre
+ if self.valeur.__class__.__name__ == 'ITEM_PARAMETRE':
+ valid=self.valeur.isvalid()
+ if valid == 0:
+ if cr == 'oui' :
+ self.cr.fatal(string.join( repr (self.valeur), " a un indice incorrect"))
+
+ self.set_valid(valid)
+ return self.valid