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