+# -*- coding: utf-8 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
# ======================================================================
"""
"""
-import string,types
+import string,types,sys
from copy import copy
+import traceback
from Noyau.N_MCLIST import MCList
from Noyau.N_MCSIMP import MCSIMP
from Noyau.N_MCFACT import MCFACT
from Noyau.N_MCBLOC import MCBLOC
import I_OBJECT
+import Validation
+
+import CONNECTOR
class MCCOMPO(I_OBJECT.OBJECT):
def getlabeltext(self):
"""
- Retourne le label de self suivant qu'il s'agit d'un MCFACT,
- d'un MCBLOC ou d'un MCFACT appartenant à une MCList :
- utilisée pour l'affichage dans l'arbre
+ Retourne le label de self
+ utilisé pour l'affichage dans l'arbre
"""
- objet = self.parent.get_child(self.nom)
- # objet peut-être self ou une MCList qui contient self ...
- if isinstance(objet,MCList) :
- index = objet.get_index(self)+1 # + 1 à cause de la numérotation qui commence à 0
- label = self.nom +'_'+`index`+':'
- return label
- else:
- return self.nom
+ return self.nom
def get_liste_mc_ordonnee(self,liste,dico):
"""
l.append(k)
return l
+ def get_index_child(self,nom_fils):
+ """
+ Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
+ Permet de savoir à quelle position il faut ajouter un nouveau mot-clé
+ """
+ cata_ordonne = self.jdc.cata_ordonne_dico
+ liste_noms_mc_ordonnee = self.get_liste_mc_ordonnee_brute(self.get_genealogie(),cata_ordonne)
+ liste_noms_mc_presents = self.liste_mc_presents()
+ index=0
+ for nom in liste_noms_mc_ordonnee:
+ if nom == nom_fils:break
+ if nom not in liste_noms_mc_presents :continue
+ index=index+1
+ return index
+
def ordonne_liste_mc(self,liste_mc_a_ordonner,liste_noms_mc_ordonnee):
"""
Retourne liste_mc_a_ordonner ordonnée suivant l'ordre
Retourne 1 si la suppression a pu être effectuée,
Retourne 0 dans le cas contraire
"""
- self.init_modif()
if not objet in self.mc_liste:
# Impossible de supprimer objet. Il n'est pas dans mc_liste
- self.fin_modif()
return 0
- try :
- if hasattr(objet.definition,'position'):
- if objet.definition.position == 'global' :
- self.delete_mc_global(objet)
- elif objet.definition.position == 'global_jdc' :
- self.delete_mc_global_jdc(objet)
- self.mc_liste.remove(objet)
- self.fin_modif()
- return 1
- except:
- self.fin_modif()
- return 0
+ self.init_modif()
+ self.mc_liste.remove(objet)
+ CONNECTOR.Emit(self,"supp",objet)
+ objet.delete_mc_global()
+ objet.update_condition_bloc()
+ objet.supprime()
+ self.fin_modif()
+ return 1
def isoblig(self):
return 0
# on est en mode création d'un motcle
if self.ispermis(name) == 0 : return 0
objet=self.definition.entites[name](val=None,nom=name,parent=self)
- if hasattr(objet.definition,'position'):
- if objet.definition.position == 'global' :
- self.append_mc_global(objet)
- elif objet.definition.position == 'global_jdc' :
- self.append_mc_global_jdc(objet)
else :
# dans ce cas on est en mode copie d'un motcle
objet = name
- objet.verif_existence_sd()
- # si un objet de même nom est déjà présent dans la liste
- # et si l'objet est répétable
- # il faut créer une MCList et remplacer l'objet de la liste
- # par la MCList
- test1 = objet.isrepetable()
- old_obj = self.get_child(objet.nom,restreint = 'oui')
- test2 = self.ispermis(objet)
- #print "test1,test2=",test1,test2
- if test1 == 0 and old_obj :
- self.jdc.send_message("L'objet %s ne peut pas être répété" %objet.nom)
- self.fin_modif()
- return 0
- if test2 == 0:
- self.jdc.send_message("L'objet %s ne peut être un fils de %s" %(objet.nom,self.nom))
+ # Appel de la methode qui fait le menage dans les references
+ # sur les concepts produits (verification que les concepts existent
+ # dans le contexte de la commande courante).
+ objet.verif_existence_sd()
+
+ # On verifie que l'ajout d'objet est autorise
+ if self.ispermis(objet) == 0:
+ self.jdc.send_message("L'objet %s ne peut être un fils de %s" %(objet.nom,
+ self.nom))
self.fin_modif()
return 0
- if test1 :
- if old_obj :
- #if not isinstance(old_obj,MCList):
- if not old_obj.isMCList():
- # un objet de même nom existe déjà mais ce n'est pas une MCList
- # Il faut en créer une
- # L'objet existant (old_obj) est certainement un MCFACT
- # qui pointe vers un constructeur
- # de MCList : definition.liste_instance
- #print "un objet de même type existe déjà"
- index = self.mc_liste.index(old_obj)
- #XXX remplacé par definition.list_instance : new_obj = MCList()
- new_obj = old_obj.definition.list_instance()
- new_obj.init(objet.nom,self)
- new_obj.append(old_obj)
- new_obj.append(objet)
- # Il ne faut pas oublier de reaffecter le parent d'obj
- objet.reparent(self)
- self.mc_liste.remove(old_obj)
- self.mc_liste.insert(index,new_obj)
+
+ # On cherche s'il existe deja un mot cle de meme nom
+ old_obj = self.get_child(objet.nom,restreint = 'oui')
+ if not old_obj :
+ # on normalize l'objet
+ objet=objet.normalize()
+ # Le mot cle n'existe pas encore. On l'ajoute a la position
+ # demandee (pos)
+ if pos == None :
+ self.mc_liste.append(objet)
+ else :
+ self.mc_liste.insert(pos,objet)
+ # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
+ objet.reparent(self)
+ CONNECTOR.Emit(self,"add",objet)
+ objet.update_mc_global()
+ objet.update_condition_bloc()
+ self.fin_modif()
+ return objet
+ else:
+ # Le mot cle existe deja. Si le mot cle est repetable,
+ # on cree une liste d'objets. Dans le cas contraire,
+ # on emet un message d'erreur.
+ if not old_obj.isrepetable():
+ self.jdc.send_message("L'objet %s ne peut pas être répété" %objet.nom)
self.fin_modif()
- return new_obj
- else :
+ return 0
+ else:
# une liste d'objets de même type existe déjà
- #print "une liste d'objets de même type existe déjà"
- old_obj.append(objet)
- # Il ne faut pas oublier de reaffecter le parent d'obj
- objet.reparent(self)
+ old_obj.addentite(objet)
self.fin_modif()
return old_obj
- if pos == None :
- self.mc_liste.append(objet)
- else :
- self.mc_liste.insert(pos,objet)
- # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
- objet.reparent(self)
- self.fin_modif()
- return objet
def ispermis(self,fils):
"""
if fils.parent.nom != self.nom : return 0
return 1
- def liste_mc_presents(self):
- """
- Retourne la liste des noms des mots-clés fils de self présents
- construite à partir de self.mc_liste
- """
- l=[]
- for v in self.mc_liste:
- k=v.nom
- l.append(k)
- return l
+ def update_concept(self,sd):
+ for child in self.mc_liste :
+ child.update_concept(sd)
def delete_concept(self,sd):
"""
for child in self.mc_liste :
child.replace_concept(old_sd,sd)
- def delete_mc_global(self,mc):
- """
- Supprime le mot-clé mc de la liste des mots-clés globaux de l'étape
- """
- etape = self.get_etape()
- if etape :
- nom = mc.nom
- del etape.mc_globaux[nom]
-
- def delete_mc_global_jdc(self,mc):
- """
- Supprime le mot-clé mc de la liste des mots-clés globaux du jdc
- """
- nom = mc.nom
- del self.jdc.mc_globaux[nom]
-
def get_liste_mc_inconnus(self):
"""
Retourne la liste des mots-clés inconnus dans self
l_mc = []
if self.reste_val != {}:
for k,v in self.reste_val.items() :
- l_mc.append([self,k,v])
+ l_mc.append([self,k,v])
for child in self.mc_liste :
if child.isvalid() : continue
l_child = child.get_liste_mc_inconnus()
for mc in l_child:
- l = [self]
- l.extend(mc)
- l_mc.append(l)
+ l = [self]
+ l.extend(mc)
+ l_mc.append(l)
return l_mc
+ def deep_update_condition_bloc(self):
+ """
+ Parcourt l'arborescence des mcobject et realise l'update
+ des blocs conditionnels par appel de la methode update_condition_bloc
+ """
+ self._update_condition_bloc()
+ for mcobj in self.mc_liste:
+ if hasattr(mcobj,"deep_update_condition_bloc"):
+ mcobj.deep_update_condition_bloc()
+
+ def update_condition_bloc(self):
+ """
+ Realise l'update des blocs conditionnels fils de self
+ et propage au parent
+ """
+ self._update_condition_bloc()
+ if self.parent:self.parent.update_condition_bloc()
+
+ def _update_condition_bloc(self):
+ """
+ Realise l'update des blocs conditionnels fils de self
+ """
+ dict = self.cree_dict_condition(self.mc_liste,condition=1)
+ for k,v in self.definition.entites.items():
+ if v.label != 'BLOC' :continue
+ globs= self.jdc and self.jdc.condition_context or {}
+ bloc=self.get_child(k,restreint = 'oui')
+ presence=v.verif_presence(dict,globs)
+ if presence and not bloc:
+ # le bloc doit être présent
+ # mais le bloc n'est pas présent et il doit être créé
+ #print "AJOUT BLOC",k
+ pos=self.get_index_child(k)
+ self.addentite(k,pos)
+ if not presence and bloc:
+ # le bloc devrait être absent
+ # le bloc est présent : il faut l'enlever
+ #print "SUPPRESSION BLOC",k,bloc
+ self.suppentite(bloc)
+
def verif_condition_bloc(self):
"""
Evalue les conditions de tous les blocs fils possibles
"""
liste_ajouts = []
liste_retraits = []
- dict = self.cree_dict_condition(self.mc_liste)
+ dict = self.cree_dict_condition(self.mc_liste,condition=1)
for k,v in self.definition.entites.items():
if v.label=='BLOC' :
globs= self.jdc and self.jdc.condition_context or {}
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
+ avant étape, sinon enlève la référence à ces concepts
"""
for motcle in self.mc_liste :
motcle.verif_existence_sd()
+
+ def update_mc_global(self):
+ """
+ Met a jour les mots cles globaux enregistrés dans l'étape parente
+ et dans le jdc parent.
+ Un mot cle compose ne peut pas etre global. Il se contente de passer
+ la requete a ses fils.
+ """
+ for motcle in self.mc_liste :
+ motcle.update_mc_global()
+
+ def delete_mc_global(self):
+ for motcle in self.mc_liste :
+ motcle.delete_mc_global()
+ try :
+ motcle.update_mc_global()
+ except :
+ pass
+
+ def init_modif_up(self):
+ Validation.V_MCCOMPO.MCCOMPO.init_modif_up(self)
+ CONNECTOR.Emit(self,"valid")
+