Noyau/N_MCSIMP.py

   1 # coding=utf-8
   2 # Copyright (C) 2007-2017   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     Ce module contient la classe MCSIMP qui sert à controler la valeur
  23     d'un mot-clé simple par rapport à sa définition portée par un objet
  24     de type ENTITE
  25 """
  26
  27 from __future__ import absolute_import
  28 from copy import copy
  29
  30 from Noyau.N_ASSD import ASSD
  31 from Noyau.N_CO import CO
  32 from . import N_OBJECT
  33 from .N_CONVERT import ConversionFactory
  34 from .N_types import forceList, isSequence
  35
  36
  37 class MCSIMP(N_OBJECT.OBJECT):
  38
  39     """
  40     """
  41     nature = 'MCSIMP'
  42
  43     def __init__(self, val, definition, nom, parent,objPyxbDeConstruction):
  44         """
  45            Attributs :
  46
  47             - val : valeur du mot clé simple
  48
  49             - definition
  50
  51             - nom
  52
  53             - parent
  54
  55           Autres attributs :
  56
  57             - valeur : valeur du mot-clé simple en tenant compte de la valeur par défaut
  58
  59         """
  60         #print ("MCSIMP, ------------------------")
  61         #print (self, val, definition, nom, parent)
  62         #print ("MCSIMP, ------------------------")
  63         self.definition = definition
  64         self.nom = nom
  65         self.val = val
  66         self.parent = parent
  67         self.convProto = ConversionFactory('type', typ=self.definition.type)
  68         self.valeur = self.GETVAL(self.val)
  69         self.objPyxbDeConstruction=objPyxbDeConstruction
  70         if parent:
  71             self.jdc  = self.parent.jdc
  72             if self.jdc : self.cata = self.jdc.cata
  73             else : self.cata = None
  74             self.niveau = self.parent.niveau
  75             self.etape = self.parent.etape
  76             #self.buildObjPyxb()
  77         else:
  78             # Le mot cle simple a été créé sans parent
  79             # est-ce possible ?
  80             print ('je suis dans le else sans parent du build')
  81             self.jdc = None
  82             self.cata = None
  83             self.niveau = None
  84             self.etape = None
  85
  86     def GETVAL(self, val):
  87         """
  88             Retourne la valeur effective du mot-clé en fonction
  89             de la valeur donnée. Defaut si val == None
  90         """
  91         if (val is None and hasattr(self.definition, 'defaut')):
  92             val = self.definition.defaut
  93         if self.convProto:
  94             val = self.convProto.convert(val)
  95         return val
  96
  97     def getValeur(self):
  98         """
  99             Retourne la "valeur" d'un mot-clé simple.
 100             Cette valeur est utilisée lors de la création d'un contexte
 101             d'évaluation d'expressions à l'aide d'un interpréteur Python
 102         """
 103         v = self.valeur
 104         # Si singleton et max=1, on retourne la valeur.
 105         # Si une valeur simple et max='**', on retourne un singleton.
 106         # (si liste de longueur > 1 et max=1, on sera arrêté plus tard)
 107         # Pour accepter les numpy.array, on remplace : "type(v) not in (list, tuple)"
 108         # par "not has_attr(v, '__iter__')".
 109         if v is None:
 110             pass
 111         elif isSequence(v) and len(v) == 1 and self.definition.max == 1:
 112             v = v[0]
 113         elif not isSequence(v) and self.definition.max != 1:
 114             v = (v, )
 115         # traitement particulier pour les complexes ('RI', r, i)
 116         if 'C' in self.definition.type and self.definition.max != 1 and v != None and v[0] in ('RI', 'MP'):
 117             v = (v, )
 118         return v
 119
 120     def getVal(self):
 121         """
 122             Une autre méthode qui retourne une "autre" valeur du mot clé simple.
 123             Elle est utilisée par la méthode getMocle
 124         """
 125         return self.valeur
 126
 127     def accept(self, visitor):
 128         """
 129            Cette methode permet de parcourir l'arborescence des objets
 130            en utilisant le pattern VISITEUR
 131         """
 132         visitor.visitMCSIMP(self)
 133
 134     def copy(self):
 135         """ Retourne une copie de self """
 136         objet = self.makeobjet()
 137         # il faut copier les listes et les tuples mais pas les autres valeurs
 138         # possibles (réel,SD,...)
 139         if type(self.valeur) in (list, tuple):
 140             objet.valeur = copy(self.valeur)
 141         else:
 142             objet.valeur = self.valeur
 143         objet.val = objet.valeur
 144         return objet
 145
 146     def makeobjet(self):
 147         return self.definition(val=None, nom=self.nom, parent=self.parent)
 148
 149     def reparent(self, parent):
 150         """
 151            Cette methode sert a reinitialiser la parente de l'objet
 152         """
 153         self.parent = parent
 154         self.jdc = parent.jdc
 155         self.etape = parent.etape
 156
 157     def getSd_utilisees(self):
 158         """
 159             Retourne une liste qui contient la ou les SD utilisée par self si c'est le cas
 160             ou alors une liste vide
 161         """
 162         l = []
 163         if isinstance(self.valeur, ASSD):
 164             l.append(self.valeur)
 165         elif type(self.valeur) in (list, tuple):
 166             for val in self.valeur:
 167                 if isinstance(val, ASSD):
 168                     l.append(val)
 169         return l
 170
 171     def getSd_mcs_utilisees(self):
 172         """
 173             Retourne la ou les SD utilisée par self sous forme d'un dictionnaire :
 174               - Si aucune sd n'est utilisée, le dictionnaire est vide.
 175               - Sinon, la clé du dictionnaire est le mot-clé simple ; la valeur est
 176                 la liste des sd attenante.
 177
 178                 Exemple ::
 179                         { 'VALE_F': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
 180                                       <Cata.cata.fonction_sdaster instance at 0x941a204> ] }
 181         """
 182         l = self.getSd_utilisees()
 183         dico = {}
 184         if len(l) > 0:
 185             dico[self.nom] = l
 186         return dico
 187
 188     def getMcsWithCo(self, co):
 189         """
 190             Cette methode retourne l'objet MCSIMP self s'il a le concept co
 191             comme valeur.
 192         """
 193         if co in forceList(self.valeur):
 194             return [self, ]
 195         return []
 196
 197     def getAllCo(self):
 198         """
 199             Cette methode retourne la liste de tous les concepts co
 200             associés au mot cle simple
 201         """
 202         return [co for co in forceList(self.valeur)
 203                 if isinstance(co, CO) and co.isTypCO()]