Noyau/N_ASSD.py

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