Noyau/N_MCSIMP.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     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             - definition
  49             - nom
  50             - parent
  51
  52           Autres attributs :
  53
  54             - valeur : valeur du mot-clé simple en tenant compte de la valeur par défaut
  55
  56         """
  57         #print (self, val, definition, nom, parent)
  58         self.definition = definition
  59         self.nom = nom
  60         self.val = val
  61         self.parent = parent
  62         self.objPyxbDeConstruction = objPyxbDeConstruction
  63         if parent:
  64             self.jdc = self.parent.jdc
  65             if self.jdc : self.cata = self.jdc.cata
  66             else        : self.cata = None
  67             self.niveau = self.parent.niveau
  68             self.etape  = self.parent.etape
  69         else:
  70             # Le mot cle simple a été créé sans parent
  71             # est-ce possible ?
  72             print ('je suis dans le else sans parent du build')
  73             print (poum)
  74             self.jdc    = None
  75             self.cata   = None
  76             self.niveau = None
  77             self.etape  = None
  78         if self.definition.creeDesObjets :
  79            self.convProto = ConversionFactory('UserASSD', self.definition.creeDesObjetsDeType)
  80         else :
  81            self.convProto = ConversionFactory('type', typ=self.definition.type)
  82         self.valeur = self.getValeurEffective(self.val)
  83         if self.definition.utiliseUneReference :
  84           if self.valeur != None:
  85              if not type(self.valeur) in (list, tuple): self.valeur.ajoutUtilisePar(self)
  86              else :
  87                #PNPN --> chgt pour Vimmp
  88                for v in self.valeur :
  89                    try : v.ajoutUtilisePar(self)
  90                    except : print ('il y a un souci ici', self.nom, self.valeur)
  91         self.buildObjPyxb()
  92         self.listeNomsObjsCrees = []
  93
  94     def getValeurEffective(self, val):
  95         """
  96             Retourne la valeur effective du mot-clé en fonction
  97             de la valeur donnée. Defaut si val == None
  98         """
  99         if (val is None and hasattr(self.definition, 'defaut')): val = self.definition.defaut
 100         if self.jdc != None and val in list(self.jdc.sdsDict.keys()): return self.jdc.sdsDict[val]
 101          # dans le cas de lecture de .comm, il est possible que l objet est deja ete cree
 102          # peut-etre devrait on aussi verifier que val est de type string ?
 103         if self.definition.creeDesObjets :
 104            # isinstance(val, self.definition.creeDesObjetsDeType) ne fonctionne pas car il y a un avec cata devant et l autre non
 105            if val != None :
 106              if  (not(val.__class__.__name__ == self.definition.creeDesObjetsDeType.__name__)) :
 107                  val=self.convProto.convert(val)
 108              else :
 109                  if val.nom=='sansNom' :
 110                     for leNom,laVariable in self.jdc.g_context.items():
 111                       if id(laVariable)== id(val) and (leNom != 'sansNom'):
 112                          val.initialiseNom(leNom)
 113                  if val.parent== None : val.initialiseParent(self)
 114            return val
 115         if self.convProto:
 116            val = self.convProto.convert(val)
 117         return val
 118
 119     def creeUserASSDetSetValeur(self, val):
 120         self.state='changed'
 121         nomVal=val
 122         if nomVal in self.jdc.sdsDict.keys():
 123            if isinstance(self.jdc.sdsDict[nomVal],self.definition.creeDesObjetsDeType): return (0, 'concept deja reference')
 124            else : return (0, 'concept d un autre type existe deja')
 125         if self.convProto:
 126             objVal = self.convProto.convert(nomVal)
 127             objVal.initialiseNom(nomVal)
 128             if objVal.parent== None : objVal.initialiseParent(self)
 129             p=self.parent
 130             while p in self.parent :
 131                   print ('mise a jour de ',p)
 132                   if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(objVal)
 133                   else : p.listeDesReferencesCrees=(objVal,)
 134                   p=p.parent
 135         return (self.setValeur(objVal), 'reference creee')
 136
 137     def creeUserASSD(self, val):
 138         self.state='changed'
 139         nomVal=val
 140         if nomVal in self.jdc.sdsDict.keys():
 141            if isinstance(self.jdc.sdsDict[nomVal],self.definition.creeDesObjetsDeType): return (0,None, 'concept deja reference')
 142            else : return (0, None, 'concept d un autre type existe deja')
 143         if self.convProto:
 144             objVal = self.convProto.convert(nomVal)
 145             objVal.initialiseNom(nomVal)
 146         return (1, objVal, 'reference creee')
 147
 148     def rattacheUserASSD(self, objASSD):
 149         if objASSD.parent== None : objASSD.initialiseParent(self)
 150         p=self.parent
 151         while p in self.parent :
 152            if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(objASSD)
 153            else : p.listeDesReferencesCrees=(objASSD,)
 154            p=p.parent
 155
 156
 157     def getValeur(self):
 158         """
 159             Retourne la "valeur" d'un mot-clé simple.
 160             Cette valeur est utilisée lors de la création d'un contexte
 161             d'évaluation d'expressions à l'aide d'un interpréteur Python
 162         """
 163         v = self.valeur
 164         # Si singleton et max=1, on retourne la valeur.
 165         # Si une valeur simple et max='**', on retourne un singleton.
 166         # (si liste de longueur > 1 et max=1, on sera arrêté plus tard)
 167         # Pour accepter les numpy.array, on remplace : "type(v) not in (list, tuple)"
 168         # par "not has_attr(v, '__iter__')".
 169         if v is None:
 170             pass
 171         elif isSequence(v) and len(v) == 1 and self.definition.max == 1:
 172             v = v[0]
 173         elif not isSequence(v) and self.definition.max != 1:
 174             v = (v, )
 175         # traitement particulier pour les complexes ('RI', r, i)
 176         if 'C' in self.definition.type and self.definition.max != 1 and v != None and v[0] in ('RI', 'MP'):
 177             v = (v, )
 178         return v
 179
 180     def getVal(self):
 181         """
 182             Une autre méthode qui retourne une "autre" valeur du mot clé simple.
 183             Elle est utilisée par la méthode getMocle
 184         """
 185         return self.valeur
 186
 187     def accept(self, visitor):
 188         """
 189            Cette methode permet de parcourir l'arborescence des objets
 190            en utilisant le pattern VISITEUR
 191         """
 192         visitor.visitMCSIMP(self)
 193
 194     def copy(self):
 195         """ Retourne une copie de self """
 196         objet = self.makeobjet()
 197         # il faut copier les listes et les tuples mais pas les autres valeurs
 198         # possibles (réel,SD,...)
 199         if type(self.valeur) in (list, tuple):
 200             objet.valeur = copy(self.valeur)
 201         else:
 202             objet.valeur = self.valeur
 203         objet.val = objet.valeur
 204         return objet
 205
 206     def makeobjet(self):
 207         return self.definition(val=None, nom=self.nom, parent=self.parent)
 208
 209     def reparent(self, parent):
 210         """
 211            Cette methode sert a reinitialiser la parente de l'objet
 212         """
 213         self.parent = parent
 214         self.jdc = parent.jdc
 215         self.etape = parent.etape
 216
 217     def getSd_utilisees(self):
 218         """
 219             Retourne une liste qui contient la ou les SD utilisée par self si c'est le cas
 220             ou alors une liste vide
 221         """
 222         l = []
 223         if isinstance(self.valeur, ASSD):
 224             l.append(self.valeur)
 225         elif type(self.valeur) in (list, tuple):
 226             for val in self.valeur:
 227                 if isinstance(val, ASSD):
 228                     l.append(val)
 229         return l
 230
 231     def getSd_mcs_utilisees(self):
 232         """
 233             Retourne la ou les SD utilisée par self sous forme d'un dictionnaire :
 234               - Si aucune sd n'est utilisée, le dictionnaire est vide.
 235               - Sinon, la clé du dictionnaire est le mot-clé simple ; la valeur est
 236                 la liste des sd attenante.
 237
 238                 Exemple ::
 239                         { 'VALE_F': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
 240                                       <Cata.cata.fonction_sdaster instance at 0x941a204> ] }
 241         """
 242         l = self.getSd_utilisees()
 243         dico = {}
 244         if len(l) > 0:
 245             dico[self.nom] = l
 246         return dico
 247
 248
 249     def getMcsWithCo(self, co):
 250         """
 251             Cette methode retourne l'objet MCSIMP self s'il a le concept co
 252             comme valeur.
 253         """
 254         if co in forceList(self.valeur):
 255             return [self, ]
 256         return []
 257
 258     def getAllCo(self):
 259         """
 260             Cette methode retourne la liste de tous les concepts co
 261             associés au mot cle simple
 262         """
 263         return [co for co in forceList(self.valeur)
 264                 if isinstance(co, CO) and co.isTypCO()]
 265
 266     def supprime(self):
 267         if hasattr(self, 'val') and hasattr(self.val, 'supprime') :self.val.supprime()
 268         N_OBJECT.OBJECT.supprime(self)