1 #@ MODIF definition_cata Accas DATE 02/07/2001 AUTEUR D6BHHJP J.P.LEFEBVRE
2 # CONFIGURATION MANAGEMENT OF EDF VERSION
3 # ======================================================================
4 # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
5 # SEE THE FILE "LICENSE.TERMS" FOR INFORMATION ON USAGE AND
6 # REDISTRIBUTION OF THIS FILE.
7 # ======================================================================
13 from Noyau.N_CR import CR
16 def __init__(self,modules_cata):
17 self.modules_cata = modules_cata # tuple de modules...
19 self.state='undetermined'
20 self.entites_attributs = {}
21 self.entites_fils = []
22 self.build_entites_attributs()
23 self.build_entites_fils()
25 def build_entites_attributs(self):
28 def build_entites_fils(self):
29 niv_types = Accas.NIVEAU(nom="types",label="Liste des types")
30 niv_commandes = Accas.NIVEAU(nom="commandes",label="Liste des commandes")
31 self.entites_fils.append(make_commande_cata(niv_types,self))
32 self.entites_fils.append(make_commande_cata(niv_commandes,self))
33 for module_cata in self.modules_cata:
34 for e in dir(module_cata):
35 obj = getattr(module_cata,e)
37 self.entites_fils[1].register(make_commande_cata(obj,self.entites_fils[1]))
38 elif type(obj) == types.ClassType:
39 if issubclass(obj,Accas.ASSD):
40 self.entites_fils[0].register(TYPE_CATA(obj))
43 self.state = 'modified'
47 Methode pour generation d un rapport de validite
50 self.cr.debut="DEBUT CR validation : "
51 self.cr.fin="FIN CR validation :"
52 self.state = 'modified'
53 self.isvalid(cr='oui')
54 for fils in self.entites_fils[1].entites :
55 self.cr.add(fils.report())
58 def isvalid(self,cr='non'):
59 if self.state != 'unchanged':
61 for fils in self.entites_fils[1].entites_fils:
62 if not fils.isvalid():
66 self.state='unchanged'
69 def make_commande_cata(objet,pere):
70 if isinstance(objet,Accas.OPER):
71 return OPER_CATA(objet,pere,objet.nom)
72 elif isinstance(objet,Accas.PROC):
73 return PROC_CATA(objet,pere,objet.nom)
74 elif isinstance(objet,Accas.MACRO):
75 return MACRO_CATA(objet,pere,objet.nom)
76 elif isinstance(objet,Accas.FORM):
77 return MACRO_CATA(objet,pere,objet.nom)
78 elif isinstance(objet,Accas.NIVEAU):
79 return NIVEAU_CATA(objet,pere,objet.nom)
81 print "Erreur dans make_commande_cata : on cherche à évaluer un objet non référencé ",objet
83 def make_mc_cata(objet,pere,nom=''):
84 if isinstance(objet,Accas.BLOC):
85 return BLOC_CATA(objet,pere,nom)
86 elif isinstance(objet,Accas.FACT):
87 return FACT_CATA(objet,pere,nom)
88 elif isinstance(objet,Accas.SIMP):
89 return SIMP_CATA(objet,pere,nom)
91 print "Erreur dans make_mc_cata : on cherche à évaluer un objet non référencé ",objet
94 def __init__(self,objet):
96 self.nom = objet.__name__
98 def isvalid(self,cr='non'):
101 def get_valeur_attribut(self,nom_attr):
102 if nom_attr == 'nom':return self.nom
108 def __init__(self,objet,pere,nom):
113 self.state='undetermined'
114 self.entites_fils = []
115 self.entites_attributs = {}
116 self.build_entites_attributs()
117 self.build_entites_fils()
121 s=self.__class__.__name__+' : '+self.nom
124 def build_entites_attributs(self):
125 for attribut in self.attributs:
126 if hasattr(self.objet,attribut):
127 self.entites_attributs[attribut]=ATTR_CATA(attribut,getattr(self.objet,attribut))
129 if self.attributs_defauts.has_key(attribut):
130 self.entites_attributs[attribut]=ATTR_CATA(attribut,self.attributs_defauts[attribut])
132 self.entites_attributs[attribut]=ATTR_CATA(attribut,None)
134 def build_entites_fils(self):
135 for k,v in self.objet.entites.items():
136 self.entites_fils.append(make_mc_cata(v,self,nom=k))
138 def get_valeur_attribut(self,nom_attr):
139 if nom_attr in self.entites_attributs.keys():
140 return self.entites_attributs[nom_attr].valeur
141 elif nom_attr in self.attributs_defauts.keys():
142 return self.attributs_defauts[nom_attr]
143 elif nom_attr == 'domaine_validité':
144 if self.entites_attributs['into'].valeur != None :
149 def isvalid(self,cr='non'):
150 if self.state =='unchanged':
154 if hasattr(self,'valid'):
155 old_valid = self.valid
158 # on teste self lui-meme
159 if self.nom == '' or self.nom == None : valid=0
160 # on teste les attributs
161 for attribut in self.entites_attributs.values():
162 if not attribut.isvalid() : valid =0
165 for fils in self.entites_fils:
166 if not fils.isvalid(): valid = 0
169 self.state = 'unchanged'
171 if old_valid != self.valid : self.init_modif_up()
174 def init_modif_up(self):
175 self.pere.state='modified'
179 self.cr.debut="Debut "+self.__class__.__name__+' : '+self.nom
180 self.cr.fin = "Fin "+self.__class__.__name__+' : '+self.nom
181 self.isvalid(cr='oui')
182 for attribut in self.entites_attributs.values():
183 self.cr.add(attribut.report())
184 for fils in self.entites_fils :
185 self.cr.add(fils.report())
188 def set_valeur_attribut(self,nom_attr,valeur):
190 Affecte la valeur 'valeur' à l'attribut de nom 'nom-attr'
192 # il faudra être prudent sur les changements de nom : interdire de changer
193 # le nom d'un mot-clé qui serait utilisé dans une règle ???
194 self.entites_attributs[nom_attr].valeur = valeur
196 def addentite(self,name,pos):
198 Permet d'ajouter un nouveau fils a self
201 if name == 'new_simp':
202 objet = Accas.SIMP(typ=('bidon',))
203 objet_cata = make_mc_cata(objet,self)
204 self.entites_fils.insert(pos,objet_cata)
207 def init_modif(self):
208 self.state = 'modified'
209 if hasattr(self,'pere'):
210 self.pere.init_modif()
212 def verif_nom(self,cr='non'):
214 Méthode appelée par EFICAS et ACCAS
215 Booléenne : retourne 1 si l'attribut nom est valide, 0 sinon
217 if self.entites_attributs['nom'].valeur == '':
218 if cr == 'oui' : self.cr.fatal("L'objet de type %s n'est pas nommé" %self.__class__.__name__)
222 def verif_defaut(self,cr='non'):
224 Méthode de vérification de validité du défaut
226 defaut = self.get_valeur_attribut('defaut')
227 if self.get_valeur_attribut('domaine_validite') == 'discret' :
228 if defaut not in self.get_valeur_attribut('into'):
229 if cr == 'oui' : self.cr.fatal("La valeur %s n'est pas autorisée" %str(defaut))
233 if defaut == None : return 1
234 typ = self.get_valeur_attribut('type')
237 if type(defaut) == types.StringType : return 1
238 val_min = self.get_valeur_attribut('val_min')
239 val_max = self.get_valeur_attribut('val_max')
240 # on attend un reel ?
242 if type(defaut) == types.StringType:
244 nb = string.atof(defaut)
251 if val_min != '**' : test = (nb >= val_min)
252 if val_max != '**' : test = test*(nb <= val_max)
254 # on attend un entier ?
256 if type(defaut)==types.StringType:
258 nb = string.atoi(defaut)
265 if val_min != '**' : test = (nb >= val_min)
266 if val_max != '**' : test = test*(nb <= val_max)
268 # si on passe par là, c'est que l'on n'a pas su évaluer defaut
269 if cr == 'oui' : self.cr.fatal("La valeur %s n'est pas une valeur permise" %str(defaut))
272 def verif_val_min(self,cr='non'):
274 Méthode de vérification de val_min.
275 Booléenne : retourne 1 si val_min est valide, 0 sinon
277 val_min = self.get_valeur_attribut('val_min')
279 if cr == 'oui' : self.cr.fatal('val_min ne peut valoir None')
281 if val_min == '**': return 1
282 # val_min doit à ce stade être :
283 # - soit un entier ou un réel
284 # - soit une chaîne de caractères représentant un entier ou un réel (provient d'EFICAS)
285 if type(val_min) == types.StringType :
287 val_min = string.atoi(val_min)
290 val_min = string.atof(val_min)
292 if cr == 'oui' : self.cr.fatal("%s n'est ni un entier ni un réel" %str(val_min))
294 # A ce stade, val_min doit être un entier ou un réel : on vérifie ...
295 if type(val_min) not in (types.IntType,types.FloatType) :
296 if cr == 'oui' : self.cr.fatal("%s n'est pas d'un type autorisé" %str(val_min))
298 # A ce stade valeur est un entier ou un réel : on peut comparer à val_max
299 val_max = self.get_valeur_attribut('val_max')
300 if val_max == '**' or val_min < val_max : return 1
301 # erreur : val_min est supérieur à val_max !!!
302 if cr == 'oui' : self.cr.fatal("%s n'est pas inférieur à %s" %(str(val_min),str(val_max)))
305 def verif_val_max(self,cr='non'):
307 Méthode de vérification de val_max.
308 Booléenne : retourne 1 si val_max est valide, 0 sinon
310 val_max = self.get_valeur_attribut('val_max')
312 if cr == 'oui' : self.cr.fatal('val_max ne peut valoir None')
314 if val_max == '**': return 1
315 # val_max doit à ce stade être :
316 # - soit un entier ou un réel
317 # - soit une chaîne de caractères représentant un entier ou un réel (provient d'EFICAS)
318 if type(val_max) == types.StringType :
320 val_max = string.atoi(val_max)
323 val_max = string.atof(val_max)
325 if cr == 'oui' : self.cr.fatal("%s n'est ni un entier ni un réel" %str(val_max))
327 # A ce stade, val_max doit être un entier ou un réel : on vérifie ...
328 if type(val_max) not in (types.IntType,types.FloatType) :
329 if cr == 'oui' : self.cr.fatal("%s n'est pas d'un type autorisé" %str(val_max))
331 # A ce stade valeur est un entier ou un réel : on peut comparer à val_max
332 val_min = self.get_valeur_attribut('val_min')
333 if val_min == '**' or val_min < val_max : return 1
334 # erreur : val_min est supérieur à val_max !!!
335 if cr == 'oui' : self.cr.fatal("%s n'est pas supérieur à %s" %(str(val_max),str(val_min)))
338 class OPER_CATA(OBJET_CATA):
339 attributs = ['ang','docu','fr','niveau','nom','op','op_init','reentrant','regles','repetable','sd_prod']
341 class PROC_CATA(OBJET_CATA):
342 attributs = ['ang','docu','fr','niveau','nom','op','op_init','regles','repetable']
344 class MACRO_CATA(OBJET_CATA):
345 attributs = ['ang','docu','fr','niveau','nom','op','op_init','reentrant','regles','repetable','sd_prod']
347 class BLOC_CATA(OBJET_CATA):
348 attributs = ['ang','condition','docu','fr','nom','regles']
350 class FACT_CATA(OBJET_CATA):
351 attributs=['ang','defaut','docu','fr','max','min','nom','regles','statut']
353 class SIMP_CATA(OBJET_CATA):
354 attributs=['ang','defaut','docu','fr','homo','into','max','min','nom','position','statut','type','val_min','val_max']
355 attributs_defauts={'ang':'','defaut':None,'fr':'','homo':1,'into':None,'max':1,'min':1,'nom' : '','position':'local',
356 'regles':None,'statut':'f','type':None,'val_min':'**','val_max':'**','docu':''}
358 def build_entites_fils(self):
361 def isvalid(self,cr='non'):
363 Mde appelpar l'externe (EFICAS et ACCAS).
364 Boolne : retourne 1 si l'objet est valide, 0 sinon
366 if self.state == 'unchanged':
370 valid = valid*self.verif_nom(cr=cr)
371 valid = valid*self.verif_defaut(cr=cr)
372 valid = valid*self.verif_val_min(cr=cr)*self.verif_val_max(cr=cr)
373 if hasattr(self,'valid'):
374 old_valid = self.valid
378 self.state='unchanged'
380 if old_valid != self.valid : self.init_modif_up()
383 class NIVEAU_CATA(OBJET_CATA):
384 def __init__(self,objet,pere,nom):
387 self.state = 'undetermined'
391 self.entites_attributs = {}
393 def register(self,fils):
395 Enregistre la commande 굡pe :
396 - si editmode = 0 : on est en mode relecture d'un fichier de commandes
397 auquel cas on ajoute etape a fin de la liste self.etapes
398 - si editmode = 1 : on est en mode ajout d'굡pe depuis eficas auquel cas
399 cette mode ne fait rien, c'est addentité enregistre etape ࡬a bonne place
402 self.entites_fils.append(fils)
404 def unregister(self,etape):
405 self.entites_fils.remove(etape)
407 def isvalid(self,cr='non'):
408 """ Mode boolne qui retourne 0 si le niveau est invalide, 1 sinon """
409 if self.state == 'unchanged':
413 if len(self.entites_fils) == 0:
414 #valid = self.Accas.valide_vide
417 for commande in self.entites_fils :
418 if hasattr(commande,'isvalid'):
419 if not commande.isvalid() :
423 print str(commande)," n'a pas de methode isvalid"
424 if hasattr(self,'valid'):
425 old_valid = self.valid
429 self.state='unchanged'
431 if old_valid != self.valid : self.init_modif_up()
435 class ATTR_CATA(OBJET_CATA):
436 def __init__(self,nom,valeur=None):
440 self.state='undetermined'
441 self.entites_attributs={}
444 def isvalid(self,cr='non'):
448 return isinstance(cmd,Accas.OPER) or isinstance(cmd,Accas.PROC) or isinstance(cmd,Accas.MACRO) or isinstance(cmd,Accas.FORM)