Ihm/I_MCSIMP.py

   1 # -*- coding: utf-8 -*-
   2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   8 # (AT YOUR OPTION) ANY LATER VERSION.
   9 #
  10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  14 #
  15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  17 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  18 #
  19 #
  20 # ======================================================================
  21 import types,string
  22 import traceback
  23 from copy import copy
  24 from repr import Repr
  25 myrepr = Repr()
  26 myrepr.maxstring = 100
  27 myrepr.maxother = 100
  28
  29 from Noyau.N_utils import repr_float
  30
  31 # Attention : les classes ASSD,.... peuvent etre surchargées
  32 # dans le package Accas. Il faut donc prendre des précautions si
  33 # on utilise les classes du Noyau pour faire des tests (isxxxx, ...)
  34 # Si on veut créer des objets comme des CO avec les classes du noyau
  35 # ils n'auront pas les conportements des autres packages (pb!!!)
  36 # Il vaut mieux les importer d'Accas mais problème d'import circulaire,
  37 # on ne peut pas les importer au début.
  38 # On fait donc un import local quand c'est nécessaire (peut occasionner
  39 # des pbs de prformance).
  40 from Noyau.N_ASSD import ASSD,assd
  41 from Noyau.N_GEOM import GEOM,geom
  42 from Noyau.N_CO import CO
  43 # fin attention
  44
  45 from Extensions import parametre
  46 import I_OBJECT
  47
  48 class MCSIMP(I_OBJECT.OBJECT):
  49   def GetText(self):
  50     """
  51         Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
  52         pointé par self
  53     """
  54     if self.valeur == None :
  55       return None
  56     elif type(self.valeur) == types.FloatType :
  57       # Traitement d'un flottant isolé
  58       #txt = repr_float(self.valeur)
  59       # Normalement str fait un travail correct
  60       txt = str(self.valeur)
  61     elif type(self.valeur) in (types.ListType,types.TupleType) :
  62       # Traitement des listes
  63       txt='('
  64       i=0
  65       for val in self.valeur:
  66         if type(val) == types.FloatType :
  67            # CCAR : Normalement str fait un travail correct
  68            #txt=txt + i*',' + repr_float(val)
  69            txt=txt + i*',' + str(val)
  70         elif isinstance(val,ASSD):
  71            txt = txt + i*',' + val.get_name()
  72     #PN
  73     # ajout du elif
  74         elif type(val) == types.InstanceType and val.__class__.__name__ in  ('PARAMETRE','PARAMETRE_EVAL'):
  75            txt = txt + i*','+ str(val)
  76         else:
  77            txt = txt + i*','+ myrepr.repr(val)
  78         i=1
  79       txt=txt+')'
  80     elif isinstance(self.valeur,ASSD):
  81       # Cas des ASSD
  82       txt=self.getval()
  83     elif type(self.valeur) == types.InstanceType and self.valeur.__class__.__name__ in  ('PARAMETRE','PARAMETRE_EVAL'):
  84       # Cas des PARAMETRES
  85       txt=str(self.valeur)
  86     else:
  87       # Traitement des autres cas
  88       txt = myrepr.repr(self.valeur)
  89
  90     # txt peut etre une longue chaine sur plusieurs lignes.
  91     # Il est possible de tronquer cette chaine au premier \n et
  92     # de limiter la longueur de la chaine a 30 caracteres. Cependant
  93     # ceci provoque une perte d'information pour l'utilisateur
  94     # Pour le moment on retourne la chaine telle que
  95     return txt
  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 wait_co(self):
 118     """
 119         Méthode booléenne qui retourne 1 si l'objet attend un objet ASSD
 120         qui n'existe pas encore (type CO()), 0 sinon
 121     """
 122     for typ in self.definition.type:
 123       if type(typ) == types.ClassType :
 124         if issubclass(typ,CO) :
 125            return 1
 126     return 0
 127
 128   def wait_assd(self):
 129     """
 130         Méthode booléenne qui retourne 1 si le MCS attend un objet de type ASSD
 131         ou dérivé, 0 sinon
 132     """
 133     for typ in self.definition.type:
 134       if type(typ) == types.ClassType :
 135         if issubclass(typ,ASSD) and not issubclass(typ,GEOM):
 136           return 1
 137     return 0
 138
 139   def wait_assd_or_geom(self):
 140     """
 141          Retourne 1 si le mot-clé simple attend un objet de type
 142          assd, ASSD, geom ou GEOM
 143          Retourne 0 dans le cas contraire
 144     """
 145     for typ in self.definition.type:
 146       if type(typ) == types.ClassType :
 147         if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) :
 148           return 1
 149     return 0
 150
 151   def wait_geom(self):
 152     """
 153          Retourne 1 si le mot-clé simple attend un objet de type GEOM
 154          Retourne 0 dans le cas contraire
 155     """
 156     for typ in self.definition.type:
 157       if type(typ) == types.ClassType :
 158         if issubclass(typ,GEOM) : return 1
 159     return 0
 160
 161   def wait_TXM(self):
 162     """
 163          Retourne 1 si le mot-clé simple attend un objet de type TXM
 164          Retourne 0 dans le cas contraire
 165     """
 166     for typ in self.definition.type:
 167       if typ == 'TXM' :return 1
 168     return 0
 169
 170   def get_liste_valeurs(self):
 171     """
 172     """
 173     if self.valeur == None:
 174       return []
 175     elif type(self.valeur) == types.TupleType:
 176       return list(self.valeur)
 177     elif type(self.valeur) == types.ListType:
 178       return self.valeur
 179     else:
 180       return [self.valeur]
 181
 182   def isoblig(self):
 183     return self.definition.statut=='o'
 184
 185   def set_valeur(self,new_valeur,evaluation='oui'):
 186         self.init_modif()
 187         self.valeur = new_valeur
 188         self.val = new_valeur
 189         self.fin_modif()
 190         return 1
 191
 192   def eval_valeur(self,new_valeur):
 193     """
 194         Essaie d'évaluer new_valeur comme une SD, une déclaration Python
 195         ou un EVAL: Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
 196     """
 197     sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
 198     if sd :
 199       return sd,1
 200     else:
 201       d={}
 202       # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
 203       from Accas import EVAL
 204       d['EVAL']=EVAL
 205       try :
 206         objet = eval(new_valeur,d)
 207         return objet,1
 208       except Exception:
 209         itparam=self.cherche_item_parametre(new_valeur)
 210         if itparam:
 211              return itparam,1
 212         if CONTEXT.debug : traceback.print_exc()
 213         return None,0
 214
 215   def cherche_item_parametre (self,new_valeur):
 216         try:
 217           nomparam=new_valeur[0:new_valeur.find("[")]
 218           indice=new_valeur[new_valeur.find("[")+1:new_valeur.find("]")]
 219           for p in self.jdc.params:
 220              if p.nom == nomparam :
 221                 if int(indice) < len(p.get_valeurs()):
 222                    itparam=parametre.ITEM_PARAMETRE(p,int(indice))
 223                    return itparam
 224           return None
 225         except:
 226           return None
 227
 228
 229   def delete_concept(self,sd):
 230     """
 231         Inputs :
 232            - sd=concept detruit
 233         Fonction :
 234         Met a jour la valeur du mot cle simple suite à la disparition
 235         du concept sd
 236     """
 237     if type(self.valeur) == types.TupleType :
 238       if sd in self.valeur:
 239         self.valeur=list(self.valeur)
 240         self.valeur.remove(sd)
 241         self.init_modif()
 242     elif type(self.valeur) == types.ListType:
 243       if sd in self.valeur:
 244         self.valeur.remove(sd)
 245         self.init_modif()
 246     else:
 247       if self.valeur == sd:
 248         self.valeur=None
 249         self.val=None
 250         self.init_modif()
 251
 252   def replace_concept(self,old_sd,sd):
 253     """
 254         Inputs :
 255            - old_sd=concept remplacé
 256            - sd=nouveau concept
 257         Fonction :
 258         Met a jour la valeur du mot cle simple suite au remplacement
 259         du concept old_sd
 260     """
 261     if type(self.valeur) == types.TupleType :
 262       if old_sd in self.valeur:
 263         self.valeur=list(self.valeur)
 264         i=self.valeur.index(old_sd)
 265         self.valeur[i]=sd
 266         self.init_modif()
 267     elif type(self.valeur) == types.ListType:
 268       if old_sd in self.valeur:
 269         i=self.valeur.index(old_sd)
 270         self.valeur[i]=sd
 271         self.init_modif()
 272     else:
 273       if self.valeur == old_sd:
 274         self.valeur=sd
 275         self.val=sd
 276         self.init_modif()
 277
 278   def set_valeur_co(self,nom_co):
 279       """
 280           Affecte à self l'objet de type CO et de nom nom_co
 281       """
 282       step=self.etape.parent
 283       if nom_co == None or nom_co == '':
 284          new_objet=None
 285       else:
 286          # Pour le moment on importe en local le CO de Accas.
 287          # Si problème de perfs, il faudra faire autrement
 288          from Accas import CO
 289          # Avant de créer un concept il faut s'assurer du contexte : step
 290          # courant
 291          sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui')
 292          if sd:
 293             # Si un concept du meme nom existe deja dans la portée de l'étape
 294             # on ne crée pas le concept
 295             return 0,"un concept de meme nom existe deja"
 296          # Il n'existe pas de concept de meme nom. On peut donc le créer
 297          # Il faut néanmoins que la méthode NommerSdProd de step gère les
 298          # contextes en mode editeur
 299          # Normalement la méthode  du Noyau doit etre surchargée
 300          # On déclare l'étape du mot clé comme etape courante pour NommerSdprod
 301          cs= CONTEXT.get_current_step()
 302          CONTEXT.unset_current_step()
 303          CONTEXT.set_current_step(step)
 304          step.set_etape_context(self.etape)
 305          new_objet = CO(nom_co)
 306          CONTEXT.unset_current_step()
 307          CONTEXT.set_current_step(cs)
 308       self.init_modif()
 309       self.valeur = new_objet
 310       self.val = new_objet
 311       self.fin_modif()
 312       step.reset_context()
 313       # On force l'enregistrement de new_objet en tant que concept produit
 314       # de la macro en appelant get_type_produit avec force=1
 315       self.etape.get_type_produit(force=1)
 316       return 1,"Concept créé"
 317
 318   def verif_existence_sd(self):
 319      """
 320         Vérifie que les structures de données utilisées dans self existent bien dans le contexte
 321         avant étape, sinon enlève la référence à ces concepts
 322      """
 323      l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values()
 324      if type(self.valeur) in (types.TupleType,types.ListType) :
 325        l=[]
 326        for sd in self.valeur:
 327          if isinstance(sd,ASSD) :
 328             if sd in l_sd_avant_etape :
 329                l.append(sd)
 330          else:
 331             l.append(sd)
 332        self.valeur=tuple(l)
 333        # Est ce init_modif ou init_modif_up
 334        # Normalement init_modif va avec fin_modif
 335        self.init_modif()
 336        self.fin_modif()
 337      else:
 338        if isinstance(self.valeur,ASSD) :
 339           if self.valeur not in l_sd_avant_etape :
 340              self.valeur = None
 341              self.init_modif()
 342              self.fin_modif()
 343
 344   def get_min_max(self):
 345      """
 346      Retourne les valeurs min et max admissibles pour la valeur de self
 347      """
 348      return self.definition.min,self.definition.max
 349
 350
 351   def get_type(self):
 352      """
 353      Retourne le type attendu par le mot-clé simple
 354      """
 355      return self.definition.type
 356
 357 #--------------------------------------------------------------------------------
 358 # PN : ajout pour Salome des methodes suivantes (jusqu aux méthodes surchargees)
 359 #--------------------------------------------------------------------------------
 360   def get_salome_valeurs(self):
 361        l=[]
 362        if not hasattr(self,'list_salome_valeurs'):
 363            self.list_salome_valeurs=[]
 364        if self.list_salome_valeurs != [] :
 365            for val in self.list_salome_valeurs:
 366                 l.append(val)
 367        return l
 368
 369   def put_salome_valeurs(self,list):
 370        self.list_salome_valeurs=[]
 371        for val in list:
 372            self.list_salome_valeurs.append(val)
 373
 374   def add_salome_valeurs(self,val):
 375       if not hasattr(self,'list_salome_valeurs'):
 376            self.list_salome_valeurs=[]
 377       try:
 378            self.list_salome_valeurs.append(val)
 379       except :
 380            try:
 381               for uneval in val :
 382                   self.list_salome_valeurs.append(uneval)
 383            except :
 384               pass
 385
 386   def has_salome_valeurs(self):
 387       if not hasattr(self,'list_salome_valeurs'):
 388            self.list_salome_valeurs=[]
 389       if self.list_salome_valeurs != []:
 390            return true
 391       else:
 392            return false
 393
 394 #--------------------------------------------------------------------------------
 395 # PN : fin ajout pour Salome
 396 #--------------------------------------------------------------------------------
 397
 398 #ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation
 399 # Elles doivent etre reintegrees des que possible
 400
 401
 402   def isvalid(self,cr='non'):
 403       """
 404          Cette méthode retourne un indicateur de validité de l'objet de type MCSIMP
 405
 406            - 0 si l'objet est invalide
 407            - 1 si l'objet est valide
 408
 409          Le paramètre cr permet de paramétrer le traitement. Si cr == 'oui'
 410          la méthode construit également un comte-rendu de validation
 411          dans self.cr qui doit avoir été créé préalablement.
 412       """
 413       if self.state == 'unchanged':
 414         return self.valid
 415       else:
 416         valid = 1
 417         v=self.valeur
 418         #  verification presence
 419         if self.isoblig() and v == None :
 420           if cr == 'oui' :
 421             self.cr.fatal(string.join(("Mot-clé : ",self.nom," obligatoire non valorisé")))
 422           valid = 0
 423
 424         if v is None:
 425            valid=0
 426            if cr == 'oui' :
 427               self.cr.fatal("None n'est pas une valeur autorisée")
 428         else:
 429            # type,into ...
 430            if v.__class__.__name__=='PARAMETRE' or v.__class__.__name__ == 'ITEM_PARAMETRE':
 431               verif_type=1
 432            else:
 433               verif_type=self.verif_type(val=v,cr=None)
 434               # cas des tuples avec un ITEM_PARAMETRE
 435               if verif_type == 0:
 436                  if type(v) == types.TupleType :
 437                    new_val=[]
 438                    for i in v:
 439                      if i.__class__.__name__ != 'PARAMETRE':
 440                         if i.__class__.__name__ != 'ITEM_PARAMETRE':
 441                            new_val.append(i)
 442                    if new_val != [] :
 443                      verif_type=self.verif_type(val=new_val,cr=cr)
 444                    else :
 445                      # Cas d une liste de paramétre
 446                      verif_type= 1
 447                  else:
 448                      verif_type=self.verif_type(val=v,cr=None)
 449            valid = verif_type*self.verif_into(cr=cr)*self.verif_card(cr=cr)
 450            #
 451            # On verifie les validateurs s'il y en a et si necessaire (valid == 1)
 452            #
 453            if valid and self.definition.validators and not self.definition.validators.verif(self.valeur):
 454               if cr == 'oui' :
 455                  self.cr.fatal(string.join(("Mot-clé : ",self.nom,"devrait avoir ",self.definition.validators.info())))
 456               valid=0
 457            # fin des validateurs
 458            #
 459         # cas d un item Parametre
 460         if self.valeur.__class__.__name__ == 'ITEM_PARAMETRE':
 461            valid=self.valeur.isvalid()
 462            if valid == 0:
 463               if cr == 'oui' :
 464                  self.cr.fatal(string.join( repr (self.valeur), " a un indice incorrect"))
 465
 466         self.set_valid(valid)
 467         return self.valid