generator/generator_aplat.py

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