X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Noyau%2FN_ENTITE.py;h=6451850d06c09bfeea80b1732b627a6b8dd418da;hb=2c5a8689b9c6cc46804fd268d416d1de2777059e;hp=89f8ccf808a85c4d5140166c551f9eac5f917b2e;hpb=860a50d7df32b5c86f9ab536178d030ea882cae5;p=tools%2Feficas.git diff --git a/Noyau/N_ENTITE.py b/Noyau/N_ENTITE.py index 89f8ccf8..6451850d 100644 --- a/Noyau/N_ENTITE.py +++ b/Noyau/N_ENTITE.py @@ -1,37 +1,39 @@ -# -*- coding: utf-8 -*- -#@ MODIF N_ENTITE Noyau DATE 09/09/2003 AUTEUR DURAND C.DURAND -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. +# -*- coding: iso-8859-1 -*- +# Copyright (C) 2007-2013 EDF R&D # -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. # -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. -# -# -# ====================================================================== -""" +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +""" Ce module contient la classe ENTITE qui est la classe de base de toutes les classes de definition d'EFICAS. """ +import re +import types import N_CR +import N_OPS import N_VALIDATOR +from strfunc import ufmt class ENTITE: """ Classe de base pour tous les objets de definition : mots cles et commandes Cette classe ne contient que des methodes utilitaires - Elle ne peut etre instanciee et doit d abord etre specialisee + Elle ne peut être instanciee et doit d abord être specialisee """ CR=N_CR.CR factories={'validator':N_VALIDATOR.validatorFactory} @@ -40,11 +42,11 @@ class ENTITE: """ Initialise les deux attributs regles et entites d'une classe dérivée à : pas de règles et pas de sous-entités. - - L'attribut regles doit contenir la liste des regles qui s'appliquent + + L'attribut regles doit contenir la liste des regles qui s'appliquent sur ses sous-entités - L'attribut entités doit contenir le dictionnaires des sous-entités + L'attribut entités doit contenir le dictionnaires des sous-entités (clé = nom, valeur=objet) """ self.regles=() @@ -57,9 +59,9 @@ class ENTITE: def affecter_parente(self): """ Cette methode a pour fonction de donner un nom et un pere aux - sous entités qui n'ont aucun moyen pour atteindre leur parent + sous entités qui n'ont aucun moyen pour atteindre leur parent directement - Il s'agit principalement des mots cles + Il s'agit principalement des mots cles """ for k,v in self.entites.items(): v.pere = self @@ -69,17 +71,19 @@ class ENTITE: """ Cette methode sert à valider les attributs de l'objet de définition """ - raise "La méthode verif_cata de la classe %s doit etre implémentée" % self.__class__.__name__ + raise NotImplementedError("La méthode verif_cata de la classe %s doit être implémentée" + % self.__class__.__name__) def __call__(self): """ Cette methode doit retourner un objet dérivé de la classe OBJECT """ - raise "La méthode __call__ de la classe %s doit etre implémentée" % self.__class__.__name__ + raise NotImplementedError("La méthode __call__ de la classe %s doit être implémentée" + % self.__class__.__name__) def report(self): """ - Cette méthode construit pour tous les objets dérivés de ENTITE un + Cette méthode construit pour tous les objets dérivés de ENTITE un rapport de validation de la définition portée par cet objet """ self.cr = self.CR() @@ -87,19 +91,19 @@ class ENTITE: for k,v in self.entites.items() : try : cr = v.report() - cr.debut = "Début "+v.__class__.__name__+ ' : ' + k - cr.fin = "Fin "+v.__class__.__name__+ ' : ' + k + cr.debut = u"Début "+v.__class__.__name__+ ' : ' + k + cr.fin = u"Fin "+v.__class__.__name__+ ' : ' + k self.cr.add(cr) except: - self.cr.fatal("Impossible d'obtenir le rapport de %s %s" %(k,`v`)) + self.cr.fatal(_(u"Impossible d'obtenir le rapport de %s %s"), k,`v`) print "Impossible d'obtenir le rapport de %s %s" %(k,`v`) print "père =",self return self.cr def verif_cata_regles(self): """ - Cette méthode vérifie pour tous les objets dérivés de ENTITE que - les objets REGLES associés ne portent que sur des sous-entités + Cette méthode vérifie pour tous les objets dérivés de ENTITE que + les objets REGLES associés ne portent que sur des sous-entités existantes """ for regle in self.regles : @@ -109,6 +113,125 @@ class ENTITE: l.append(mc) if l != [] : txt = str(regle) - self.cr.fatal("Argument(s) non permis : %s pour la règle : %s" %(`l`,txt)) + self.cr.fatal(_(u"Argument(s) non permis : %r pour la règle : %s"), l, txt) + + def check_definition(self, parent): + """Verifie la definition d'un objet composite (commande, fact, bloc).""" + args = self.entites.copy() + mcs = set() + for nom, val in args.items(): + if val.label == 'SIMP': + mcs.add(nom) + #XXX + #if val.max != 1 and val.type == 'TXM': + #print "#CMD", parent, nom + elif val.label == 'FACT': + val.check_definition(parent) + # CALC_SPEC ! + #assert self.label != 'FACT', \ + #'Commande %s : Mot-clef facteur present sous un mot-clef facteur : interdit !' \ + #% parent + else: + continue + del args[nom] + # seuls les blocs peuvent entrer en conflit avec les mcs du plus haut niveau + for nom, val in args.items(): + if val.label == 'BLOC': + mcbloc = val.check_definition(parent) + #XXX + #print "#BLOC", parent, re.sub('\s+', ' ', val.condition) + #assert mcs.isdisjoint(mcbloc), "Commande %s : Mot(s)-clef(s) vu(s) plusieurs fois : %s" \ + # % (parent, tuple(mcs.intersection(mcbloc))) + return mcs + + def check_op(self, valmin=-9999, valmax=9999): + """Vérifie l'attribut op.""" + if self.op is not None and \ + (type(self.op) is not int or self.op < valmin or self.op > valmax): + self.cr.fatal(_(u"L'attribut 'op' doit être un entier " + u"compris entre %d et %d : %r"), valmin, valmax, self.op) + + def check_proc(self): + """Vérifie l'attribut proc.""" + if self.proc is not None and not isinstance(self.proc, N_OPS.OPS): + self.cr.fatal(_(u"L'attribut op doit être une instance d'OPS : %r"), self.proc) + + def check_regles(self): + """Vérifie l'attribut regles.""" + if type(self.regles) is not tuple: + self.cr.fatal(_(u"L'attribut 'regles' doit être un tuple : %r"), + self.regles) + + def check_fr(self): + """Vérifie l'attribut fr.""" + if type(self.fr) not in (str, unicode): + self.cr.fatal(_(u"L'attribut 'fr' doit être une chaine de caractères : %r"), + self.fr) + + def check_docu(self): + """Vérifie l'attribut docu.""" + if type(self.docu) not in (str, unicode): + self.cr.fatal(_(u"L'attribut 'docu' doit être une chaine de caractères : %r"), + self.docu) + + def check_nom(self): + """Vérifie l'attribut proc.""" + if type(self.nom) != types.StringType : + self.cr.fatal(_(u"L'attribut 'nom' doit être une chaine de caractères : %r"), + self.nom) + + def check_reentrant(self): + """Vérifie l'attribut reentrant.""" + if self.reentrant not in ('o', 'n', 'f'): + self.cr.fatal(_(u"L'attribut 'reentrant' doit valoir 'o','n' ou 'f' : %r"), + self.reentrant) + + def check_statut(self, into=('o', 'f', 'c', 'd')): + """Vérifie l'attribut statut.""" + if self.statut not in into: + self.cr.fatal(_(u"L'attribut 'statut' doit être parmi %s : %r"), + into, self.statut) + + def check_condition(self): + """Vérifie l'attribut condition.""" + if self.condition != None : + if type(self.condition) != types.StringType : + self.cr.fatal(_(u"L'attribut 'condition' doit être une chaine de caractères : %r"), + self.condition) + else: + self.cr.fatal(_(u"La condition ne doit pas valoir None !")) + + def check_min_max(self): + """Vérifie les attributs min/max.""" + if type(self.min) != types.IntType : + if self.min != '**': + self.cr.fatal(_(u"L'attribut 'min' doit être un entier : %r"), self.min) + if type(self.max) != types.IntType : + if self.max != '**': + self.cr.fatal(_(u"L'attribut 'max' doit être un entier : %r"), self.max) + if self.min > self.max : + self.cr.fatal(_(u"Nombres d'occurrence min et max invalides : %r %r"), + self.min, self.max) + + def check_validators(self): + """Vérifie les validateurs supplémentaires""" + if self.validators and not self.validators.verif_cata(): + self.cr.fatal(_(u"Un des validateurs est incorrect. Raison : %s"), + self.validators.cata_info) + + def check_homo(self): + """Vérifie l'attribut homo.""" + if self.homo != 0 and self.homo != 1 : + self.cr.fatal(_(u"L'attribut 'homo' doit valoir 0 ou 1 : %r"), self.homo) + def check_into(self): + """Vérifie l'attribut into.""" + if self.into != None : + if type(self.into) != types.TupleType : + self.cr.fatal(_(u"L'attribut 'into' doit être un tuple : %r"), self.into) + def check_position(self): + """Vérifie l'attribut position.""" + if self.position not in ('local', 'global', 'global_jdc'): + self.cr.fatal(_(u"L'attribut 'position' doit valoir 'local', 'global' " + u"ou 'global_jdc' : %r"), self.position)