]> SALOME platform Git repositories - tools/eficas.git/blob - Validation/V_MACRO_ETAPE.py
Salome HOME
Version Aster 6.3.14
[tools/eficas.git] / Validation / V_MACRO_ETAPE.py
1 #@ MODIF V_MACRO_ETAPE Validation  DATE 26/06/2002   AUTEUR DURAND C.DURAND 
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.                                 
9 #
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.                            
14 #
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.      
18 #                                                                       
19 #                                                                       
20 # ======================================================================
21 """
22    Ce module contient la classe mixin MACRO_ETAPE qui porte les méthodes
23    nécessaires pour réaliser la validation d'un objet de type MACRO_ETAPE
24    dérivé de OBJECT.
25
26    Une classe mixin porte principalement des traitements et est
27    utilisée par héritage multiple pour composer les traitements.
28 """
29 # Modules Python
30 import string,types,sys
31 import traceback
32
33 # Modules EFICAS
34 import V_MCCOMPO
35 import V_ETAPE
36 from Noyau.N_Exception import AsException
37 from Noyau.N_utils import AsType
38
39 class MACRO_ETAPE(V_ETAPE.ETAPE):
40    """
41    """
42
43    def isvalid(self,sd='oui',cr='non'):
44       """ 
45          Methode pour verifier la validité de l'objet ETAPE. Cette méthode
46          peut etre appelée selon plusieurs modes en fonction de la valeur
47          de sd et de cr.
48
49          Si cr vaut oui elle crée en plus un compte-rendu.
50
51          Cette méthode a plusieurs fonctions :
52
53           - mettre à jour l'état de self (update)
54
55           - retourner un indicateur de validité 0=non, 1=oui
56
57           - produire un compte-rendu : self.cr
58
59       """
60       if CONTEXT.debug : print "ETAPE.isvalid ",self.nom
61       if self.state == 'unchanged' :
62         return self.valid
63       else:
64         valid = 1
65         if hasattr(self,'valid'):
66           old_valid = self.valid
67         else:
68           old_valid = None
69         # on teste, si elle existe, le nom de la sd (sa longueur doit etre <= 8 caractères)
70         if self.sd != None :
71           # la SD existe déjà : on regarde son nom
72           if self.sd.get_name() != None :
73             if len(self.sd.nom) > 8 :
74               if cr == 'oui' :
75                 self.cr.fatal("Le nom de concept %s est trop long (8 caractères maxi)" %self.sd.nom)
76               valid = 0
77           if string.find(self.sd.nom,'sansnom') != -1 :
78               # la SD est 'sansnom' : --> erreur
79               if cr == 'oui' :
80                 self.cr.fatal("Pas de nom pour le concept retourné")
81               valid = 0
82           elif string.find(self.sd.nom,'SD_') != -1 :
83               # la SD est 'SD_' cad son nom = son id donc pas de nom donné par utilisateur : --> erreur
84               if cr == 'oui' :
85                 self.cr.fatal("Pas de nom pour le concept retourné")
86               valid = 0
87         # on teste les enfants
88         for child in self.mc_liste :
89           if not child.isvalid():
90             valid = 0
91             break
92         # on teste les règles de self
93         text_erreurs,test_regles = self.verif_regles()
94         if not test_regles :
95           if cr == 'oui' : self.cr.fatal(string.join(("Règle(s) non respectée(s) :", text_erreurs)))
96           valid = 0
97         if self.reste_val != {}:
98           if cr == 'oui' :
99             self.cr.fatal("Mots cles inconnus :" + string.join(self.reste_val.keys(),','))
100           valid=0
101         if sd == 'oui' and valid:
102           valid = self.update_sdprod(cr)
103         # Si la macro comprend des etapes internes, on teste leur validite
104         for e in self.etapes:
105           if not e.isvalid():
106             valid=0
107             break
108         self.valid = valid
109         self.state = 'unchanged'
110         if old_valid:
111           if old_valid != self.valid : self.init_modif_up()
112         return self.valid
113
114    def update_sdprod(self,cr='non'):
115       """ 
116            Cette méthode met à jour le concept produit en fonction des conditions initiales :
117
118             1- Il n'y a pas de concept retourné (self.definition.sd_prod == None)
119
120             2- Le concept retourné n existait pas (self.sd == None)
121
122             3- Le concept retourné existait. On change alors son type ou on le supprime
123
124            En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
125       """
126       sd_prod=self.definition.sd_prod
127       # On memorise le type retourné dans l attribut typret
128       self.typret=None 
129       if type(sd_prod) == types.FunctionType: 
130         # Type de concept retourné calculé
131         d=self.cree_dict_valeurs(self.mc_liste)
132         try:
133           # la sd_prod d'une macro a l'objet lui meme en premier argument
134           # contrairement à une ETAPE ou PROC_ETAPE
135           # Comme sd_prod peut invoquer la méthode type_sdprod qui ajoute
136           # les concepts produits dans self.sdprods, il faut le mettre à zéro
137           self.sdprods=[]
138           sd_prod= apply(sd_prod,(self,),d)
139         except:
140           # Erreur pendant le calcul du type retourné
141           if CONTEXT.debug:traceback.print_exc()
142           self.sd=None
143           if cr == 'oui' : 
144              l=traceback.format_exception(sys.exc_info()[0],
145                                            sys.exc_info()[1],
146                                            sys.exc_info()[2])
147              self.cr.fatal('Impossible d affecter un type au résultat\n'+string.join(l[2:]))
148           return 0
149       # on teste maintenant si la SD est r\351utilis\351e ou s'il faut la cr\351er
150       valid=1
151       if self.reuse:
152         # Un concept reutilise a ete specifie
153         if AsType(self.reuse) != sd_prod:
154           if cr == 'oui' : self.cr.fatal('Type de concept reutilise incompatible avec type produit')
155           valid=0
156         if self.sdnom[0] != '_' and self.reuse.nom != self.sdnom:
157           # Le nom de la variable de retour (self.sdnom) doit etre le meme que celui du concept reutilise (self.reuse.nom)
158           if cr == 'oui' :
159              self.cr.fatal('Concept reutilise : le nom de la variable de retour devrait etre %s et non %s' %(self.reuse.nom,self.sdnom))
160           valid= 0
161         if valid:self.sd=self.reuse
162       else:
163         if sd_prod == None:# Pas de concept retourné
164           # Que faut il faire de l eventuel ancien sd ?
165           self.sd = None
166         else:
167           if self.sd: 
168             # Un sd existe deja, on change son type
169             self.sd.__class__=sd_prod
170             self.typret=sd_prod
171           else: 
172             # Le sd n existait pas , on ne le crée pas
173             self.typret=sd_prod
174             if cr == 'oui' : self.cr.fatal("Concept retourné non défini")
175             valid=0 
176         if self.definition.reentrant == 'o':
177            if cr == 'oui' : self.cr.fatal('Commande obligatoirement reentrante : specifier reuse=concept')
178            valid=0
179            #self.reuse = self.sd
180       return valid
181
182    def report(self):
183       """ 
184           Methode pour la generation d un rapport de validation
185       """
186       V_ETAPE.ETAPE.report(self)
187       for e in self.etapes :
188         self.cr.add(e.report())
189       return self.cr
190