Noyau/N_ENTITE.py

   1 # coding=utf-8
   2 # ======================================================================
   3 # COPYRIGHT (C) 1991 - 2017  EDF R&D                  WWW.CODE-ASTER.ORG
   4 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   5 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   6 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   7 # (AT YOUR OPTION) ANY LATER VERSION.
   8 #
   9 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  10 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  11 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  12 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  13 #
  14 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  15 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  16 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  17 #
  18 #
  19 # ======================================================================
  20
  21
  22 """
  23     Ce module contient la classe ENTITE qui est la classe de base
  24     de toutes les classes de definition d'EFICAS.
  25 """
  26
  27 from __future__ import absolute_import
  28 from __future__ import print_function
  29 try :
  30    from builtins import str
  31    from builtins import object
  32 except :
  33    pass
  34 import re
  35 from . import N_CR
  36 from . import N_OPS
  37 from . import N_VALIDATOR
  38
  39 import six
  40 stringTypes = (str, six.text_type)
  41
  42
  43 class ENTITE(object):
  44
  45     """
  46        Classe de base pour tous les objets de definition : mots cles et commandes
  47        Cette classe ne contient que des methodes utilitaires
  48        Elle ne peut être instanciee et doit d abord être specialisee
  49     """
  50     CR = N_CR.CR
  51     factories = {'validator': N_VALIDATOR.validatorFactory}
  52
  53     def __init__(self, validators=None):
  54         """
  55            Initialise les deux attributs regles et entites d'une classe dérivée
  56            à : pas de règles et pas de sous-entités.
  57
  58            L'attribut regles doit contenir la liste des regles qui s'appliquent
  59            sur ses sous-entités
  60
  61            L'attribut entités doit contenir le dictionnaires des sous-entités
  62            (clé = nom, valeur=objet)
  63         """
  64         self.regles = ()
  65         self.entites = {}
  66         if validators:
  67             self.validators = self.factories['validator'](validators)
  68         else:
  69             self.validators = validators
  70
  71     def affecter_parente(self):
  72         """
  73             Cette methode a pour fonction de donner un nom et un pere aux
  74             sous entités qui n'ont aucun moyen pour atteindre leur parent
  75             directement
  76             Il s'agit principalement des mots cles
  77         """
  78         for k, v in list(self.entites.items()):
  79             v.pere = self
  80             v.nom = k
  81
  82     def verifCata(self):
  83         """
  84             Cette methode sert à valider les attributs de l'objet de définition
  85         """
  86         raise NotImplementedError("La méthode verifCata de la classe %s doit être implémentée"
  87                                   % self.__class__.__name__)
  88
  89     def __call__(self):
  90         """
  91             Cette methode doit retourner un objet dérivé de la classe OBJECT
  92         """
  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.verifCata()
 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 verifCataRegles(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 checkDefinition(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.checkDefinition(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.checkDefinition(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 checkOp(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 checkProc(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 checkRegles(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 checkFr(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 checkDocu(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 checkNom(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 checkReentrant(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 checkStatut(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 checkCondition(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 checkMinMax(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 checkValidators(self):
 241         """Vérifie les validateurs supplémentaires"""
 242         if self.validators and not self.validators.verifCata():
 243             self.cr.fatal(_(u"Un des validateurs est incorrect. Raison : %s"),
 244                           self.validators.cata_info)
 245
 246     def checkHomo(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 checkInto(self):
 253         """Vérifie l'attribut into."""
 254         if self.into != None:
 255             if (type(self.into) not in (list, tuple)) and (type(self.into) != types.FunctionType) :
 256                 self.cr.fatal(
 257                     _(u"L'attribut 'into' doit être un tuple : %r"), self.into)
 258
 259     def checkPosition(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)
 264
 265     def dumpXSD(self):
 266         args = self.entites.copy()
 267         mcs = set()
 268         for nom, val in list(args.items()):
 269             if val.label == 'SIMP':
 270                 mcs.add(nom)
 271                 # XXX
 272                 # if val.max != 1 and val.type == 'TXM':
 273                     # print "#CMD", parent, nom
 274             elif val.label == 'FACT':
 275                 liste=val.dumpXSD()
 276                 mcs.update(liste)
 277         print (self.nom, mcs)
 278         return mcs