Noyau/N_ASSD.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
  22 """
  23
  24 from N_utils import import_object
  25 from N_info import message, SUPERV
  26
  27
  28 class ASSD(object):
  29
  30     """
  31        Classe de base pour definir des types de structures de donnees ASTER
  32        equivalent d un concept ASTER
  33     """
  34     idracine = "SD"
  35
  36     def __init__(self, etape=None, sd=None, reg='oui'):
  37         """
  38           reg est un paramètre qui vaut oui ou non :
  39             - si oui (défaut) : on enregistre la SD auprès du JDC
  40             - si non : on ne l'enregistre pas
  41         """
  42         self.etape = etape
  43         self.sd = sd
  44         self.nom = None
  45         if etape:
  46             self.parent = etape.parent
  47         else:
  48             self.parent = CONTEXT.get_current_step()
  49         if self.parent:
  50             self.jdc = self.parent.get_jdc_root()
  51         else:
  52             self.jdc = None
  53
  54         if not self.parent:
  55             self.id = None
  56         elif reg == 'oui':
  57             self.id = self.parent.reg_sd(self)
  58         else:
  59             self.id = self.parent.o_register(self)
  60         # permet de savoir si le concept a été calculé (1) ou non (0)
  61         self.executed = 0
  62         if self.parent:
  63             self.order = self.parent.icmd
  64         else:
  65             self.order = 0
  66         # attributs pour le Catalogue de Structure de Données Jeveux
  67         # "self.cata_sdj" est un attribut de classe
  68         self.ptr_class_sdj = None
  69         self.ptr_sdj = None
  70         # construit en tant que CO('...')
  71         # 0 : assd normal, 1 : type CO, 2 : type CO typé
  72         self._as_co = 0
  73
  74     def _get_sdj(self):
  75         """Retourne le catalogue de SD associé au concept."""
  76         if self.ptr_sdj is None:
  77             cata_sdj = getattr(self, 'cata_sdj', None)
  78             assert cata_sdj, "The attribute 'cata_sdj' must be defined in the class %s" \
  79                 % self.__class__.__name__
  80             assert self.nom, "The attribute 'nom' has not been filled!"
  81             if self.ptr_class_sdj is None:
  82                 self.ptr_class_sdj = import_object(cata_sdj)
  83             self.ptr_sdj = self.ptr_class_sdj(nomj=self.nom)
  84         return self.ptr_sdj
  85
  86     def _del_sdj(self):
  87         """Suppression du catalogue de SD."""
  88         if self.ptr_sdj is not None:
  89             self.ptr_sdj.supprime(True)
  90             self.ptr_sdj = None
  91         self.ptr_class_sdj = None
  92
  93     sdj = property(_get_sdj, None, _del_sdj)
  94
  95     def __getitem__(self, key):
  96         from strfunc import convert
  97         text_error = convert(_(u"ASSD.__getitem__ est déprécié car la référence à "
  98                                u"l'objet ETAPE parent sera supprimée."))
  99         # raise NotImplementedError(text_error)
 100         from warnings import warn
 101         warn(text_error, DeprecationWarning, stacklevel=2)
 102         return self.etape[key]
 103
 104     def set_name(self, nom):
 105         """Positionne le nom de self (et appelle sd_init)
 106         """
 107         self.nom = nom
 108
 109     def is_typco(self):
 110         """Permet de savoir si l'ASSD est issu d'un type CO.
 111         Retourne:
 112            0 : ce n'est pas un type CO
 113            1 : c'est un type CO, non encore typé
 114            2 : c'est un type CO retypé
 115         """
 116         return self._as_co
 117
 118     def change_type(self, new_type):
 119         """Type connu a posteriori (type CO)."""
 120         self.__class__ = new_type
 121         assert self._as_co != 0, 'it should only be called on CO object.'
 122         self._as_co = 2
 123
 124     def get_name(self):
 125         """
 126             Retourne le nom de self, éventuellement en le demandant au JDC
 127         """
 128         if not self.nom:
 129             try:
 130                 self.nom = self.parent.get_name(self) or self.id
 131             except:
 132                 self.nom = ""
 133         if self.nom.find('sansnom') != -1 or self.nom == '':
 134             self.nom = self.id
 135         return self.nom
 136
 137     def supprime(self, force=False):
 138         """
 139         Cassage des boucles de références pour destruction du JDC.
 140         'force' est utilisée pour faire des suppressions complémentaires
 141         (voir les formules dans N_FONCTION).
 142         """
 143         self.supprime_sd()
 144         self.etape = None
 145         self.sd = None
 146         self.jdc = None
 147         self.parent = None
 148
 149     def supprime_sd(self):
 150         """Supprime la partie du catalogue de SD."""
 151         # 'del self.sdj' appellerait la méthode '_get_sdj()'...
 152         self._del_sdj()
 153
 154     def __del__(self):
 155         # message.debug(SUPERV, "__del__ ASSD %s <%s>", getattr(self, 'nom',
 156         # 'unknown'), self)
 157         pass
 158
 159     def accept(self, visitor):
 160         """
 161            Cette methode permet de parcourir l'arborescence des objets
 162            en utilisant le pattern VISITEUR
 163         """
 164         visitor.visitASSD(self)
 165
 166     def __getstate__(self):
 167         """
 168             Cette methode permet de pickler les objets ASSD
 169             Ceci est possible car on coupe les liens avec les objets
 170             parent, etape et jdc qui conduiraient à pickler de nombreux
 171             objets inutiles ou non picklables.
 172             En sortie, l'objet n'est plus tout à fait le même !
 173         """
 174         d = self.__dict__.copy()
 175         for key in ('parent', 'etape', 'jdc'):
 176             if d.has_key(key):
 177                 del d[key]
 178         for key in d.keys():
 179             if key in ('_as_co', ):
 180                 continue
 181             if key[0] == '_':
 182                 del d[key]
 183         return d
 184
 185     def accessible(self):
 186         """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD.
 187         """
 188         if CONTEXT.debug:
 189             print '| accessible ?', self.nom
 190         is_accessible = CONTEXT.get_current_step().sd_accessible()
 191         if CONTEXT.debug:
 192             print '  `- is_accessible =', repr(is_accessible)
 193         return is_accessible
 194
 195     def filter_context(self, context):
 196         """Filtre le contexte fourni pour retirer (en gros) ce qui vient du catalogue."""
 197         from N_ENTITE import ENTITE
 198         import types
 199         ctxt = {}
 200         for key, value in context.items():
 201             if type(value) is types.ClassType:
 202                 continue
 203             if type(value) is types.ModuleType and value.__name__.startswith('Accas'):
 204                 continue
 205             if issubclass(type(value), types.TypeType):
 206                 continue
 207             if isinstance(value, ENTITE):
 208                 continue
 209             ctxt[key] = value
 210         return ctxt
 211
 212     def par_lot(self):
 213         """Conserver uniquement pour la compatibilite avec le catalogue v9 dans eficas."""
 214         # XXX eficas
 215         if not hasattr(self, 'jdc') or self.jdc == None:
 216             val = None
 217         else:
 218             val = self.jdc.par_lot
 219         return val == 'OUI'
 220
 221     def rebuild_sd(self):
 222         """Conserver uniquement pour la compatibilite avec le catalogue v10 dans eficas."""
 223
 224
 225 class assd(ASSD):
 226
 227     def __convert__(cls, valeur):
 228             # On accepte les vraies ASSD et les objets 'entier' et 'reel'
 229             # qui font tout pour se faire passer pour de vrais entiers/réels.
 230         if isinstance(valeur, ASSD) or type(valeur) in (int, float):
 231             return valeur
 232         raise ValueError(_(u"On attend un objet concept."))
 233     __convert__ = classmethod(__convert__)
 234
 235
 236 class not_checked(ASSD):
 237
 238     def __convert__(cls, valeur):
 239         return valeur
 240     __convert__ = classmethod(__convert__)