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 import re
  29 import N_CR
  30 import N_OPS
  31 import N_VALIDATOR
  32 from strfunc import ufmt
  33
  34 try:
  35     from PyQt4 import QtCore
  36     stringTypes = (str, unicode, QtCore.QString)
  37 except ImportError:
  38     stringTypes = (str, unicode)
  39
  40
  41 class ENTITE:
  42
  43     """
  44        Classe de base pour tous les objets de definition : mots cles et commandes
  45        Cette classe ne contient que des methodes utilitaires
  46        Elle ne peut être instanciee et doit d abord être specialisee
  47     """
  48     CR = N_CR.CR
  49     factories = {'validator': N_VALIDATOR.validatorFactory}
  50
  51     def __init__(self, validators=None):
  52         """
  53            Initialise les deux attributs regles et entites d'une classe dérivée
  54            à : pas de règles et pas de sous-entités.
  55
  56            L'attribut regles doit contenir la liste des regles qui s'appliquent
  57            sur ses sous-entités
  58
  59            L'attribut entités doit contenir le dictionnaires des sous-entités
  60            (clé = nom, valeur=objet)
  61         """
  62         self.regles = ()
  63         self.entites = {}
  64         if validators:
  65             self.validators = self.factories['validator'](validators)
  66         else:
  67             self.validators = validators
  68
  69     def affecter_parente(self):
  70         """
  71             Cette methode a pour fonction de donner un nom et un pere aux
  72             sous entités qui n'ont aucun moyen pour atteindre leur parent
  73             directement
  74             Il s'agit principalement des mots cles
  75         """
  76         for k, v in self.entites.items():
  77             v.pere = self
  78             v.nom = k
  79
  80     def verif_cata(self):
  81         """
  82             Cette methode sert à valider les attributs de l'objet de définition
  83         """
  84         raise NotImplementedError("La méthode verif_cata de la classe %s doit être implémentée"
  85                                   % self.__class__.__name__)
  86
  87     def __call__(self):
  88         """
  89             Cette methode doit retourner un objet dérivé de la classe OBJECT
  90         """
  91         raise NotImplementedError("La méthode __call__ de la classe %s doit être implémentée"
  92                                   % self.__class__.__name__)
  93
  94     def report(self):
  95         """
  96            Cette méthode construit pour tous les objets dérivés de ENTITE un
  97            rapport de validation de la définition portée par cet objet
  98         """
  99         self.cr = self.CR()
 100         self.verif_cata()
 101         for k, v in self.entites.items():
 102             try:
 103                 cr = v.report()
 104                 cr.debut = u"Début " + v.__class__.__name__ + ' : ' + k
 105                 cr.fin = u"Fin " + v.__class__.__name__ + ' : ' + k
 106                 self.cr.add(cr)
 107             except:
 108                 self.cr.fatal(
 109                     _(u"Impossible d'obtenir le rapport de %s %s"), k, `v`)
 110                 print "Impossible d'obtenir le rapport de %s %s" % (k, `v`)
 111                 print "père =", self
 112         return self.cr
 113
 114     def verif_cata_regles(self):
 115         """
 116            Cette méthode vérifie pour tous les objets dérivés de ENTITE que
 117            les objets REGLES associés ne portent que sur des sous-entités
 118            existantes
 119         """
 120         for regle in self.regles:
 121             l = []
 122             for mc in regle.mcs:
 123                 if not self.entites.has_key(mc):
 124                     l.append(mc)
 125             if l != []:
 126                 txt = str(regle)
 127                 self.cr.fatal(
 128                     _(u"Argument(s) non permis : %r pour la règle : %s"), l, txt)
 129
 130     def check_definition(self, parent):
 131         """Verifie la definition d'un objet composite (commande, fact, bloc)."""
 132         args = self.entites.copy()
 133         mcs = set()
 134         for nom, val in args.items():
 135             if val.label == 'SIMP':
 136                 mcs.add(nom)
 137                 # XXX
 138                 # if val.max != 1 and val.type == 'TXM':
 139                     # print "#CMD", parent, nom
 140             elif val.label == 'FACT':
 141                 val.check_definition(parent)
 142                 # CALC_SPEC !
 143                 # assert self.label != 'FACT', \
 144                    #'Commande %s : Mot-clef facteur present sous un mot-clef facteur : interdit !' \
 145                    #% parent
 146             else:
 147                 continue
 148             del args[nom]
 149         # seuls les blocs peuvent entrer en conflit avec les mcs du plus haut
 150         # niveau
 151         for nom, val in args.items():
 152             if val.label == 'BLOC':
 153                 mcbloc = val.check_definition(parent)
 154                 # XXX
 155                 # print "#BLOC", parent, re.sub('\s+', ' ', val.condition)
 156                 assert mcs.isdisjoint(mcbloc), "Commande %s : Mot(s)-clef(s) vu(s) plusieurs fois : %s" \
 157                     % (parent, tuple(mcs.intersection(mcbloc)))
 158         return mcs
 159
 160     def check_op(self, valmin=-9999, valmax=9999):
 161         """Vérifie l'attribut op."""
 162         if self.op is not None and \
 163            (type(self.op) is not int or self.op < valmin or self.op > valmax):
 164             self.cr.fatal(_(u"L'attribut 'op' doit être un entier "
 165                             u"compris entre %d et %d : %r"), valmin, valmax, self.op)
 166
 167     def check_proc(self):
 168         """Vérifie l'attribut proc."""
 169         if self.proc is not None and not isinstance(self.proc, N_OPS.OPS):
 170             self.cr.fatal(
 171                 _(u"L'attribut op doit être une instance d'OPS : %r"), self.proc)
 172
 173     def check_regles(self):
 174         """Vérifie l'attribut regles."""
 175         if type(self.regles) is not tuple:
 176             self.cr.fatal(_(u"L'attribut 'regles' doit être un tuple : %r"),
 177                           self.regles)
 178
 179     def check_fr(self):
 180         """Vérifie l'attribut fr."""
 181         if type(self.fr) not in stringTypes:
 182             self.cr.fatal(
 183                 _(u"L'attribut 'fr' doit être une chaine de caractères : %r"),
 184                 self.fr)
 185
 186     def check_docu(self):
 187         """Vérifie l'attribut docu."""
 188         if type(self.docu) not in stringTypes:
 189             self.cr.fatal(
 190                 _(u"L'attribut 'docu' doit être une chaine de caractères : %r"),
 191                 self.docu)
 192
 193     def check_nom(self):
 194         """Vérifie l'attribut proc."""
 195         if type(self.nom) is not str:
 196             self.cr.fatal(
 197                 _(u"L'attribut 'nom' doit être une chaine de caractères : %r"),
 198                 self.nom)
 199
 200     def check_reentrant(self):
 201         """Vérifie l'attribut reentrant."""
 202         if self.reentrant not in ('o', 'n', 'f'):
 203             self.cr.fatal(
 204                 _(u"L'attribut 'reentrant' doit valoir 'o','n' ou 'f' : %r"),
 205                 self.reentrant)
 206
 207     def check_statut(self, into=('o', 'f', 'c', 'd')):
 208         """Vérifie l'attribut statut."""
 209         if self.statut not in into:
 210             self.cr.fatal(_(u"L'attribut 'statut' doit être parmi %s : %r"),
 211                           into, self.statut)
 212
 213     def check_condition(self):
 214         """Vérifie l'attribut condition."""
 215         if self.condition != None:
 216             if type(self.condition) is not str:
 217                 self.cr.fatal(
 218                     _(u"L'attribut 'condition' doit être une chaine de caractères : %r"),
 219                     self.condition)
 220         else:
 221             self.cr.fatal(_(u"La condition ne doit pas valoir None !"))
 222
 223     def check_min_max(self):
 224         """Vérifie les attributs min/max."""
 225         if type(self.min) != int:
 226             if self.min != '**':
 227                 self.cr.fatal(
 228                     _(u"L'attribut 'min' doit être un entier : %r"), self.min)
 229         if type(self.max) != int:
 230             if self.max != '**':
 231                 self.cr.fatal(
 232                     _(u"L'attribut 'max' doit être un entier : %r"), self.max)
 233         if self.min > self.max:
 234             self.cr.fatal(
 235                 _(u"Nombres d'occurrence min et max invalides : %r %r"),
 236                 self.min, self.max)
 237
 238     def check_validators(self):
 239         """Vérifie les validateurs supplémentaires"""
 240         if self.validators and not self.validators.verif_cata():
 241             self.cr.fatal(_(u"Un des validateurs est incorrect. Raison : %s"),
 242                           self.validators.cata_info)
 243
 244     def check_homo(self):
 245         """Vérifie l'attribut homo."""
 246         if self.homo != 0 and self.homo != 1:
 247             self.cr.fatal(
 248                 _(u"L'attribut 'homo' doit valoir 0 ou 1 : %r"), self.homo)
 249
 250     def check_into(self):
 251         """Vérifie l'attribut into."""
 252         if self.into != None:
 253             if type(self.into) not in (list, tuple):
 254                 self.cr.fatal(
 255                     _(u"L'attribut 'into' doit être un tuple : %r"), self.into)
 256
 257     def check_position(self):
 258         """Vérifie l'attribut position."""
 259         if self.position not in ('local', 'global', 'global_jdc'):
 260             self.cr.fatal(_(u"L'attribut 'position' doit valoir 'local', 'global' "
 261                             u"ou 'global_jdc' : %r"), self.position)