Noyau/N_PROC_ETAPE.py

   1 # -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2013   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21
  22 """
  23     Ce module contient la classe PROC_ETAPE qui sert à vérifier et à exécuter
  24     une procédure
  25 """
  26
  27 # Modules Python
  28 import types,sys,string
  29 import traceback
  30
  31 # Modules EFICAS
  32 import N_MCCOMPO, N_ETAPE
  33 from N_Exception import AsException
  34 import N_utils
  35
  36 class PROC_ETAPE(N_ETAPE.ETAPE):
  37    """
  38       Cette classe hérite de ETAPE. La seule différence porte sur le fait
  39       qu'une procédure n'a pas de concept produit
  40
  41    """
  42    nature = "PROCEDURE"
  43    def __init__(self, oper=None, reuse=None, args={}):
  44       """
  45       Attributs :
  46        - definition : objet portant les attributs de définition d'une étape de type opérateur. Il
  47                       est initialisé par l'argument oper.
  48        - valeur : arguments d'entrée de type mot-clé=valeur. Initialisé avec l'argument args.
  49        - reuse : forcément None pour une PROC
  50       """
  51       N_ETAPE.ETAPE.__init__(self, oper, reuse=None, args=args, niveau=5)
  52       self.reuse = None
  53
  54    def Build_sd(self):
  55       """
  56           Cette methode applique la fonction op_init au contexte du parent
  57           et lance l'exécution en cas de traitement commande par commande
  58           Elle doit retourner le concept produit qui pour une PROC est toujours None
  59           En cas d'erreur, elle leve une exception : AsException ou EOFError
  60       """
  61       if not self.isactif():return
  62       try:
  63          if self.parent:
  64             if type(self.definition.op_init) == types.FunctionType:
  65                apply(self.definition.op_init,(self,self.parent.g_context))
  66          else:
  67             pass
  68       except AsException,e:
  69         raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
  70                               'fichier : ',self.appel[1],e)
  71       except EOFError:
  72         raise
  73       except :
  74         l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2])
  75         raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
  76                           'fichier : ',self.appel[1]+'\n',
  77                           string.join(l))
  78
  79       self.Execute()
  80       return None
  81
  82    def supprime(self):
  83       """
  84          Méthode qui supprime toutes les références arrières afin que l'objet puisse
  85          etre correctement détruit par le garbage collector
  86       """
  87       N_MCCOMPO.MCCOMPO.supprime(self)
  88       self.jdc=None
  89       self.appel=None
  90
  91    def accept(self,visitor):
  92       """
  93          Cette methode permet de parcourir l'arborescence des objets
  94          en utilisant le pattern VISITEUR
  95       """
  96       visitor.visitPROC_ETAPE(self)
  97
  98    def update_context(self,d):
  99       """
 100          Met à jour le contexte de l'appelant passé en argument (d)
 101          Une PROC_ETAPE n ajoute pas directement de concept dans le contexte
 102          Seule une fonction enregistree dans op_init pourrait le faire
 103       """
 104       if type(self.definition.op_init) == types.FunctionType:
 105         apply(self.definition.op_init,(self,d))
 106
 107
 108