generator/generator_aplat.py

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