Salome HOME
fin du menage
[tools/eficas.git] / Noyau / N_BLOC.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 """
22     Ce module contient la classe de definition BLOC
23     qui permet de spécifier les caractéristiques des blocs de mots clés
24 """
25
26 from __future__ import absolute_import
27 from __future__ import print_function
28 import types
29 import sys
30 import traceback
31
32 from . import N_ENTITE
33 from . import N_MCBLOC
34 from .N_Exception import AsException
35 from .N_types import forceList
36
37
38
39 class BLOC(N_ENTITE.ENTITE):
40
41     """
42      Classe pour definir un bloc de mots-cles
43
44      Cette classe a deux attributs de classe :
45
46        - class_instance qui indique la classe qui devra etre utilisée
47          pour créer l'objet qui servira à controler la conformité d'un
48          bloc de mots-clés avec sa définition
49        - label qui indique la nature de l'objet de définition (ici, BLOC)
50
51     """
52     class_instance = N_MCBLOC.MCBLOC
53     label = 'BLOC'
54
55     def __init__(self, fr="", docu="", regles=(), statut='f', condition=None,ang="", nomXML=None,
56                  **args):
57         """
58             Un bloc est caractérisé par les attributs suivants :
59
60               - fr   : chaine de caractere commentaire pour aide en ligne (en francais)
61               - regles : liste d'objets de type REGLE pour vérifier la cohérence des sous-objets
62               - statut : obligatoire ('o') ou facultatif ('f')
63               - condition : chaine de caractère evaluable par l'interpreteur Python
64               - entites : dictionnaire contenant les sous-objets de self (mots-clés).
65                 La clé du dictionnaire est le nom du mot-clé et la valeur l'objet de
66                 définition correspondant. Cet attribut est initialisé avec l'argument
67                 args de la méthode __init__
68
69         """
70         # Initialisation des attributs
71         self.fr = fr
72         self.ang = ang
73         self.docu = docu
74         self.fenetreIhm=None
75         if type(regles) == tuple:
76             self.regles = regles
77         else:
78             self.regles = (regles,)
79         self.statut = statut
80         self.condition = condition
81         self.nomXML = nomXML
82         self.entites = args
83         self.affecter_parente()
84         self.txtNomComplet = ''
85
86     def __call__(self, val, nom, parent=None, dicoPyxbDeConstruction=None):
87         """
88             Construit un objet MCBLOC a partir de sa definition (self)
89             de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent)
90         """
91         return self.class_instance(nom=nom, definition=self, val=val, parent=parent,dicoPyxbDeConstruction=dicoPyxbDeConstruction)
92
93     def verifCata(self):
94         """
95            Cette méthode vérifie si les attributs de définition sont valides.
96            Les éventuels messages d'erreur sont écrits dans l'objet compte-rendu (self.cr).
97         """
98         self.checkFr()
99         self.checkDocu()
100         self.checkRegles()
101         self.checkStatut(into=('f', 'o'))
102         self.checkCondition()
103         self.verifCataRegles()
104
105
106     def verifPresence(self, dict, globs):
107         """
108            Cette méthode vérifie si le dictionnaire passé en argument (dict)
109            est susceptible de contenir un bloc de mots-clés conforme à la
110            définition qu'il porte.
111
112            Si la réponse est oui, la méthode retourne 1
113
114            Si la réponse est non, la méthode retourne 0
115
116            Le dictionnaire dict a pour clés les noms des mots-clés et pour valeurs
117            les valeurs des mots-clés
118         """
119         # On recopie le dictionnaire pour protéger l'original
120         dico = blocUtils()
121         dico.update(dict)
122         if self.condition != None:
123             try:
124             #if 1 :
125                 test = eval(self.condition, globs, dico)
126                 return test
127             #try:
128             #   1
129             except NameError:
130                 # erreur 'normale' : un mot-clé n'est pas présent et on veut
131                 # l'évaluer dans la condition
132                 if CONTEXT.debug:
133                     l = traceback.format_exception(
134                         sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
135                     print(("WARNING : Erreur a l'evaluation de la condition " + ''.join(l)))
136                 return 0
137             except SyntaxError:
138                 # le texte de la condition n'est pas du Python correct -->
139                 # faute de catalogue
140                 l = traceback.format_exception(
141                     sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
142                 raise AsException(
143                     "Catalogue entite : ", self.nom, ", de pere : ", self.pere.nom,
144                     '\n', "Erreur dans la condition : ", self.condition, ''.join(l))
145             except:
146                 l = traceback.format_exception(
147                     sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
148                 raise AsException(
149                     "Catalogue entite : ", self.nom, ", de pere : ", self.pere.nom,
150                     '\n', "Erreur dans la condition : ", self.condition, ''.join(l))
151         else:
152             return 0
153
154
155
156     
157     def longueurDsArbre(self):
158       longueur=0
159       for mc in self.mcListe : 
160          longueur = longueur + mc.longueurDsArbre()
161       return longueur
162
163 def blocUtils():
164     """Définit un ensemble de fonctions utilisables pour écrire les
165     conditions de BLOC."""
166     def au_moins_un(mcsimp, valeurs):
167         """Valide si la (ou une) valeur de 'mcsimp' est au moins une fois dans
168         la ou les 'valeurs'. Similaire à la règle AU_MOINS_UN, 'mcsimp' peut
169         contenir plusieurs valeurs."""
170         test = set(forceList(mcsimp))
171         valeurs = set(forceList(valeurs))
172         return not test.isdisjoint(valeurs)
173
174     def aucun(mcsimp, valeurs):
175         """Valide si aucune des valeurs de 'mcsimp' n'est dans 'valeurs'."""
176         return not au_moins_un(mcsimp, valeurs)
177
178     def getEficasAttribut( nomUserASSD, nomAttr):
179         if nomUserASSD == None : return None
180         return ( nomUserASSD.getEficasAttribut(nomAttr))
181
182     def getEficasListOfAttributs( nomASSD, listeAttributs):
183         if nomASSD == None : return ()
184         return ( nomASSD.getEficasListOfAttributs(listeAttributs))
185
186     return locals()