generator/generator_aplat.py

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