Noyau/N_MACRO.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 de definition MACRO
  24     qui permet de spécifier les caractéristiques d'une macro-commande
  25 """
  26
  27 import types,string,traceback
  28
  29 import N_ENTITE
  30 import N_MACRO_ETAPE
  31 import nommage
  32 from strfunc import ufmt
  33
  34 class MACRO(N_ENTITE.ENTITE):
  35    """
  36     Classe pour definir une macro-commande
  37
  38     Cette classe a trois attributs de classe
  39
  40     - class_instance qui indique la classe qui devra etre utilisée
  41             pour créer l'objet qui servira à controler la conformité d'un
  42             macro-commande avec sa définition
  43
  44     - label qui indique la nature de l'objet de définition (ici, MACRO)
  45
  46     - nommage qui est un module Python qui fournit la fonctionnalité de nommage
  47
  48     et les attributs d'instance suivants :
  49
  50     - nom   : son nom
  51
  52     - op   : le numéro d'opérateur
  53
  54     - sd_prod : le type de concept produit. C'est une classe ou une fonction qui retourne
  55                       une classe
  56
  57     - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur
  58                         réentrant peut modifier un concept d'entrée et le produire comme concept de sortie
  59
  60     - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur
  61                         non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort
  62                         de l'objet gérant le contexte d'exécution de vérifier cette contrainte.
  63
  64     - fr   : commentaire associé en francais
  65
  66     - ang : commentaire associé en anglais
  67
  68     - docu : clé de documentation associée
  69
  70     - regles : liste des règles associées
  71
  72     - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette
  73                       fonction est exécutée lors des phases d'initialisation de l'étape associée.
  74
  75     - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre
  76                      rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement.
  77                      Si niveau vaut None, l'opérateur est rangé au niveau global.
  78
  79     - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit
  80                       des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut
  81                       est initialisé avec args, c'est à dire les arguments d'appel restants.
  82
  83
  84    """
  85    class_instance = N_MACRO_ETAPE.MACRO_ETAPE
  86    label = 'MACRO'
  87    nommage = nommage
  88
  89    def __init__(self,nom,op,sd_prod=None,reentrant='n',repetable='o',fr="",ang="",
  90                 docu="",regles=(),op_init=None,niveau = None,fichier_ini=0,UIinfo=None,**args):
  91       """
  92          Méthode d'initialisation de l'objet MACRO. Les arguments sont utilisés pour initialiser
  93          les attributs de meme nom
  94       """
  95       # XXX fichier_ini n'est pas utilisé pour l'instant
  96       self.nom=nom
  97       # op est obligatoire et permet de spécifier la procédure de construction de la macro
  98       # - Si op est un entier la construction de la macro est réalisée par une subroutine fortran opsxxx ou
  99       # xxx est donné par la valeur absolue de op. L'execution est egalement effectuée via cette subroutine.
 100       # - Si op est une fonction Python, la construction de la macro est effectuée par l'appel à cette fonction
 101       # Suivant le cas on garde l info dans self.op ou dans self.proc
 102       if type(op) == types.IntType:
 103         self.proc=None
 104         self.op=op
 105       else:
 106         self.op=None
 107         self.proc=op
 108
 109       self.sd_prod=sd_prod
 110       self.reentrant=reentrant
 111       self.fr=fr
 112       self.ang=ang
 113       self.repetable = repetable
 114       self.docu=docu
 115       if type(regles)== types.TupleType:
 116           self.regles=regles
 117       else:
 118           self.regles=(regles,)
 119       self.fichier_ini = fichier_ini
 120       # Attribut op_init : Fonction a appeler a la construction de l operateur sauf si == None
 121       self.op_init=op_init
 122       self.entites = args
 123       current_cata=CONTEXT.get_current_cata()
 124       if niveau == None:
 125          self.niveau=None
 126          current_cata.enregistre(self)
 127       else:
 128          self.niveau=current_cata.get_niveau(niveau)
 129          self.niveau.enregistre(self)
 130       self.UIinfo=UIinfo
 131       self.affecter_parente()
 132       self.check_definition(self.nom)
 133
 134    def __call__(self,reuse=None,**args):
 135       """
 136           Construit l'objet MACRO_ETAPE a partir de sa definition (self),
 137           puis demande la construction de ses sous-objets et du concept produit.
 138       """
 139       nomsd = self.nommage.GetNomConceptResultat(self.nom)
 140       etape = self.class_instance(oper=self,reuse=reuse,args=args)
 141       etape.McBuild()
 142       return etape.Build_sd(nomsd)
 143
 144    def make_objet(self,mc_list='oui'):
 145       """
 146            Cette méthode crée l'objet MACRO_ETAPE dont la définition est self sans
 147            créer sa sdprod.
 148            Normalement l'étape est enregistrée auprès de son parent.
 149            Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction
 150            des objets MCxxx.
 151       """
 152       etape= self.class_instance(oper=self,reuse=None,args={})
 153       if mc_list == 'oui':etape.McBuild()
 154       return etape
 155
 156    def verif_cata(self):
 157       """
 158           Méthode de vérification des attributs de définition
 159       """
 160       self.check_op(valmax=0)
 161       self.check_proc()
 162       self.check_regles()
 163       self.check_fr()
 164       self.check_docu()
 165       self.check_nom()
 166       self.check_reentrant()
 167       self.verif_cata_regles()
 168
 169    def supprime(self):
 170       """
 171           Méthode pour supprimer les références arrières susceptibles de provoquer
 172           des cycles de références
 173       """
 174       self.niveau=None
 175