generator/generator_aplat.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2021   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,appliEficas=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