]> SALOME platform Git repositories - tools/eficas.git/blob - Validation/V_MACRO_ETAPE.py
Salome HOME
PN Pour les formules
[tools/eficas.git] / Validation / V_MACRO_ETAPE.py
1 #@ MODIF V_MACRO_ETAPE Validation  DATE 14/09/2004   AUTEUR MCOURTOI M.COURTOIS 
2 # -*- coding: iso-8859-1 -*-
3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
4 # ======================================================================
5 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
6 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
7 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
8 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
9 # (AT YOUR OPTION) ANY LATER VERSION.                                 
10 #
11 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
12 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
13 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
14 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
15 #
16 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
17 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
18 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
19 #                                                                       
20 #                                                                       
21 # ======================================================================
22
23
24 """
25    Ce module contient la classe mixin MACRO_ETAPE qui porte les méthodes
26    nécessaires pour réaliser la validation d'un objet de type MACRO_ETAPE
27    dérivé de OBJECT.
28
29    Une classe mixin porte principalement des traitements et est
30    utilisée par héritage multiple pour composer les traitements.
31 """
32 # Modules Python
33 import string,types,sys
34 import traceback
35
36 # Modules EFICAS
37 import V_MCCOMPO
38 import V_ETAPE
39 from Noyau.N_Exception import AsException
40 from Noyau.N_utils import AsType
41
42 class MACRO_ETAPE(V_ETAPE.ETAPE):
43    """
44    """
45
46    def isvalid(self,sd='oui',cr='non'):
47       """ 
48          Methode pour verifier la validité de l'objet ETAPE. Cette méthode
49          peut etre appelée selon plusieurs modes en fonction de la valeur
50          de sd et de cr.
51
52          Si cr vaut oui elle crée en plus un compte-rendu.
53
54          Cette méthode a plusieurs fonctions :
55
56           - mettre à jour l'état de self (update)
57
58           - retourner un indicateur de validité 0=non, 1=oui
59
60           - produire un compte-rendu : self.cr
61
62       """
63       if CONTEXT.debug : print "ETAPE.isvalid ",self.nom
64       if self.state == 'unchanged' :
65         return self.valid
66       else:
67         valid=self.valid_child()
68         valid=valid * self.valid_regles(cr)
69
70         if self.reste_val != {}:
71           if cr == 'oui' :
72             self.cr.fatal("Mots cles inconnus :" + string.join(self.reste_val.keys(),','))
73           valid=0
74
75         if sd == "non":
76            # Dans ce cas, on ne calcule qu'une validite partielle, on ne modifie pas l'état de self
77            # on retourne simplement l'indicateur valid
78            return valid
79
80         if self.sd != None :
81            valid = valid * self.valid_sdnom(cr)
82
83         if self.definition.reentrant == 'n' and self.reuse:
84            # Il ne peut y avoir de concept reutilise avec une MACRO  non reentrante
85            if cr == 'oui' : self.cr.fatal('Macro-commande non reentrante : ne pas utiliser reuse ')
86            valid=0
87
88         if valid:
89           valid = self.update_sdprod(cr)
90
91         # Si la macro comprend des etapes internes, on teste leur validite
92         for e in self.etapes:
93           if not e.isvalid():
94             valid=0
95             break
96
97         self.set_valid(valid)
98         return self.valid
99
100    def update_sdprod(self,cr='non'):
101       """ 
102            Cette méthode met à jour le concept produit en fonction des conditions initiales :
103
104             1- Il n'y a pas de concept retourné (self.definition.sd_prod == None)
105
106             2- Le concept retourné n existait pas (self.sd == None)
107
108             3- Le concept retourné existait. On change alors son type ou on le supprime
109
110            En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
111       """
112       sd_prod=self.definition.sd_prod
113       # On memorise le type retourné dans l attribut typret
114       self.typret=None 
115       if type(sd_prod) == types.FunctionType: 
116         # Type de concept retourné calculé
117         d=self.cree_dict_valeurs(self.mc_liste)
118         try:
119           # la sd_prod d'une macro a l'objet lui meme en premier argument
120           # contrairement à une ETAPE ou PROC_ETAPE
121           # Comme sd_prod peut invoquer la méthode type_sdprod qui ajoute
122           # les concepts produits dans self.sdprods, il faut le mettre à zéro
123           self.sdprods=[]
124           sd_prod= apply(sd_prod,(self,),d)
125         except:
126           # Erreur pendant le calcul du type retourné
127           if CONTEXT.debug:traceback.print_exc()
128           self.sd=None
129           if cr == 'oui' : 
130              l=traceback.format_exception(sys.exc_info()[0],
131                                            sys.exc_info()[1],
132                                            sys.exc_info()[2])
133              self.cr.fatal('Impossible d affecter un type au résultat\n'+string.join(l[2:]))
134           return 0
135       # on teste maintenant si la SD est r\351utilis\351e ou s'il faut la cr\351er
136       valid=1
137       if self.reuse:
138         # Un concept reutilise a ete specifie
139         if AsType(self.reuse) != sd_prod:
140           if cr == 'oui' : self.cr.fatal('Type de concept reutilise incompatible avec type produit')
141           valid=0
142         if self.sdnom!='':
143            if self.sdnom[0] != '_' and self.reuse.nom != self.sdnom:
144              # Le nom de la variable de retour (self.sdnom) doit etre le meme que celui du concept reutilise (self.reuse.nom)
145              if cr == 'oui' :
146                 self.cr.fatal('Concept reutilise : le nom de la variable de retour devrait etre %s et non %s' %(self.reuse.nom,self.sdnom))
147              valid= 0
148         if valid:self.sd=self.reuse
149       else:
150         if sd_prod == None:# Pas de concept retourné
151           # Que faut il faire de l eventuel ancien sd ?
152           self.sd = None
153         else:
154           if self.sd: 
155             # Un sd existe deja, on change son type
156             self.sd.__class__=sd_prod
157             self.typret=sd_prod
158           else: 
159             # Le sd n existait pas , on ne le crée pas
160             self.typret=sd_prod
161             if cr == 'oui' : self.cr.fatal("Concept retourné non défini")
162             valid=0 
163         if self.definition.reentrant == 'o':
164            if cr == 'oui' : self.cr.fatal('Commande obligatoirement reentrante : specifier reuse=concept')
165            valid=0
166       return valid
167
168    def report(self):
169       """ 
170           Methode pour la generation d un rapport de validation
171       """
172       V_ETAPE.ETAPE.report(self)
173       for e in self.etapes :
174         self.cr.add(e.report())
175       return self.cr
176