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