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