Validation/V_MACRO_ETAPE.py

   1 #@ MODIF V_MACRO_ETAPE Validation  DATE 26/09/2003   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=self.valid_child()
  65         valid=valid * self.valid_regles(cr)
  66
  67         if self.reste_val != {}:
  68           if cr == 'oui' :
  69             self.cr.fatal("Mots cles inconnus :" + string.join(self.reste_val.keys(),','))
  70           valid=0
  71
  72         if sd == "non":
  73            # Dans ce cas, on ne calcule qu'une validite partielle, on ne modifie pas l'état de self
  74            # on retourne simplement l'indicateur valid
  75            return valid
  76
  77         if self.sd != None :
  78            valid = valid * self.valid_sdnom(cr)
  79
  80         if self.definition.reentrant == 'n' and self.reuse:
  81            # Il ne peut y avoir de concept reutilise avec une MACRO  non reentrante
  82            if cr == 'oui' : self.cr.fatal('Macro-commande non reentrante : ne pas utiliser reuse ')
  83            valid=0
  84
  85         if valid:
  86           valid = self.update_sdprod(cr)
  87
  88         # Si la macro comprend des etapes internes, on teste leur validite
  89         for e in self.etapes:
  90           if not e.isvalid():
  91             valid=0
  92             break
  93
  94         self.set_valid(valid)
  95
  96         return self.valid
  97
  98    def update_sdprod(self,cr='non'):
  99       """
 100            Cette méthode met à jour le concept produit en fonction des conditions initiales :
 101
 102             1- Il n'y a pas de concept retourné (self.definition.sd_prod == None)
 103
 104             2- Le concept retourné n existait pas (self.sd == None)
 105
 106             3- Le concept retourné existait. On change alors son type ou on le supprime
 107
 108            En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
 109       """
 110       sd_prod=self.definition.sd_prod
 111       # On memorise le type retourné dans l attribut typret
 112       self.typret=None
 113       if type(sd_prod) == types.FunctionType:
 114         # Type de concept retourné calculé
 115         d=self.cree_dict_valeurs(self.mc_liste)
 116         try:
 117           # la sd_prod d'une macro a l'objet lui meme en premier argument
 118           # contrairement à une ETAPE ou PROC_ETAPE
 119           # Comme sd_prod peut invoquer la méthode type_sdprod qui ajoute
 120           # les concepts produits dans self.sdprods, il faut le mettre à zéro
 121           self.sdprods=[]
 122           sd_prod= apply(sd_prod,(self,),d)
 123         except:
 124           # Erreur pendant le calcul du type retourné
 125           if CONTEXT.debug:traceback.print_exc()
 126           self.sd=None
 127           if cr == 'oui' :
 128              l=traceback.format_exception(sys.exc_info()[0],
 129                                            sys.exc_info()[1],
 130                                            sys.exc_info()[2])
 131              self.cr.fatal('Impossible d affecter un type au résultat\n'+string.join(l[2:]))
 132           return 0
 133       # on teste maintenant si la SD est r\351utilis\351e ou s'il faut la cr\351er
 134       valid=1
 135       if self.reuse:
 136         # Un concept reutilise a ete specifie
 137         if AsType(self.reuse) != sd_prod:
 138           if cr == 'oui' : self.cr.fatal('Type de concept reutilise incompatible avec type produit')
 139           valid=0
 140         if self.sdnom!='':
 141            if self.sdnom[0] != '_' and self.reuse.nom != self.sdnom:
 142              # Le nom de la variable de retour (self.sdnom) doit etre le meme que celui du concept reutilise (self.reuse.nom)
 143              if cr == 'oui' :
 144                 self.cr.fatal('Concept reutilise : le nom de la variable de retour devrait etre %s et non %s' %(self.reuse.nom,self.sdnom))
 145              valid= 0
 146         if valid:self.sd=self.reuse
 147       else:
 148         if sd_prod == None:# Pas de concept retourné
 149           # Que faut il faire de l eventuel ancien sd ?
 150           self.sd = None
 151         else:
 152           if self.sd:
 153             # Un sd existe deja, on change son type
 154             self.sd.__class__=sd_prod
 155             self.typret=sd_prod
 156           else:
 157             # Le sd n existait pas , on ne le crée pas
 158             self.typret=sd_prod
 159             if cr == 'oui' : self.cr.fatal("Concept retourné non défini")
 160             valid=0
 161         if self.definition.reentrant == 'o':
 162            if cr == 'oui' : self.cr.fatal('Commande obligatoirement reentrante : specifier reuse=concept')
 163            valid=0
 164       return valid
 165
 166    def report(self):
 167       """
 168           Methode pour la generation d un rapport de validation
 169       """
 170       V_ETAPE.ETAPE.report(self)
 171       for e in self.etapes :
 172         self.cr.add(e.report())
 173       return self.cr
 174