Noyau/N_MCSIMP.py

   1 #@ MODIF N_MCSIMP Noyau  DATE 30/08/2011   AUTEUR COURTOIS M.COURTOIS
   2 # -*- coding: iso-8859-1 -*-
   3 # RESPONSABLE COURTOIS M.COURTOIS
   4 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   5 # ======================================================================
   6 # COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
   7 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   8 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   9 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
  10 # (AT YOUR OPTION) ANY LATER VERSION.
  11 #
  12 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  13 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  14 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  15 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  16 #
  17 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  18 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  19 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  20 #
  21 #
  22 # ======================================================================
  23
  24
  25 """
  26     Ce module contient la classe MCSIMP qui sert a controler la valeur
  27     d'un mot-cle simple par rapport a sa definition portee par un objet
  28     de type ENTITE
  29 """
  30
  31 from copy import copy
  32
  33 from Noyau.N_ASSD import ASSD
  34 from Noyau.N_CO import CO
  35 import N_OBJECT
  36 from N_CONVERT import ConversionFactory
  37
  38 class MCSIMP(N_OBJECT.OBJECT):
  39    """
  40    """
  41    nature = 'MCSIMP'
  42    def __init__(self,val,definition,nom,parent):
  43       """
  44          Attributs :
  45           - val : valeur du mot cle simple
  46           - definition
  47           - nom
  48           - parent
  49         Autres attributs :
  50
  51           - valeur : valeur du mot-cle simple en tenant compte de la valeur par defaut
  52
  53       """
  54       self.definition=definition
  55       self.nom=nom
  56       self.val = val
  57       self.parent = parent
  58       self.convProto = ConversionFactory('type', typ=self.definition.type)
  59       self.valeur = self.GETVAL(self.val)
  60       if parent :
  61          self.jdc = self.parent.jdc
  62          self.niveau = self.parent.niveau
  63          self.etape = self.parent.etape
  64       else:
  65          # Le mot cle simple a ete cree sans parent
  66          self.jdc = None
  67          self.niveau = None
  68          self.etape = None
  69
  70    def GETVAL(self,val):
  71       """
  72           Retourne la valeur effective du mot-cle en fonction
  73           de la valeur donnee. Defaut si val == None
  74       """
  75       if (val is None and hasattr(self.definition,'defaut')) :
  76          val = self.definition.defaut
  77       if self.convProto:
  78          val = self.convProto.convert(val)
  79       return val
  80
  81    def get_valeur(self):
  82       """
  83           Retourne la "valeur" d'un mot-cle simple.
  84           Cette valeur est utilisee lors de la creation d'un contexte
  85           d'evaluation d'expressions a l'aide d'un interpreteur Python
  86       """
  87       v = self.valeur
  88       # Si singleton et max=1, on retourne la valeur.
  89       # Si une valeur simple et max='**', on retourne un singleton.
  90       # (si liste de longueur > 1 et max=1, on sera arrete plus tard)
  91       # Pour accepter les numpy.array, on remplace : "type(v) not in (list, tuple)"
  92       # par "not has_attr(v, '__iter__')".
  93       if v is None:
  94           pass
  95       elif type(v) in (list, tuple) and len(v) == 1 and self.definition.max == 1:
  96          v = v[0]
  97       elif not hasattr(v, '__iter__') and self.definition.max != 1:
  98           v = (v, )
  99       # traitement particulier pour les complexes ('RI', r, i)
 100       if 'C' in self.definition.type and self.definition.max != 1 \
 101         and v[0] in ('RI', 'MP'):
 102           v = (v, )
 103       return v
 104
 105    def get_val(self):
 106       """
 107           Une autre methode qui retourne une "autre" valeur du mot cle simple.
 108           Elle est utilisee par la methode get_mocle
 109       """
 110       return self.valeur
 111
 112    def accept(self,visitor):
 113       """
 114          Cette methode permet de parcourir l'arborescence des objets
 115          en utilisant le pattern VISITEUR
 116       """
 117       visitor.visitMCSIMP(self)
 118
 119    def copy(self):
 120       """ Retourne une copie de self """
 121       objet = self.makeobjet()
 122       # il faut copier les listes et les tuples mais pas les autres valeurs
 123       # possibles (reel,SD,...)
 124       if type(self.valeur) in (list, tuple):
 125          objet.valeur = copy(self.valeur)
 126       else:
 127          objet.valeur = self.valeur
 128       objet.val = objet.valeur
 129       return objet
 130
 131    def makeobjet(self):
 132       return self.definition(val = None, nom = self.nom,parent = self.parent)
 133
 134    def reparent(self,parent):
 135       """
 136          Cette methode sert a reinitialiser la parente de l'objet
 137       """
 138       self.parent=parent
 139       self.jdc=parent.jdc
 140       self.etape=parent.etape
 141
 142    def get_sd_utilisees(self):
 143       """
 144           Retourne une liste qui contient la ou les SD utilisee par self si c'est le cas
 145           ou alors une liste vide
 146       """
 147       l=[]
 148       if isinstance(self.valeur, ASSD):
 149          l.append(self.valeur)
 150       elif type(self.valeur) in (list, tuple):
 151         for val in self.valeur :
 152            if isinstance(val, ASSD):
 153               l.append(val)
 154       return l
 155
 156    def get_sd_mcs_utilisees(self):
 157       """
 158           Retourne la ou les SD utilisee par self sous forme d'un dictionnaire :
 159             - Si aucune sd n'est utilisee, le dictionnaire est vide.
 160             - Sinon, la cle du dictionnaire est le mot-cle simple ; la valeur est
 161               la liste des sd attenante.
 162
 163               Exemple ::
 164                       { 'VALE_F': [ <Cata.cata.para_sensi instance at 0x9419854>,
 165                                     <Cata.cata.para_sensi instance at 0x941a204> ] }
 166       """
 167       l=self.get_sd_utilisees()
 168       dico = {}
 169       if len(l) > 0 :
 170         dico[self.nom] = l
 171       return dico
 172
 173    def get_mcs_with_co(self,co):
 174       """
 175           Cette methode retourne l'objet MCSIMP self s'il a le concept co
 176           comme valeur.
 177       """
 178       lval=self.valeur
 179       if type(self.valeur) not in (list, tuple):
 180         lval=(self.valeur,)
 181       if co in lval:return [self,]
 182       return []
 183
 184    def get_all_co(self):
 185       """
 186           Cette methode retourne la liste de tous les concepts co
 187           associes au mot cle simple
 188       """
 189       lval=self.valeur
 190       if type(self.valeur) not in (list, tuple):
 191         lval=(self.valeur,)
 192       l=[]
 193       for c in lval:
 194         if isinstance(c,CO) or hasattr(c,"_etape"):l.append(c)
 195       return l