Noyau/N_MCSIMP.py

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