1 # -*- coding: utf-8 -*-
2 # CONFIGURATION MANAGEMENT OF EDF VERSION
3 # ======================================================================
4 # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
8 # (AT YOUR OPTION) ANY LATER VERSION.
10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
17 # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
20 # ======================================================================
26 myrepr.maxstring = 100
29 from Noyau.N_utils import repr_float
33 # Attention : les classes ASSD,.... peuvent etre surchargées
34 # dans le package Accas. Il faut donc prendre des précautions si
35 # on utilise les classes du Noyau pour faire des tests (isxxxx, ...)
36 # Si on veut créer des objets comme des CO avec les classes du noyau
37 # ils n'auront pas les conportements des autres packages (pb!!!)
38 # Il vaut mieux les importer d'Accas mais problème d'import circulaire,
39 # on ne peut pas les importer au début.
40 # On fait donc un import local quand c'est nécessaire (peut occasionner
41 # des pbs de prformance).
42 from Noyau.N_ASSD import ASSD,assd
43 from Noyau.N_GEOM import GEOM,geom
44 from Noyau.N_CO import CO
48 from Extensions import parametre
49 from Extensions import param2
52 from I_VALIDATOR import ValError,listProto
54 class MCSIMP(I_OBJECT.OBJECT):
56 def GetNomConcept(self):
60 nomconcept=p.get_sdname()
64 nomconcept= p.object.get_sdname()
73 Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
77 if self.valeur == None :
79 elif type(self.valeur) == types.FloatType :
80 # Traitement d'un flottant isolé
81 txt = str(self.valeur)
82 clefobj=self.GetNomConcept()
83 if self.jdc.appli.dict_reels.has_key(clefobj):
84 if self.jdc.appli.dict_reels[clefobj].has_key(self.valeur):
85 txt=self.jdc.appli.dict_reels[clefobj][self.valeur]
86 elif type(self.valeur) in (types.ListType,types.TupleType) :
87 # Traitement des listes
90 for val in self.valeur:
91 if type(val) == types.FloatType :
92 clefobj=self.GetNomConcept()
93 if self.jdc.appli.dict_reels.has_key(clefobj):
94 if self.jdc.appli.dict_reels[clefobj].has_key(val):
95 txt=txt + sep +self.jdc.appli.dict_reels[clefobj][val]
97 txt=txt + sep + str(val)
99 txt=txt + sep + str(val)
101 txt = txt + sep+ str(val)
103 #ligne trop longue, on tronque
109 # Traitement des autres cas
110 txt = str(self.valeur)
112 # txt peut etre une longue chaine sur plusieurs lignes.
113 # Il est possible de tronquer cette chaine au premier \n et
114 # de limiter la longueur de la chaine a 30 caracteres. Cependant
115 # ceci provoque une perte d'information pour l'utilisateur
116 # Pour le moment on retourne la chaine telle que
121 Retourne une chaîne de caractère représentant la valeur de self
124 if type(val) == types.FloatType :
125 clefobj=self.GetNomConcept()
126 if self.jdc.appli.dict_reels.has_key(clefobj):
127 if self.jdc.appli.dict_reels[clefobj].has_key(val):
128 return self.jdc.appli.dict_reels[clefobj][val]
129 if type(val) != types.TupleType :
131 return val.get_name()
138 s=s+item.get_name()+','
146 Méthode booléenne qui retourne 1 si l'objet attend un objet ASSD
147 qui n'existe pas encore (type CO()), 0 sinon
149 for typ in self.definition.type:
150 if type(typ) == types.ClassType or isinstance(typ,type):
151 if issubclass(typ,CO) :
157 Méthode booléenne qui retourne 1 si le MCS attend un objet de type ASSD
160 for typ in self.definition.type:
161 if type(typ) == types.ClassType or isinstance(typ,type):
162 if issubclass(typ,ASSD) and not issubclass(typ,GEOM):
166 def wait_assd_or_geom(self):
168 Retourne 1 si le mot-clé simple attend un objet de type
169 assd, ASSD, geom ou GEOM
170 Retourne 0 dans le cas contraire
172 for typ in self.definition.type:
173 if type(typ) == types.ClassType or isinstance(typ,type):
174 if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) :
180 Retourne 1 si le mot-clé simple attend un objet de type GEOM
181 Retourne 0 dans le cas contraire
183 for typ in self.definition.type:
184 if type(typ) == types.ClassType or isinstance(typ,type):
185 if issubclass(typ,GEOM) : return 1
190 Retourne 1 si le mot-clé simple attend un objet de type TXM
191 Retourne 0 dans le cas contraire
193 for typ in self.definition.type:
194 if typ == 'TXM' :return 1
197 def get_liste_valeurs(self):
200 if self.valeur == None:
202 elif type(self.valeur) == types.TupleType:
203 return list(self.valeur)
204 elif type(self.valeur) == types.ListType:
210 return self.definition.statut=='o'
212 def valid_val(self,valeur):
214 Verifie que la valeur passee en argument (valeur) est valide
215 sans modifier la valeur courante
217 lval=listProto.adapt(valeur)
220 mess="None n'est pas une valeur autorisée"
224 self.typeProto.adapt(val)
225 self.intoProto.adapt(val)
226 self.cardProto.adapt(lval)
227 if self.definition.validators:
228 self.definition.validators.convert(lval)
235 def valid_valeur(self,new_valeur):
237 Verifie que la valeur passee en argument (new_valeur) est valide
238 sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
240 validite,mess=self.valid_val(new_valeur)
243 def valid_valeur_partielle(self,new_valeur):
245 Verifie que la valeur passee en argument (new_valeur) est une liste partiellement valide
246 sans modifier la valeur courante du mot cle
250 for val in new_valeur:
251 self.typeProto.adapt(val)
252 self.intoProto.adapt(val)
253 #on ne verifie pas la cardinalité
254 if self.definition.validators:
255 validite=self.definition.validators.valide_liste_partielle(new_valeur)
261 def update_condition_bloc(self):
262 """ Met a jour les blocs conditionnels dependant du mot cle simple self
264 if self.definition.position == 'global' :
265 self.etape.deep_update_condition_bloc()
266 elif self.definition.position == 'global_jdc' :
267 self.jdc.deep_update_condition_bloc()
269 self.parent.update_condition_bloc()
271 def set_valeur(self,new_valeur,evaluation='oui'):
272 #print "set_valeur",new_valeur
274 self.valeur = new_valeur
275 self.val = new_valeur
276 self.update_condition_bloc()
280 def eval_valeur(self,new_valeur):
282 Essaie d'évaluer new_valeur comme une SD, une déclaration Python
283 ou un EVAL: Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
285 sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
286 #sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
290 lsd = self.jdc.cherche_list_avant(self.etape,new_valeur)
295 # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
298 objet = eval(new_valeur,d)
301 itparam=self.cherche_item_parametre(new_valeur)
305 object=eval(new_valeur.valeur,d)
308 if CONTEXT.debug : traceback.print_exc()
311 def eval_val(self,new_valeur):
313 Tente d'evaluer new_valeur comme un objet du jdc (par appel a eval_val_item)
314 ou comme une liste de ces memes objets
315 Si new_valeur contient au moins un separateur (,), tente l'evaluation sur
318 if type(new_valeur) in (types.ListType,types.TupleType):
320 for item in new_valeur :
321 valeurretour.append(self.eval_val_item(item))
324 valeur=self.eval_val_item(new_valeur)
327 def eval_val_item(self,new_valeur):
329 Tente d'evaluer new_valeur comme un concept, un parametre, un objet Python
330 Si c'est impossible retourne new_valeur inchange
331 argument new_valeur : string (nom de concept, de parametre, expression ou simple chaine)
333 if self.etape and self.etape.parent:
334 valeur=self.etape.parent.eval_in_context(new_valeur,self.etape)
341 #traceback.print_exc()
345 def cherche_item_parametre (self,new_valeur):
347 nomparam=new_valeur[0:new_valeur.find("[")]
348 indice=new_valeur[new_valeur.find("[")+1:new_valeur.find("]")]
349 for p in self.jdc.params:
350 if p.nom == nomparam :
351 if int(indice) < len(p.get_valeurs()):
352 itparam=parametre.ITEM_PARAMETRE(p,int(indice))
358 def update_concept(self,sd):
359 if type(self.valeur) in (types.ListType,types.TupleType) :
360 if sd in self.valeur:self.fin_modif()
362 if sd == self.valeur:self.fin_modif()
364 def delete_concept(self,sd):
369 Met a jour la valeur du mot cle simple suite à la disparition
372 #print "delete_concept",sd
373 if type(self.valeur) == types.TupleType :
374 if sd in self.valeur:
376 self.valeur=list(self.valeur)
377 self.valeur.remove(sd)
379 elif type(self.valeur) == types.ListType:
380 if sd in self.valeur:
382 self.valeur.remove(sd)
385 if self.valeur == sd:
391 def replace_concept(self,old_sd,sd):
394 - old_sd=concept remplacé
397 Met a jour la valeur du mot cle simple suite au remplacement
400 #print "replace_concept",old_sd,sd
401 if type(self.valeur) == types.TupleType :
402 if old_sd in self.valeur:
404 self.valeur=list(self.valeur)
405 i=self.valeur.index(old_sd)
408 elif type(self.valeur) == types.ListType:
409 if old_sd in self.valeur:
411 i=self.valeur.index(old_sd)
415 if self.valeur == old_sd:
421 def set_valeur_co(self,nom_co):
423 Affecte à self l'objet de type CO et de nom nom_co
425 #print "set_valeur_co",nom_co
426 step=self.etape.parent
427 if nom_co == None or nom_co == '':
430 # Avant de créer un concept il faut s'assurer du contexte : step
432 sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui')
434 # Si un concept du meme nom existe deja dans la portée de l'étape
435 # on ne crée pas le concept
436 return 0,"un concept de meme nom existe deja"
437 # Il n'existe pas de concept de meme nom. On peut donc le créer
438 # Il faut néanmoins que la méthode NommerSdProd de step gère les
439 # contextes en mode editeur
440 # Normalement la méthode du Noyau doit etre surchargée
441 # On déclare l'étape du mot clé comme etape courante pour NommerSdprod
442 cs= CONTEXT.get_current_step()
443 CONTEXT.unset_current_step()
444 CONTEXT.set_current_step(step)
445 step.set_etape_context(self.etape)
446 new_objet = Accas.CO(nom_co)
447 CONTEXT.unset_current_step()
448 CONTEXT.set_current_step(cs)
450 self.valeur = new_objet
452 # On force l'enregistrement de new_objet en tant que concept produit
453 # de la macro en appelant get_type_produit avec force=1
454 self.etape.get_type_produit(force=1)
457 #print "set_valeur_co",new_objet
458 return 1,"Concept créé"
460 def verif_existence_sd(self):
462 Vérifie que les structures de données utilisées dans self existent bien dans le contexte
463 avant étape, sinon enlève la référence à ces concepts
465 #print "verif_existence_sd"
466 # Attention : possible probleme avec include
467 # A priori il n'y a pas de raison de retirer les concepts non existants
468 # avant etape. En fait il s'agit uniquement eventuellement de ceux crees par une macro
469 l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values()
470 if type(self.valeur) in (types.TupleType,types.ListType) :
472 for sd in self.valeur:
473 if isinstance(sd,ASSD) :
474 if sd in l_sd_avant_etape or self.etape.get_sdprods(sd.nom) is sd:
478 if len(l) < len(self.valeur):
483 if isinstance(self.valeur,ASSD) :
484 if self.valeur not in l_sd_avant_etape and self.etape.get_sdprods(self.valeur.nom) is None:
489 def get_min_max(self):
491 Retourne les valeurs min et max admissibles pour la valeur de self
493 return self.definition.min,self.definition.max
498 Retourne le type attendu par le mot-clé simple
500 return self.definition.type
502 def delete_mc_global(self):
503 """ Retire self des declarations globales
505 if self.definition.position == 'global' :
506 etape = self.get_etape()
508 del etape.mc_globaux[self.nom]
509 elif self.definition.position == 'global_jdc' :
510 del self.jdc.mc_globaux[self.nom]
512 def update_mc_global(self):
514 Met a jour les mots cles globaux enregistrés dans l'étape parente
515 et dans le jdc parent.
516 Un mot cle simple peut etre global.
518 if self.definition.position == 'global' :
519 etape = self.get_etape()
521 etape.mc_globaux[self.nom]=self
522 elif self.definition.position == 'global_jdc' :
524 self.jdc.mc_globaux[self.nom]=self
526 def nbrColonnes(self):
527 genea = self.get_genealogie()
528 if "VALE_C" in genea and "DEFI_FONCTION" in genea : return 3
529 if "VALE" in genea and "DEFI_FONCTION" in genea : return 2
532 def valide_item(self,item):
533 """Valide un item isolé. Cet item est candidat à l'ajout à la liste existante"""
537 self.typeProto.adapt(item)
538 #on verifie les choix possibles
539 self.intoProto.adapt(item)
540 #on ne verifie pas la cardinalité
541 if self.definition.validators:
542 valid=self.definition.validators.verif_item(item)
544 #traceback.print_exc()
548 def verif_type(self,item):
549 """Verifie le type d'un item de liste"""
552 self.typeProto.adapt(item)
553 #on verifie les choix possibles
554 self.intoProto.adapt(item)
555 #on ne verifie pas la cardinalité mais on verifie les validateurs
556 if self.definition.validators:
557 valid=self.definition.validators.verif_item(item)
561 #traceback.print_exc()
566 #--------------------------------------------------------------------------------
568 #ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation
569 # Elles doivent etre reintegrees des que possible
572 def verif_typeihm(self,val,cr='non'):
577 traceback.print_exc()
579 return self.verif_type(val,cr)
581 def verif_typeliste(self,val,cr='non') :
584 verif=verif+self.verif_typeihm(v,cr)
587 def init_modif_up(self):
588 Validation.V_MCSIMP.MCSIMP.init_modif_up(self)
589 CONNECTOR.Emit(self,"valid")