Noyau/N_ENTITE.py

   1 # coding=utf-8
   2 # person_in_charge: mathieu.courtois at edf.fr
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2015  EDF R&D                  WWW.CODE-ASTER.ORG
   5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   8 # (AT YOUR OPTION) ANY LATER VERSION.
   9 #
  10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  14 #
  15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  17 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  18 #
  19 #
  20 # ======================================================================
  21
  22
  23 """
  24     Ce module contient la classe ENTITE qui est la classe de base
  25     de toutes les classes de definition d'EFICAS.
  26 """
  27
  28 from __future__ import absolute_import
  29 from __future__ import print_function
  30 try :
  31    from builtins import str
  32    from builtins import object
  33 except :
  34    pass
  35 import re
  36 from . import N_CR
  37 from . import N_OPS
  38 from . import N_VALIDATOR
  39
  40 import six
  41 stringTypes = (str, six.text_type)
  42
  43
  44 class ENTITE(object):
  45
  46     """
  47        Classe de base pour tous les objets de definition : mots cles et commandes
  48        Cette classe ne contient que des methodes utilitaires
  49        Elle ne peut être instanciee et doit d abord être specialisee
  50     """
  51     CR = N_CR.CR
  52     factories = {'validator': N_VALIDATOR.validatorFactory}
  53
  54     def __init__(self, validators=None):
  55         """
  56            Initialise les deux attributs regles et entites d'une classe dérivée
  57            à : pas de règles et pas de sous-entités.
  58
  59            L'attribut regles doit contenir la liste des regles qui s'appliquent
  60            sur ses sous-entités
  61
  62            L'attribut entités doit contenir le dictionnaires des sous-entités
  63            (clé = nom, valeur=objet)
  64         """
  65         self.regles = ()
  66         self.entites = {}
  67         if validators:
  68             self.validators = self.factories['validator'](validators)
  69         else:
  70             self.validators = validators
  71
  72     def affecter_parente(self):
  73         """
  74             Cette methode a pour fonction de donner un nom et un pere aux
  75             sous entités qui n'ont aucun moyen pour atteindre leur parent
  76             directement
  77             Il s'agit principalement des mots cles
  78         """
  79         for k, v in list(self.entites.items()):
  80             v.pere = self
  81             v.nom = k
  82
  83     def verif_cata(self):
  84         """
  85             Cette methode sert à valider les attributs de l'objet de définition
  86         """
  87         raise NotImplementedError("La méthode verif_cata de la classe %s doit être implémentée"
  88                                   % self.__class__.__name__)
  89
  90     def __call__(self):
  91         """
  92             Cette methode doit retourner un objet dérivé de la classe OBJECT
  93         """
  94         raise NotImplementedError("La méthode __call__ de la classe %s doit être implémentée"
  95                                   % self.__class__.__name__)
  96
  97     def report(self):
  98         """
  99            Cette méthode construit pour tous les objets dérivés de ENTITE un
 100            rapport de validation de la définition portée par cet objet
 101         """
 102         self.cr = self.CR()
 103         self.verif_cata()
 104         for k, v in list(self.entites.items()):
 105             try:
 106                 cr = v.report()
 107                 cr.debut = u"Début " + v.__class__.__name__ + ' : ' + k
 108                 cr.fin = u"Fin " + v.__class__.__name__ + ' : ' + k
 109                 self.cr.add(cr)
 110             except:
 111                 self.cr.fatal("Impossible d'obtenir le rapport de %s %s" % (k, repr(v)))
 112                 print(("Impossible d'obtenir le rapport de %s %s" % (k, repr(v))))
 113                 print(("père =", self))
 114         return self.cr
 115
 116     def verif_cata_regles(self):
 117         """
 118            Cette méthode vérifie pour tous les objets dérivés de ENTITE que
 119            les objets REGLES associés ne portent que sur des sous-entités
 120            existantes
 121         """
 122         for regle in self.regles:
 123             l = []
 124             for mc in regle.mcs:
 125                 if not mc in  self.entites :
 126                     l.append(mc)
 127             if l != []:
 128                 txt = str(regle)
 129                 self.cr.fatal(
 130                     _(u"Argument(s) non permis : %r pour la règle : %s"), l, txt)
 131
 132     def check_definition(self, parent):
 133         """Verifie la definition d'un objet composite (commande, fact, bloc)."""
 134         args = self.entites.copy()
 135         mcs = set()
 136         for nom, val in list(args.items()):
 137             if val.label == 'SIMP':
 138                 mcs.add(nom)
 139                 # XXX
 140                 # if val.max != 1 and val.type == 'TXM':
 141                     # print "#CMD", parent, nom
 142             elif val.label == 'FACT':
 143                 val.check_definition(parent)
 144                 # CALC_SPEC !
 145                 # assert self.label != 'FACT', \
 146                    #'Commande %s : Mot-clef facteur present sous un mot-clef facteur : interdit !' \
 147                    #% parent
 148             else:
 149                 continue
 150             del args[nom]
 151         # seuls les blocs peuvent entrer en conflit avec les mcs du plus haut
 152         # niveau
 153         for nom, val in list(args.items()):
 154             if val.label == 'BLOC':
 155                 mcbloc = val.check_definition(parent)
 156                 # XXX
 157                 # print "#BLOC", parent, re.sub('\s+', ' ', val.condition)
 158                 assert mcs.isdisjoint(mcbloc), "Commande %s : Mot(s)-clef(s) vu(s) plusieurs fois : %s" \
 159                     % (parent, tuple(mcs.intersection(mcbloc)))
 160         return mcs
 161
 162     def check_op(self, valmin=-9999, valmax=9999):
 163         """Vérifie l'attribut op."""
 164         if self.op is not None and \
 165            (type(self.op) is not int or self.op < valmin or self.op > valmax):
 166             self.cr.fatal(_(u"L'attribut 'op' doit être un entier "
 167                             u"compris entre %d et %d : %r"), valmin, valmax, self.op)
 168
 169     def check_proc(self):
 170         """Vérifie l'attribut proc."""
 171         if self.proc is not None and not isinstance(self.proc, N_OPS.OPS):
 172             self.cr.fatal(
 173                 _(u"L'attribut op doit être une instance d'OPS : %r"), self.proc)
 174
 175     def check_regles(self):
 176         """Vérifie l'attribut regles."""
 177         if type(self.regles) is not tuple:
 178             self.cr.fatal(_(u"L'attribut 'regles' doit être un tuple : %r"),
 179                           self.regles)
 180
 181     def check_fr(self):
 182         """Vérifie l'attribut fr."""
 183         if type(self.fr) not in stringTypes:
 184             self.cr.fatal(
 185                 _(u"L'attribut 'fr' doit être une chaine de caractères : %r"),
 186                 self.fr)
 187
 188     def check_docu(self):
 189         """Vérifie l'attribut docu."""
 190         if type(self.docu) not in stringTypes:
 191             self.cr.fatal(
 192                 _(u"L'attribut 'docu' doit être une chaine de caractères : %r"),
 193                 self.docu)
 194
 195     def check_nom(self):
 196         """Vérifie l'attribut proc."""
 197         if type(self.nom) is not str:
 198             self.cr.fatal(
 199                 _(u"L'attribut 'nom' doit être une chaine de caractères : %r"),
 200                 self.nom)
 201
 202     def check_reentrant(self):
 203         """Vérifie l'attribut reentrant."""
 204         if self.reentrant not in ('o', 'n', 'f'):
 205             self.cr.fatal(
 206                 _(u"L'attribut 'reentrant' doit valoir 'o','n' ou 'f' : %r"),
 207                 self.reentrant)
 208
 209     def check_statut(self, into=('o', 'f', 'c', 'd')):
 210         """Vérifie l'attribut statut."""
 211         if self.statut not in into:
 212             self.cr.fatal(_(u"L'attribut 'statut' doit être parmi %s : %r"),
 213                           into, self.statut)
 214
 215     def check_condition(self):
 216         """Vérifie l'attribut condition."""
 217         if self.condition != None:
 218             if type(self.condition) is not str:
 219                 self.cr.fatal(
 220                     _(u"L'attribut 'condition' doit être une chaine de caractères : %r"),
 221                     self.condition)
 222         else:
 223             self.cr.fatal(_(u"La condition ne doit pas valoir None !"))
 224
 225     def check_min_max(self):
 226         """Vérifie les attributs min/max."""
 227         if type(self.min) != int:
 228             if self.min != '**'and self.min != float('-inf'):
 229                 self.cr.fatal(
 230                     _(u"L'attribut 'min' doit être un entier : %r"), self.min)
 231         if type(self.max) != int:
 232             if self.max != '**' and self.max != float('inf'):
 233                 self.cr.fatal(
 234                     _(u"L'attribut 'max' doit être un entier : %r"), self.max)
 235         if self.min > self.max:
 236             self.cr.fatal(
 237                 _(u"Nombres d'occurrence min et max invalides : %r %r"),
 238                 self.min, self.max)
 239
 240     def check_validators(self):
 241         """Vérifie les validateurs supplémentaires"""
 242         if self.validators and not self.validators.verif_cata():
 243             self.cr.fatal(_(u"Un des validateurs est incorrect. Raison : %s"),
 244                           self.validators.cata_info)
 245
 246     def check_homo(self):
 247         """Vérifie l'attribut homo."""
 248         if self.homo != 0 and self.homo != 1:
 249             self.cr.fatal(
 250                 _(u"L'attribut 'homo' doit valoir 0 ou 1 : %r"), self.homo)
 251
 252     def check_into(self):
 253         """Vérifie l'attribut into."""
 254         if self.into != None:
 255             if type(self.into) not in (list, tuple):
 256                 self.cr.fatal(
 257                     _(u"L'attribut 'into' doit être un tuple : %r"), self.into)
 258
 259     def check_position(self):
 260         """Vérifie l'attribut position."""
 261         if self.position not in ('local', 'global', 'global_jdc'):
 262             self.cr.fatal(_(u"L'attribut 'position' doit valoir 'local', 'global' "
 263                             u"ou 'global_jdc' : %r"), self.position)