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       # Normalement str fait un travail correct
  58       txt = str(self.valeur)
  59     elif type(self.valeur) in (types.ListType,types.TupleType) :
  60       txt='('
  61       i=0
  62       for val in self.valeur:
  63         if type(val) == types.FloatType :
  64            # Normalement str fait un travail correct
  65            #txt=txt + i*',' + repr_float(val)
  66            txt=txt + i*',' + str(val)
  67         elif type(val) == types.InstanceType and isinstance(val,ASSD):
  68            txt = txt + i*',' + val.get_name()
  69         else:
  70            txt = txt + i*','+ myrepr.repr(val)
  71         i=1
  72       txt=txt+')'
  73     else:
  74       txt = self.getval()
  75     if type(txt) != types.StringType:
  76       if type(txt) == types.InstanceType:
  77         if isinstance(txt,parametre.PARAMETRE):
  78           return str(txt)
  79       return repr(txt)
  80     # txt peut etre une longue chaine sur plusieurs lignes.
  81     # Il est possible de tronquer cette chaine au premier \n et
  82     # de limiter la longueur de la chaine a 30 caracteres. Cependant
  83     # ceci provoque une perte d'information pour l'utilisateur
  84     # Pour le moment on retourne la chaine telle que
  85     return txt
  86
  87     # Partie de code inaccessible (pour memoire)
  88     # txt est tronquee au dela d'un certain nombre de caractères
  89     # et avant tout retour chariot (txt peut etre une chaine de caractères
  90     # sur plusieurs lignes (ex:shell)
  91     txt = string.split(txt,'\n')[0]
  92     if len(txt) < 30 :
  93       return txt
  94     else:
  95       return txt[0:29]
  96
  97   def getval(self):
  98     """
  99        Retourne une chaîne de caractère représentant la valeur de self
 100     """
 101     val=self.valeur
 102     if type(val) != types.TupleType :
 103       try:
 104         return val.get_name()
 105       except:
 106         return val
 107     else :
 108       s='( '
 109       for item in val :
 110         try :
 111           s=s+item.get_name()+','
 112         except:
 113           s=s+`item`+','
 114       s=s+' )'
 115       return s
 116
 117   def get_min_max(self):
 118     return self.definition.min,self.definition.max
 119
 120   def wait_co(self):
 121     """
 122         Méthode booléenne qui retourne 1 si l'objet attend un objet ASSD
 123         qui n'existe pas encore (type CO()), 0 sinon
 124     """
 125     for typ in self.definition.type:
 126       if type(typ) == types.ClassType :
 127         if issubclass(typ,CO) :
 128            return 1
 129     return 0
 130
 131   def wait_assd(self):
 132     """
 133         Méthode booléenne qui retourne 1 si le MCS attend un objet de type ASSD
 134         ou dérivé, 0 sinon
 135     """
 136     for typ in self.definition.type:
 137       if type(typ) == types.ClassType :
 138         if issubclass(typ,ASSD) and not issubclass(typ,GEOM):
 139           return 1
 140     return 0
 141
 142   def wait_assd_or_geom(self):
 143     """
 144          Retourne 1 si le mot-clé simple attend un objet de type
 145           assd, ASSD, geom ou GEOM
 146          Retourne 0 dans le cas contraire
 147     """
 148     for typ in self.definition.type:
 149       if type(typ) == types.ClassType :
 150         if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) :
 151           return 1
 152     return 0
 153
 154   def wait_geom(self):
 155     """
 156          Retourne 1 si le mot-clé simple attend un objet de type GEOM
 157          Retourne 0 dans le cas contraire
 158     """
 159     for typ in self.definition.type:
 160       if type(typ) == types.ClassType :
 161         if issubclass(typ,GEOM) : return 1
 162     return 0
 163
 164   def wait_TXM(self):
 165     """
 166          Retourne 1 si le mot-clé simple attend un objet de type TXM
 167          Retourne 0 dans le cas contraire
 168     """
 169     for typ in self.definition.type:
 170       if typ == 'TXM' :return 1
 171     return 0
 172
 173   def get_liste_valeurs(self):
 174     """
 175     """
 176     if self.valeur == None:
 177       return []
 178     elif type(self.valeur) == types.TupleType:
 179       return list(self.valeur)
 180     elif type(self.valeur) == types.ListType:
 181       return self.valeur
 182     else:
 183       return [self.valeur]
 184
 185   def isoblig(self):
 186     return self.definition.statut=='o'
 187
 188   def set_valeur(self,new_valeur,evaluation='oui'):
 189     """
 190         Remplace la valeur de self(si elle existe) par new_valeur
 191             - si evaluation = 'oui' :
 192                         essaie d'évaluer new_valeur dans le contexte
 193             - si evaluation = 'non' :
 194                         n'essaie pas d'évaluer (on stocke une string ou
 195                         une valeur de la liste into )
 196     """
 197     if evaluation == 'oui' and not self.wait_assd_or_geom():
 198       valeur,test = self.eval_valeur(new_valeur)
 199       if test :
 200         self.val = new_valeur
 201         self.valeur = valeur
 202         self.init_modif()
 203         self.fin_modif()
 204         return 1
 205       else:
 206         # On n'a pas trouve de concept ni réussi à évaluer la valeur
 207         # dans le contexte
 208         # Si le mot cle simple attend un type CO on crée un objet de ce
 209         # type de nom new_valeur
 210         if self.wait_co():
 211           try:
 212             # Pour avoir la classe CO avec tous ses comportements
 213             from Accas import CO
 214             self.valeur=CO(new_valeur)
 215           except:
 216             traceback.print_exc()
 217             return 0
 218           self.init_modif()
 219           self.val=self.valeur
 220           self.fin_modif()
 221           return 1
 222         elif type(new_valeur)==types.StringType and self.wait_TXM():
 223           self.init_modif()
 224           self.val = new_valeur
 225           self.valeur = new_valeur
 226           self.fin_modif()
 227           return 1
 228         else:
 229           return 0
 230     else :
 231       # on ne fait aucune vérification ...
 232       self.init_modif()
 233       try:
 234         self.valeur = eval(new_valeur)
 235         self.val = eval(new_valeur)
 236         self.fin_modif()
 237         return 1
 238       except:
 239         self.valeur = new_valeur
 240         self.val = new_valeur
 241         self.fin_modif()
 242         return 1
 243
 244   def eval_valeur(self,new_valeur):
 245     """
 246         Essaie d'évaluer new_valeur comme une SD, une déclaration Python
 247         ou un EVAL:
 248            Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
 249     """
 250     #sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
 251     sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
 252     if sd :
 253       return sd,1
 254     else:
 255       d={}
 256       # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
 257       from Accas import EVAL
 258       d['EVAL']=EVAL
 259       try :
 260         objet = eval(new_valeur,d)
 261         return objet,1
 262       except Exception:
 263 # PN :
 264 #    - Ajout de quote autour de la valeur en cas de chaine de caracteres
 265         if type(new_valeur)==types.StringType and self.wait_TXM():
 266             new_valeur="'"+new_valeur+"'"
 267             try :
 268                 objet = eval(new_valeur,d)
 269                 return objet,1
 270             except :
 271                 return None,0
 272         if CONTEXT.debug : traceback.print_exc()
 273         return None,0
 274
 275   def delete_concept(self,sd):
 276     """
 277         Inputs :
 278            sd=concept detruit
 279         Fonction :
 280            Met a jour la valeur du mot cle simple suite à la disparition
 281            du concept sd
 282     """
 283     if type(self.valeur) == types.TupleType :
 284       if sd in self.valeur:
 285         self.valeur=list(self.valeur)
 286         self.valeur.remove(sd)
 287         self.init_modif()
 288     elif type(self.valeur) == types.ListType:
 289       if sd in self.valeur:
 290         self.valeur.remove(sd)
 291         self.init_modif()
 292     else:
 293       if self.valeur == sd:
 294         self.valeur=None
 295         self.val=None
 296         self.init_modif()
 297
 298   def replace_concept(self,old_sd,sd):
 299     """
 300         Inputs :
 301            old_sd=concept remplacé
 302            sd=nouveau concept
 303         Fonction :
 304            Met a jour la valeur du mot cle simple suite au remplacement
 305            du concept old_sd
 306     """
 307     if type(self.valeur) == types.TupleType :
 308       if old_sd in self.valeur:
 309         self.valeur=list(self.valeur)
 310         i=self.valeur.index(old_sd)
 311         self.valeur[i]=sd
 312         self.init_modif()
 313     elif type(self.valeur) == types.ListType:
 314       if old_sd in self.valeur:
 315         i=self.valeur.index(old_sd)
 316         self.valeur[i]=sd
 317         self.init_modif()
 318     else:
 319       if self.valeur == old_sd:
 320         self.valeur=sd
 321         self.val=sd
 322         self.init_modif()
 323
 324   def copy(self):
 325     """ Retourne une copie de self """
 326     objet = self.makeobjet()
 327     # il faut copier les listes et les tuples mais pas les autres valeurs
 328     # possibles (réel,SD,...)
 329     if type(self.valeur) in (types.ListType,types.TupleType):
 330        objet.valeur = copy(self.valeur)
 331     else:
 332        objet.valeur = self.valeur
 333     objet.val = objet.valeur
 334     return objet
 335
 336   def makeobjet(self):
 337     return self.definition(val = None, nom = self.nom,parent = self.parent)
 338
 339   def get_sd_utilisees(self):
 340     """
 341         Retourne une liste qui contient la SD utilisée par self si c'est le cas
 342         ou alors une liste vide
 343     """
 344     l=[]
 345     if type(self.valeur) == types.InstanceType:
 346       #XXX Est ce différent de isinstance(self.valeur,ASSD) ??
 347       if issubclass(self.valeur.__class__,ASSD) : l.append(self.valeur)
 348     return l
 349
 350
 351   def set_valeur_co(self,nom_co):
 352       """
 353           Affecte à self l'objet de type CO et de nom nom_co
 354       """
 355       step=self.etape.parent
 356       if nom_co == None or nom_co == '':
 357          new_objet=None
 358       else:
 359          # Pour le moment on importe en local le CO de Accas.
 360          # Si problème de perfs, il faudra faire autrement
 361          from Accas import CO
 362          # Avant de créer un concept il faut s'assurer du contexte : step
 363          # courant
 364          sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui')
 365          if sd:
 366             # Si un concept du meme nom existe deja dans la portée de l'étape
 367             # on ne crée pas le concept
 368             return 0,"un concept de meme nom existe deja"
 369          # Il n'existe pas de concept de meme nom. On peut donc le créer
 370          # Il faut néanmoins que la méthode NommerSdProd de step gère les
 371          # contextes en mode editeur
 372          # Normalement la méthode  du Noyau doit etre surchargée
 373          # On déclare l'étape du mot clé comme etape courante pour NommerSdprod
 374          cs= CONTEXT.get_current_step()
 375          CONTEXT.unset_current_step()
 376          CONTEXT.set_current_step(step)
 377          step.set_etape_context(self.etape)
 378          new_objet = CO(nom_co)
 379          CONTEXT.unset_current_step()
 380          CONTEXT.set_current_step(cs)
 381       self.init_modif()
 382       self.valeur = new_objet
 383       self.val = new_objet
 384       self.fin_modif()
 385       step.reset_context()
 386       # On force l'enregistrement de new_objet en tant que concept produit
 387       # de la macro en appelant get_type_produit avec force=1
 388       self.etape.get_type_produit(force=1)
 389       return 1,"Concept créé"
 390
 391   def reparent(self,parent):
 392      """
 393          Cette methode sert a reinitialiser la parente de l'objet
 394      """
 395      self.parent=parent
 396      self.jdc=parent.jdc
 397      self.etape=parent.etape
 398
 399   def verif_existence_sd(self):
 400      """
 401         Vérifie que les structures de données utilisées dans self existent bien dans le contexte
 402         avant étape, sinon enlève la référence à ces concepts
 403      """
 404      l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values()
 405      if type(self.valeur) in (types.TupleType,types.ListType) :
 406        l=[]
 407        for sd in self.valeur:
 408          if isinstance(sd,ASSD) :
 409             if sd in l_sd_avant_etape :
 410                l.append(sd)
 411          else:
 412             l.append(sd)
 413        self.valeur=l
 414        # Est ce init_modif ou init_modif_up
 415        # Normalement init_modif va avec fin_modif
 416        self.init_modif()
 417        self.fin_modif()
 418      else:
 419        if isinstance(self.valeur,ASSD) :
 420           if self.valeur not in l_sd_avant_etape :
 421              self.valeur = None
 422              self.init_modif()
 423              self.fin_modif()
 424
 425   def get_min_max(self):
 426      """
 427      Retourne les valeurs min et max admissibles pour la valeur de self
 428      """
 429      return self.definition.min,self.definition.max
 430
 431
 432   def get_type(self):
 433      """
 434      Retourne le type attendu par le mot-clé simple
 435      """
 436      return self.definition.type
 437
 438 #ATTENTION : toutes les methodes ci apres sont des surcharges du Noyau et de Validation
 439 # Elles doivent etre reintegrees des que possible
 440
 441   def isvalid(self,cr='non'):
 442       """
 443          Cette méthode retourne un indicateur de validité de l'objet
 444          de type MCSIMP
 445
 446          - 0 si l'objet est invalide
 447
 448          - 1 si l'objet est valide
 449
 450          Le paramètre cr permet de paramétrer le traitement.
 451          Si cr == 'oui'
 452              la méthode construit également un comte-rendu de validation
 453              dans self.cr qui doit avoir été créé préalablement.
 454       """
 455       if self.state == 'unchanged':
 456         return self.valid
 457       else:
 458         valid = 1
 459         if hasattr(self,'valid'):
 460           old_valid = self.valid
 461         else:
 462           old_valid = None
 463         v=self.valeur
 464         #  presence
 465         if self.isoblig() and v == None :
 466           if cr == 'oui' :
 467             self.cr.fatal(string.join(("Mot-clé : ",self.nom," obligatoire non valorisé")))
 468           valid = 0
 469         # type,into ...
 470         valid = self.verif_type(cr=cr)*self.verif_into(cr=cr)*self.verif_card(cr=cr)
 471         self.valid = valid
 472         self.state = 'unchanged'
 473         # Si la validité du mot clé a changé, on le signale à l'objet parent
 474         if not old_valid:
 475           self.init_modif_up()
 476         elif old_valid != self.valid :
 477           self.init_modif_up()
 478         return self.valid
 479
 480
 481
 482
 483
 484
 485
 486
 487
 488
 489
 490
 491
 492