-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2017 EDF R&D
#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-# ======================================================================
"""
Ce module contient le plugin generateur de fichier au format
aplat pour EFICAS.
"""
+try :
+ from builtins import str
+ from builtins import object
+except : pass
+
import traceback
-import types,string,re
+import types,re
+from Extensions.i18n import tr
+from Extensions.eficas_exception import EficasException
from Noyau import N_CR
from Noyau.N_utils import repr_float
def entryPoint():
"""
- Retourne les informations nécessaires pour le chargeur de plugins
+ Retourne les informations necessaires pour le chargeur de plugins
- Ces informations sont retournées dans un dictionnaire
+ Ces informations sont retournees dans un dictionnaire
"""
return {
# Le nom du plugin
'name' : 'aplat',
- # La factory pour créer une instance du plugin
+ # La factory pour creer une instance du plugin
'factory' : AplatGenerator,
}
-class AplatGenerator:
+class AplatGenerator(object):
"""
Ce generateur parcourt un objet de type JDC et produit
un fichier au format aplat
- L'acquisition et le parcours sont réalisés par la méthode
+ L'acquisition et le parcours sont realises par la methode
generator.gener(objet_jdc,format)
- L'écriture du fichier au format ini par appel de la méthode
+ L'ecriture du fichier au format ini par appel de la methode
generator.writefile(nom_fichier)
- Ses caractéristiques principales sont exposées dans des attributs
+ Ses caracteristiques principales sont exposees dans des attributs
de classe :
-
- - extensions : qui donne une liste d'extensions de fichier préconisées
+ - extensions : qui donne une liste d'extensions de fichier preconisees
"""
- # Les extensions de fichier préconisées
+ # Les extensions de fichier preconisees
extensions=('.*',)
def __init__(self,cr=None):
self.cr=N_CR.CR(debut='CR generateur format aplat pour eficas',
fin='fin CR format aplat pour eficas')
self.init=''
- # Le séparateur utiisé
+ # Le separateur utiise
self.sep='//'
- # Le texte au format aplat est stocké dans l'attribut text
+ # Le texte au format aplat est stocke dans l'attribut text
self.text=''
def writefile(self,filename):
fp.write(self.text)
fp.close()
- def gener(self,obj,format='brut'):
+ def gener(self,obj,format='brut',config=None,appliEficas=None):
"""
- Retourne une représentation du JDC obj sous une
- forme qui est paramétrée par format.
- Si format vaut 'brut', 'standard' ou 'beautifie', retourne le texte issu
- de generator
+ Retourne une representation du JDC obj sous une forme qui est parametree par format.
+ Si format vaut 'brut', 'standard' ou 'beautifie', retourne le texte issu de generator
"""
liste= self.generator(obj)
if format == 'brut':
elif format == 'beautifie':
self.text=liste
else:
- raise "Format pas implémenté : "+format
+ raise EficasException(tr("Format pas implemente : %s", format))
return self.text
def generator(self,obj):
"""
Cette methode joue un role d'aiguillage en fonction du type de obj
- On pourrait utiliser les méthodes accept et visitxxx à la
- place (dépend des gouts !!!)
+ On pourrait utiliser les methodes accept et visitxxx a la
+ place (depend des gouts !!!)
"""
- # ATTENTION a l'ordre des tests : il peut avoir de l'importance (héritage)
+ # ATTENTION a l'ordre des tests : il peut avoir de l'importance (heritage)
if isinstance(obj,PROC_ETAPE):
return self.generPROC_ETAPE(obj)
elif isinstance(obj,MACRO_ETAPE):
return self.generETAPE_NIVEAU(obj)
elif isinstance(obj,COMMENTAIRE):
return self.generCOMMENTAIRE(obj)
- # Attention doit etre placé avant PARAMETRE (raison : héritage)
+ # Attention doit etre place avant PARAMETRE (raison : heritage)
elif isinstance(obj,PARAMETRE_EVAL):
return self.generPARAMETRE_EVAL(obj)
elif isinstance(obj,PARAMETRE):
elif isinstance(obj,MCNUPLET):
return self.generMCNUPLET(obj)
else:
- raise "Type d'objet non prévu",obj
+ raise EficasException(tr("Format non implemente : %s", format))
+
def generJDC(self,obj):
"""
- Cette méthode convertit un objet JDC en une chaine de
- caractères à la syntaxe aplat
+ Cette methode convertit un objet JDC en une chaine de
+ caracteres a la syntaxe aplat
"""
text=''
if obj.definition.l_niveaux == ():
def generCOMMANDE_COMM(self,obj):
"""
- Cette méthode convertit un COMMANDE_COMM
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit un COMMANDE_COMM
+ en une chaine de caracteres a la syntaxe aplat
"""
- l_lignes = string.split(obj.valeur,'\n')
+ l_lignes = obj.valeur.split('\n')
txt=''
for ligne in l_lignes:
txt = txt + '##'+ligne+'\n'
def generEVAL(self,obj):
"""
- Cette méthode convertit un EVAL
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit un EVAL
+ en une chaine de caracteres a la syntaxe aplat
"""
return 'EVAL("""'+ obj.valeur +'""")'
def generCOMMENTAIRE(self,obj):
"""
- Cette méthode convertit un COMMENTAIRE
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit un COMMENTAIRE
+ en une chaine de caracteres a la syntaxe aplat
"""
- l_lignes = string.split(obj.valeur,'\n')
+ l_lignes = obj.valeur.split('\n')
txt=''
for ligne in l_lignes:
txt = txt + '#'+ligne+'\n'
def generPARAMETRE_EVAL(self,obj):
"""
- Cette méthode convertit un PARAMETRE_EVAL
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit un PARAMETRE_EVAL
+ en une chaine de caracteres a la syntaxe aplat
"""
if obj.valeur == None:
return obj.nom + ' = None ;\n'
def generPARAMETRE(self,obj):
"""
- Cette méthode convertit un PARAMETRE
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit un PARAMETRE
+ en une chaine de caracteres a la syntaxe aplat
"""
- if type(obj.valeur) == types.StringType:
- return obj.nom + " = '" + obj.valeur + "';\n"
+ if type(obj.valeur) == bytes or type(obj.valeur) == str:
+ # PN pour corriger le bug a='3+4' au lieu de a= 3+4
+ #return obj.nom + " = '" + obj.valeur + "';\n"
+ return obj.nom + " = " + obj.valeur + ";\n"
else:
return obj.nom + ' = ' + str(obj.valeur) + ';\n'
def generETAPE_NIVEAU(self,obj):
"""
- Cette méthode convertit une étape niveau
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit une etape niveau
+ en une chaine de caracteres a la syntaxe aplat
"""
text=''
if obj.etapes_niveaux == []:
def gener_etape(self,obj):
"""
- Cette méthode est utilisé pour convertir les objets etape
- en une chaine de caractères à la syntaxe aplat
+ Cette methode est utilise pour convertir les objets etape
+ en une chaine de caracteres a la syntaxe aplat
"""
text=''
- for v in obj.mc_liste:
+ for v in obj.mcListe:
text=text + self.generator(v)
if text=='':
return self.init+'\n'
def generETAPE(self,obj):
"""
- Cette méthode convertit une étape
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit une etape
+ en une chaine de caracteres a la syntaxe aplat
"""
try:
sdname= self.generator(obj.sd)
def generMACRO_ETAPE(self,obj):
"""
- Cette méthode convertit une macro-étape
- en une chaine de caractères à la syntaxe aplat
+ Cette methode convertit une macro-etape
+ en une chaine de caracteres a la syntaxe aplat
"""
try:
if obj.sd == None:
def generASSD(self,obj):
"""
- Convertit un objet dérivé d'ASSD en une chaine de caractères à la
+ Convertit un objet derive d'ASSD en une chaine de caracteres a la
syntaxe aplat
"""
- return obj.get_name()
+ return obj.getName()
def generMCList(self,obj):
"""
- Convertit un objet MCList en une chaine de caractères à la
+ Convertit un objet MCList en une chaine de caracteres a la
syntaxe aplat
"""
i=0
old_init=self.init
for data in obj.data :
i=i+1
- self.init = init + self.sep + "occurrence n°"+`i`
+ self.init = init + self.sep + "occurrence n"+repr(i)
text = text + self.generator(data)
self.init=old_init
return text
def generMCSIMP(self,obj) :
"""
- Convertit un objet MCSIMP en une chaine de caractères à la
+ Convertit un objet MCSIMP en une chaine de caracteres a la
syntaxe aplat
"""
- if type(obj.valeur) in (types.TupleType,types.ListType) :
- # On est en présence d'une liste de valeur
+ if type(obj.valeur) in (tuple,list) :
+ # On est en presence d'une liste de valeur
rep = '('
for val in obj.valeur:
- if type(val) == types.InstanceType :
+ #if type(val) == types.InstanceType :
+ if isinstance(val,object):
rep = rep + self.generator(val) +','
else:
- rep = rep + `val`+','
+ rep = rep + repr(val)+','
rep = rep + ')'
- elif type(obj.valeur) == types.InstanceType :
- # On est en présence d'une valeur unique de type instance
+ #elif type(obj.valeur) == types.InstanceType :
+ elif type(obj.valeur) == object :
+ # On est en presence d'une valeur unique de type instance
rep = self.generator(obj.valeur)
else :
- # On est en présence d'une valeur unique
- rep = `obj.valeur`
+ # On est en presence d'une valeur unique
+ rep = repr(obj.valeur)
return self.init + self.sep + obj.nom + ' :' + rep + '\n'
def generMCCOMPO(self,obj):
"""
- Convertit un objet MCCOMPO en une chaine de caractères à la
+ Convertit un objet MCCOMPO en une chaine de caracteres a la
syntaxe aplat
"""
text = ''
old_init=self.init
self.init = self.init + self.sep + obj.nom
- for mocle in obj.mc_liste :
+ for mocle in obj.mcListe :
text = text + self.generator(mocle)
self.init=old_init
return text
