generator/generator_aplat.py

   1 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   2 # ======================================================================
   3 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   4 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   5 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   6 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   7 # (AT YOUR OPTION) ANY LATER VERSION.
   8 #
   9 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  10 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  11 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  12 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  13 #
  14 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  15 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  16 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  17 #
  18 #
  19 # ======================================================================
  20 """
  21     Ce module contient le plugin generateur de fichier au format
  22     aplat pour EFICAS.
  23
  24 """
  25 import traceback
  26 import types,string,re
  27
  28 from Noyau import N_CR
  29 from Noyau.N_utils import repr_float
  30 from Accas import ETAPE,PROC_ETAPE,MACRO_ETAPE,ETAPE_NIVEAU,JDC,FORM_ETAPE
  31 from Accas import MCSIMP,MCFACT,MCBLOC,MCList,EVAL
  32 from Accas import GEOM,ASSD,MCNUPLET
  33 from Accas import COMMENTAIRE,PARAMETRE, PARAMETRE_EVAL,COMMANDE_COMM
  34
  35 def entryPoint():
  36    """
  37        Retourne les informations nécessaires pour le chargeur de plugins
  38
  39        Ces informations sont retournées dans un dictionnaire
  40    """
  41    return {
  42         # Le nom du plugin
  43           'name' : 'aplat',
  44         # La factory pour créer une instance du plugin
  45           'factory' : AplatGenerator,
  46           }
  47
  48
  49 class AplatGenerator:
  50    """
  51        Ce generateur parcourt un objet de type JDC et produit
  52        un fichier au format aplat
  53
  54        L'acquisition et le parcours sont réalisés par la méthode
  55        generator.gener(objet_jdc,format)
  56
  57        L'écriture du fichier au format ini par appel de la méthode
  58        generator.writefile(nom_fichier)
  59
  60        Ses caractéristiques principales sont exposées dans des attributs
  61        de classe :
  62          - extensions : qui donne une liste d'extensions de fichier préconisées
  63
  64    """
  65    # Les extensions de fichier préconisées
  66    extensions=('.*',)
  67
  68    def __init__(self,cr=None):
  69       # Si l'objet compte-rendu n'est pas fourni, on utilise le compte-rendu standard
  70       if cr :
  71          self.cr=cr
  72       else:
  73          self.cr=N_CR.CR(debut='CR generateur format aplat pour eficas',
  74                          fin='fin CR format aplat pour eficas')
  75       self.init=''
  76       # Le séparateur utiisé
  77       self.sep='//'
  78       # Le texte au format aplat est stocké dans l'attribut text
  79       self.text=''
  80
  81    def writefile(self,filename):
  82       fp=open(filename,'w')
  83       fp.write(self.text)
  84       fp.close()
  85
  86    def gener(self,obj,format='brut'):
  87       """
  88           Retourne une représentation du JDC obj sous une forme qui est paramétrée par format.
  89           Si format vaut 'brut', 'standard' ou 'beautifie', retourne le texte issu de generator
  90       """
  91       liste= self.generator(obj)
  92       if format == 'brut':
  93          self.text=liste
  94       elif format == 'standard':
  95          self.text=liste
  96       elif format == 'beautifie':
  97          self.text=liste
  98       else:
  99          raise "Format pas implémenté : "+format
 100       return self.text
 101
 102    def generator(self,obj):
 103       """
 104          Cette methode joue un role d'aiguillage en fonction du type de obj
 105          On pourrait utiliser les méthodes accept et visitxxx à la
 106          place (dépend des gouts !!!)
 107       """
 108       # ATTENTION a l'ordre des tests : il peut avoir de l'importance (héritage)
 109       if isinstance(obj,PROC_ETAPE):
 110          return self.generPROC_ETAPE(obj)
 111       elif isinstance(obj,MACRO_ETAPE):
 112          return self.generMACRO_ETAPE(obj)
 113       elif isinstance(obj,FORM_ETAPE):
 114          return self.generFORM_ETAPE(obj)
 115       elif isinstance(obj,ETAPE):
 116          return self.generETAPE(obj)
 117       elif isinstance(obj,MCFACT):
 118          return self.generMCFACT(obj)
 119       elif isinstance(obj,MCList):
 120          return self.generMCList(obj)
 121       elif isinstance(obj,MCBLOC):
 122          return self.generMCBLOC(obj)
 123       elif isinstance(obj,MCSIMP):
 124          return self.generMCSIMP(obj)
 125       elif isinstance(obj,ASSD):
 126          return self.generASSD(obj)
 127       elif isinstance(obj,ETAPE_NIVEAU):
 128          return self.generETAPE_NIVEAU(obj)
 129       elif isinstance(obj,COMMENTAIRE):
 130          return self.generCOMMENTAIRE(obj)
 131       # Attention doit etre placé avant PARAMETRE (raison : héritage)
 132       elif isinstance(obj,PARAMETRE_EVAL):
 133          return self.generPARAMETRE_EVAL(obj)
 134       elif isinstance(obj,PARAMETRE):
 135          return self.generPARAMETRE(obj)
 136       elif isinstance(obj,EVAL):
 137          return self.generEVAL(obj)
 138       elif isinstance(obj,COMMANDE_COMM):
 139          return self.generCOMMANDE_COMM(obj)
 140       elif isinstance(obj,JDC):
 141          return self.generJDC(obj)
 142       elif isinstance(obj,MCNUPLET):
 143          return self.generMCNUPLET(obj)
 144       else:
 145          raise "Type d'objet non prévu",obj
 146
 147    def generJDC(self,obj):
 148       """
 149          Cette méthode convertit un objet JDC en une chaine de
 150          caractères à la syntaxe aplat
 151       """
 152       text=''
 153       if obj.definition.l_niveaux == ():
 154          # Il n'y a pas de niveaux
 155          for etape in obj.etapes:
 156             text=text+self.generator(etape)+'\n'
 157       else:
 158          # Il y a des niveaux
 159          for etape_niveau in obj.etapes_niveaux:
 160             text=text+self.generator(etape_niveau)+'\n'
 161       return text
 162
 163    def generCOMMANDE_COMM(self,obj):
 164       """
 165          Cette méthode convertit un COMMANDE_COMM
 166          en une chaine de caractères à la syntaxe aplat
 167       """
 168       l_lignes = string.split(obj.valeur,'\n')
 169       txt=''
 170       for ligne in l_lignes:
 171           txt = txt + '##'+ligne+'\n'
 172       return txt
 173
 174    def generEVAL(self,obj):
 175       """
 176          Cette méthode convertit un EVAL
 177          en une chaine de caractères à la syntaxe aplat
 178       """
 179       return 'EVAL("""'+ obj.valeur +'""")'
 180
 181    def generCOMMENTAIRE(self,obj):
 182       """
 183          Cette méthode convertit un COMMENTAIRE
 184          en une chaine de caractères à la syntaxe aplat
 185       """
 186       l_lignes = string.split(obj.valeur,'\n')
 187       txt=''
 188       for ligne in l_lignes:
 189         txt = txt + '#'+ligne+'\n'
 190       return txt
 191
 192    def generPARAMETRE_EVAL(self,obj):
 193       """
 194          Cette méthode convertit un PARAMETRE_EVAL
 195          en une chaine de caractères à la syntaxe aplat
 196       """
 197       if obj.valeur == None:
 198          return obj.nom + ' = None ;\n'
 199       else:
 200          return obj.nom + ' = '+ self.generator(obj.valeur) +';\n'
 201
 202    def generPARAMETRE(self,obj):
 203       """
 204          Cette méthode convertit un PARAMETRE
 205          en une chaine de caractères à la syntaxe aplat
 206       """
 207       if type(obj.valeur) == types.StringType:
 208         return obj.nom + " = '" + obj.valeur + "';\n"
 209       else:
 210         return obj.nom + ' = ' + str(obj.valeur) + ';\n'
 211
 212    def generETAPE_NIVEAU(self,obj):
 213       """
 214          Cette méthode convertit une étape niveau
 215          en une chaine de caractères à la syntaxe aplat
 216       """
 217       text=''
 218       if obj.etapes_niveaux == []:
 219         for etape in obj.etapes:
 220           text=text+self.generator(etape)+'\n'
 221       else:
 222         for etape_niveau in obj.etapes_niveaux:
 223           text=text+self.generator(etape_niveau)+'\n'
 224       return text
 225
 226    def gener_etape(self,obj):
 227       """
 228          Cette méthode est utilisé pour convertir les objets etape
 229          en une chaine de caractères à la syntaxe aplat
 230       """
 231       text=''
 232       for v in obj.mc_liste:
 233          text=text + self.generator(v)
 234       if text=='':
 235          return self.init+'\n'
 236       else:
 237          return text
 238
 239    def generETAPE(self,obj):
 240       """
 241          Cette méthode convertit une étape
 242          en une chaine de caractères à la syntaxe aplat
 243       """
 244       try:
 245         sdname= self.generator(obj.sd)
 246       except:
 247         sdname='sansnom'
 248       self.init = sdname + self.sep + obj.nom
 249       return self.gener_etape(obj)
 250
 251    def generMACRO_ETAPE(self,obj):
 252       """
 253          Cette méthode convertit une macro-étape
 254          en une chaine de caractères à la syntaxe aplat
 255       """
 256       try:
 257         if obj.sd == None:
 258           self.init = obj.nom
 259         else:
 260           sdname= self.generator(obj.sd)
 261           self.init = sdname + self.sep + obj.nom
 262       except:
 263         self.init = 'sansnom' + self.sep + obj.nom
 264
 265       return self.gener_etape(obj)
 266
 267    generPROC_ETAPE = generMACRO_ETAPE
 268
 269    generFORM_ETAPE = generMACRO_ETAPE
 270
 271    def generASSD(self,obj):
 272       """
 273           Convertit un objet dérivé d'ASSD en une chaine de caractères à la
 274           syntaxe aplat
 275       """
 276       return obj.get_name()
 277
 278    def generMCList(self,obj):
 279       """
 280           Convertit un objet MCList en une chaine de caractères à la
 281           syntaxe aplat
 282       """
 283       i=0
 284       text = ''
 285       init = self.init + self.sep + obj.nom
 286       old_init=self.init
 287       for data in obj.data :
 288         i=i+1
 289         self.init = init + self.sep + "occurrence n°"+`i`
 290         text = text + self.generator(data)
 291       self.init=old_init
 292       return text
 293
 294    def generMCSIMP(self,obj) :
 295       """
 296           Convertit un objet MCSIMP en une chaine de caractères à la
 297           syntaxe aplat
 298       """
 299       if type(obj.valeur) in (types.TupleType,types.ListType) :
 300          # On est en présence d'une liste de valeur
 301          rep = '('
 302          for val in obj.valeur:
 303            if type(val) == types.InstanceType :
 304              rep = rep + self.generator(val) +','
 305            else:
 306              rep = rep + `val`+','
 307          rep = rep + ')'
 308       elif type(obj.valeur) == types.InstanceType :
 309          # On est en présence d'une valeur unique de type instance
 310          rep = self.generator(obj.valeur)
 311       else :
 312          # On est en présence d'une valeur unique
 313          rep = `obj.valeur`
 314       return self.init + self.sep + obj.nom + ' :' + rep + '\n'
 315
 316    def generMCCOMPO(self,obj):
 317       """
 318           Convertit un objet MCCOMPO en une chaine de caractères à la
 319           syntaxe aplat
 320       """
 321       text = ''
 322       old_init=self.init
 323       self.init = self.init + self.sep + obj.nom
 324       for mocle in obj.mc_liste :
 325         text = text + self.generator(mocle)
 326       self.init=old_init
 327       return text
 328
 329    generMCFACT=generMCCOMPO
 330
 331    generMCBLOC=generMCCOMPO
 332
 333    generMCNUPLET=generMCCOMPO
 334
 335