Noyau/N_FACT.py

   1 # coding=utf-8
   2 # Copyright (C) 2007-2013   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 """ Ce module contient la classe de definition FACT
  22     qui permet de spécifier les caractéristiques des mots clés facteurs
  23 """
  24
  25 from __future__ import absolute_import
  26 from __future__ import print_function
  27 import types
  28
  29 from . import N_ENTITE
  30 from . import N_MCFACT
  31 from . import N_MCLIST
  32 from .N__F import _F
  33 from .N_types import is_sequence
  34
  35 from . import N_OBJECT
  36
  37
  38 class FACT(N_ENTITE.ENTITE):
  39
  40     """
  41      Classe pour definir un mot cle facteur
  42
  43      Cette classe a trois 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          mot-clé facteur avec sa définition
  48
  49        - list_instance
  50
  51        - label qui indique la nature de l'objet de définition (ici, FACT)
  52     """
  53     class_instance = N_MCFACT.MCFACT
  54     list_instance = N_MCLIST.MCList
  55     label = 'FACT'
  56
  57     def __init__(self, fr="", docu="", regles=(), statut='f', defaut=None,ang="",
  58                  min=0, max=1, validators=None, **args):
  59         """
  60             Un mot-clé facteur est caractérisé par les attributs suivants :
  61
  62               - fr   :
  63               - statut :
  64               - defaut :
  65               - regles
  66               - min
  67               - max
  68               - position
  69               - docu
  70         """
  71         N_ENTITE.ENTITE.__init__(self, validators)
  72         # Initialisation des attributs
  73         self.fr = fr
  74         self.ang=ang
  75         self.docu = docu
  76         if type(regles) == tuple:
  77             self.regles = regles
  78         else:
  79             self.regles = (regles,)
  80         self.statut = statut
  81         self.defaut = defaut
  82         self.min = min
  83         self.max = max
  84         if self.max == "**" : self.max=float('inf')
  85         if self.min == "**" : self.min=float('-inf')
  86         self.entites = args
  87         self.position = None
  88         self.affecter_parente()
  89
  90     def __call__(self, val, nom, parent):
  91         """
  92             Construit la structure de donnee pour un mot cle facteur a partir
  93             de sa definition (self) de sa valeur (val), de son nom (nom) et de
  94             son parent dans l arboresence (parent)
  95
  96             Suivant le type de la valeur on retournera soit un objet de type
  97             MCFACT soit une liste de type MCLIST.
  98
  99             La creation d un mot cle facteur depend de son statut
 100               - Si statut ='o'   il est obligatoire
 101               - Si statut == 'd' il est facultatif mais ses sous mots cles avec
 102                 defaut sont visibles
 103               - Si statut == 'f' il est facultatif et ses sous mots avec defaut ne
 104                 sont pas visibles
 105               - Si statut == 'c' il est cache ???
 106               - Si defaut != None, on utilise cette valeur pour calculer la valeur
 107                 par defaut du mot cle facteur
 108         """
 109         if val is None:
 110             if self.defaut == None:
 111                 val = {}
 112             elif type(self.defaut) == tuple:
 113                 val = self.defaut
 114                     # Est ce utile ? Le défaut pourrait etre uniquement un dict
 115             elif type(self.defaut) == dict or isinstance(self.defaut, _F):
 116                 val = self.defaut
 117             else:
 118                 # On ne devrait jamais passer par la
 119                 print ("On ne devrait jamais passer par la")
 120                 return None
 121         elif is_sequence(val) and len(val) == 0 and self.statut == 'o':
 122                 # On est dans le cas où le mcfact est présent mais est une liste/tuple
 123                 # vide. Il est obligatoire donc on l'initialise. Les règles, mots-clés
 124                 # obligatoires diront si un mcfact vide est accepté.
 125             val = {}
 126
 127         # On cree toujours une liste de mcfact
 128         l = self.list_instance()
 129         l.init(nom=nom, parent=parent)
 130         if type(val) in (tuple, list, self.list_instance):
 131             for v in val:
 132                 if type(v) == dict or isinstance(v, _F):
 133                     objet = self.class_instance(
 134                         nom=nom, definition=self, val=v, parent=parent)
 135                     l.append(objet)
 136                 elif isinstance(v, self.class_instance):
 137                     l.append(v)
 138                 else:
 139                     l.append(N_OBJECT.ErrorObj(self, v, parent, nom))
 140         elif type(val) == dict or isinstance(val, _F):
 141             objet = self.class_instance(
 142                 nom=nom, definition=self, val=val, parent=parent)
 143             l.append(objet)
 144         elif isinstance(val, self.class_instance):
 145             l.append(val)
 146         else:
 147             l.append(N_OBJECT.ErrorObj(self, val, parent, nom))
 148
 149         return l
 150
 151     def verif_cata(self):
 152         self.check_min_max()
 153         self.check_fr()
 154         self.check_regles()
 155         self.check_statut()
 156         self.check_docu()
 157         self.check_validators()
 158         self.verif_cata_regles()