Ihm/I_MCSIMP.py

   1 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   2 # ======================================================================
   3 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   4 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   5 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   6 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   7 # (AT YOUR OPTION) ANY LATER VERSION.
   8 #
   9 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  10 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  11 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  12 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  13 #
  14 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  15 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  16 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  17 #
  18 #
  19 # ======================================================================
  20 import types,string
  21 import traceback
  22 from copy import copy
  23 from repr import Repr
  24 myrepr = Repr()
  25 myrepr.maxstring = 100
  26 myrepr.maxother = 100
  27
  28 from Noyau.N_utils import repr_float
  29
  30 # Attention : les classes ASSD,.... peuvent etre surchargées
  31 # dans le package Accas. Il faut donc prendre des précautions si
  32 # on utilise les classes du Noyau pour faire des tests (isxxxx, ...)
  33 # Si on veut créer des objets comme des CO avec les classes du noyau
  34 # ils n'auront pas les conportements des autres packages (pb!!!)
  35 # Il vaut mieux les importer d'Accas mais problème d'import circulaire,
  36 # on ne peut pas les importer au début.
  37 # On fait donc un import local quand c'est nécessaire (peut occasionner
  38 # des pbs de prformance).
  39 from Noyau.N_ASSD import ASSD,assd
  40 from Noyau.N_GEOM import GEOM,geom
  41 from Noyau.N_CO import CO
  42 # fin attention
  43
  44 from Extensions import parametre
  45 import I_OBJECT
  46
  47 class MCSIMP(I_OBJECT.OBJECT):
  48   def GetText(self):
  49     """
  50         Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
  51         pointé par self
  52     """
  53     if self.valeur == None :
  54       return None
  55     elif type(self.valeur) == types.FloatType :
  56       txt = repr_float(self.valeur)
  57     elif type(self.valeur) in (types.ListType,types.TupleType) :
  58       txt='('
  59       i=0
  60       for val in self.valeur:
  61         if type(val) == types.FloatType :
  62            txt=txt + i*',' + repr_float(val)
  63         elif type(val) == types.InstanceType and isinstance(val,ASSD):
  64            txt = txt + i*',' + val.get_name()
  65         else:
  66            txt = txt + i*','+ myrepr.repr(val)
  67         i=1
  68       txt=txt+')'
  69     else:
  70       txt = self.getval()
  71     if type(txt) != types.StringType:
  72       if type(txt) == types.InstanceType:
  73         if isinstance(txt,parametre.PARAMETRE):
  74           return str(txt)
  75       return repr(txt)
  76     # il faut tronquer txt au delà d'un certain nombre de caractères
  77     # et avant tout retour chariot (txt peut être une chaîne de caractères
  78     # sur plusieurs lignes (ex:shell)
  79     txt = string.split(txt,'\n')[0]
  80     if len(txt) < 30 :
  81       return txt
  82     else:
  83       return txt[0:29]
  84
  85   def getval(self):
  86     """
  87        Retourne une chaîne de caractère représentant la valeur de self
  88     """
  89     val=self.valeur
  90     if type(val) != types.TupleType :
  91       try:
  92         return val.get_name()
  93       except:
  94         return val
  95     else :
  96       s='( '
  97       for item in val :
  98         try :
  99           s=s+item.get_name()+','
 100         except:
 101           s=s+`item`+','
 102       s=s+' )'
 103       return s
 104
 105   def get_min_max(self):
 106     return self.definition.min,self.definition.max
 107
 108   def wait_co(self):
 109     """
 110         Méthode booléenne qui retourne 1 si l'objet attend un objet ASSD
 111         qui n'existe pas encore (type CO()), 0 sinon
 112     """
 113     for typ in self.definition.type:
 114       if type(typ) == types.ClassType :
 115         if issubclass(typ,CO) :
 116            return 1
 117     return 0
 118
 119   def wait_assd(self):
 120     """
 121         Méthode booléenne qui retourne 1 si le MCS attend un objet de type ASSD
 122         ou dérivé, 0 sinon
 123     """
 124     for typ in self.definition.type:
 125       if type(typ) == types.ClassType :
 126         if issubclass(typ,ASSD) and not issubclass(typ,GEOM):
 127           return 1
 128     return 0
 129
 130   def wait_assd_or_geom(self):
 131     """
 132          Retourne 1 si le mot-clé simple attend un objet de type
 133           assd, ASSD, geom ou GEOM
 134          Retourne 0 dans le cas contraire
 135     """
 136     for typ in self.definition.type:
 137       if type(typ) == types.ClassType :
 138         if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) :
 139           return 1
 140     return 0
 141
 142   def wait_geom(self):
 143     """
 144          Retourne 1 si le mot-clé simple attend un objet de type GEOM
 145          Retourne 0 dans le cas contraire
 146     """
 147     for typ in self.definition.type:
 148       if type(typ) == types.ClassType :
 149         if issubclass(typ,GEOM) : return 1
 150     return 0
 151
 152   def wait_TXM(self):
 153     """
 154          Retourne 1 si le mot-clé simple attend un objet de type TXM
 155          Retourne 0 dans le cas contraire
 156     """
 157     for typ in self.definition.type:
 158       if typ == 'TXM' :return 1
 159     return 0
 160
 161   def get_liste_valeurs(self):
 162     """
 163     """
 164     if self.valeur == None:
 165       return []
 166     elif type(self.valeur) == types.TupleType:
 167       return list(self.valeur)
 168     elif type(self.valeur) == types.ListType:
 169       return self.valeur
 170     else:
 171       return [self.valeur]
 172
 173   def isoblig(self):
 174     return self.definition.statut=='o'
 175
 176   def set_valeur(self,new_valeur,evaluation='oui'):
 177     """
 178         Remplace la valeur de self(si elle existe) par new_valeur
 179             - si evaluation = 'oui' :
 180                         essaie d'évaluer new_valeur dans le contexte
 181             - si evaluation = 'non' :
 182                         n'essaie pas d'évaluer (on stocke une string ou
 183                         une valeur de la liste into )
 184     """
 185     if evaluation == 'oui' and not self.wait_assd_or_geom():
 186       valeur,test = self.eval_valeur(new_valeur)
 187       if test :
 188         self.val = new_valeur
 189         self.valeur = valeur
 190         self.init_modif()
 191         return 1
 192       else:
 193         # On n'a pas trouve de concept ni réussi à évaluer la valeur
 194         # dans le contexte
 195         # Si le mot cle simple attend un type CO on crée un objet de ce
 196         # type de nom new_valeur
 197         if self.wait_co():
 198           try:
 199             # Pour avoir la classe CO avec tous ses comportements
 200             from Accas import CO
 201             self.valeur=CO(new_valeur)
 202           except:
 203             traceback.print_exc()
 204             return 0
 205           self.val=self.valeur
 206           self.init_modif()
 207           return 1
 208         elif type(new_valeur)==types.StringType and self.wait_TXM():
 209           self.val = new_valeur
 210           self.valeur = new_valeur
 211           self.init_modif()
 212           return 1
 213         else:
 214           return 0
 215     else :
 216       # on ne fait aucune vérification ...
 217       try:
 218         self.valeur = eval(new_valeur)
 219         self.val = eval(new_valeur)
 220         self.init_modif()
 221         return 1
 222       except:
 223         self.valeur = new_valeur
 224         self.val = new_valeur
 225         self.init_modif()
 226         return 1
 227
 228   def eval_valeur(self,new_valeur):
 229     """
 230         Essaie d'évaluer new_valeur comme une SD, une déclaration Python
 231         ou un EVAL:
 232            Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
 233     """
 234     #sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
 235     sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
 236     if sd :
 237       return sd,1
 238     else:
 239       d={}
 240       # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
 241       from Accas import EVAL
 242       d['EVAL']=EVAL
 243       try :
 244         objet = eval(new_valeur,d)
 245         return objet,1
 246       except Exception:
 247         if CONTEXT.debug : traceback.print_exc()
 248         return None,0
 249
 250   def delete_concept(self,sd):
 251     """
 252         Inputs :
 253            sd=concept detruit
 254         Fonction :
 255            Met a jour la valeur du mot cle simple suite à la disparition
 256            du concept sd
 257     """
 258     if type(self.valeur) == types.TupleType :
 259       if sd in self.valeur:
 260         self.valeur=list(self.valeur)
 261         self.valeur.remove(sd)
 262         self.init_modif()
 263     elif type(self.valeur) == types.ListType:
 264       if sd in self.valeur:
 265         self.valeur.remove(sd)
 266         self.init_modif()
 267     else:
 268       if self.valeur == sd:
 269         self.valeur=None
 270         self.val=None
 271         self.init_modif()
 272
 273   def copy(self):
 274     """ Retourne une copie de self """
 275     objet = self.makeobjet()
 276     # il faut copier les listes et les tuples mais pas les autres valeurs
 277     # possibles (réel,SD,...)
 278     if type(self.valeur) in (types.ListType,types.TupleType):
 279        objet.valeur = copy(self.valeur)
 280     else:
 281        objet.valeur = self.valeur
 282     objet.val = objet.valeur
 283     return objet
 284
 285   def makeobjet(self):
 286     return self.definition(val = None, nom = self.nom,parent = self.parent)
 287
 288   def get_sd_utilisees(self):
 289     """
 290         Retourne une liste qui contient la SD utilisée par self si c'est le cas
 291         ou alors une liste vide
 292     """
 293     l=[]
 294     if type(self.valeur) == types.InstanceType:
 295       #XXX Est ce différent de isinstance(self.valeur,ASSD) ??
 296       if issubclass(self.valeur.__class__,ASSD) : l.append(self.valeur)
 297     return l
 298
 299
 300   def set_valeur_co(self,nom_co):
 301       """
 302           Affecte à self l'objet de type CO et de nom nom_co
 303       """
 304       step=self.etape.parent
 305       if nom_co == None or nom_co == '':
 306          new_objet=None
 307       else:
 308          # Pour le moment on importe en local le CO de Accas.
 309          # Si problème de perfs, il faudra faire autrement
 310          from Accas import CO
 311          # Avant de créer un concept il faut s'assurer du contexte : step
 312          # courant
 313          sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui')
 314          if sd:
 315             # Si un concept du meme nom existe deja dans la portée de l'étape
 316             # on ne crée pas le concept
 317             return 0,"un concept de meme nom existe deja"
 318          # Il n'existe pas de concept de meme nom. On peut donc le créer
 319          # Il faut néanmoins que la méthode NommerSdProd de step gère les
 320          # contextes en mode editeur
 321          # Normalement la méthode  du Noyau doit etre surchargée
 322          # On déclare l'étape du mot clé comme etape courante pour NommerSdprod
 323          cs= CONTEXT.get_current_step()
 324          CONTEXT.unset_current_step()
 325          CONTEXT.set_current_step(step)
 326          step.set_etape_context(self.etape)
 327          new_objet = CO(nom_co)
 328          CONTEXT.unset_current_step()
 329          CONTEXT.set_current_step(cs)
 330       self.valeur = new_objet
 331       self.val = new_objet
 332       self.init_modif()
 333       step.reset_context()
 334       # On force l'enregistrement de new_objet en tant que concept produit
 335       # de la macro en appelant get_type_produit avec force=1
 336       self.etape.get_type_produit(force=1)
 337       return 1,"Concept créé"
 338
 339   def reparent(self,parent):
 340      """
 341          Cette methode sert a reinitialiser la parente de l'objet
 342      """
 343      self.parent=parent
 344      self.jdc=parent.jdc
 345      self.etape=parent.etape
 346
 347   def verif_existence_sd(self):
 348      """
 349         Vérifie que les structures de données utilisées dans self existent bien dans le contexte
 350         avant étape, sinon enlève la référence à ces concepts
 351      """
 352      l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values()
 353      if type(self.valeur) in (types.TupleType,types.ListType) :
 354        l=[]
 355        for sd in self.valeur:
 356          if isinstance(sd,ASSD) :
 357             if sd in l_sd_avant_etape :
 358                l.append(sd)
 359          else:
 360             l.append(sd)
 361        self.valeur=l
 362        self.init_modif()
 363      else:
 364        if isinstance(self.valeur,ASSD) :
 365           if self.valeur not in l_sd_avant_etape :
 366              self.valeur = None
 367              self.init_modif()
 368
 369
 370   def get_min_max(self):
 371      """
 372      Retourne les valeurs min et max admissibles pour la valeur de self
 373      """
 374      return self.definition.min,self.definition.max
 375
 376
 377   def get_type(self):
 378      """
 379      Retourne le type attendu par le mot-clé simple
 380      """
 381      return self.definition.type
 382
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393
 394
 395