Validation/V_MACRO_ETAPE.py

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