Extensions/mcnuplet.py

   1 """
   2 """
   3 # Modules Python
   4 import string
   5
   6 # Modules Eficas
   7 from Noyau import N_MCCOMPO
   8 from Validation import V_MCCOMPO
   9
  10 class MCNUPLET(V_MCCOMPO.MCCOMPO,N_MCCOMPO.MCCOMPO):
  11    """
  12    """
  13    nature = "MCNUPLET"
  14    txt_nat="Nuplet : "
  15
  16    def __init__(self,val,definition,nom,parent):
  17       # val contient la valeur initial du nuplet
  18       self.val = val
  19       if val == None: self.val=()
  20       self.definition=definition
  21       self.nom=nom
  22       self.parent = parent
  23       # GETVAL affecte la valeur par defaut si necessaire
  24       self.valeur=self.GETVAL(self.val)
  25       if parent :
  26          self.jdc = self.parent.jdc
  27          self.niveau = self.parent.niveau
  28          self.etape = self.parent.etape
  29       else:
  30          # Le mot cle a été créé sans parent
  31          self.jdc = None
  32          self.niveau = None
  33          self.etape = None
  34       self.state = 'undetermined'
  35       self.mc_liste=self.build_mc()
  36
  37    def build_mc(self):
  38       """
  39           Construit la liste des sous-entites de MCNUPLET
  40           à partir de la liste des arguments (valeur)
  41       """
  42       args = self.valeur
  43       if args ==None : args =()
  44       mc_liste=[]
  45
  46       # on crée les sous entites du NUPLET a partir des valeurs initiales
  47       k=0
  48       for v in self.definition.entites:
  49         if k < len(args):
  50           val=args[k]
  51         else:
  52           val=None
  53         objet=v(val=val,nom=`k`,parent=self)
  54         if hasattr(objet.definition,'position'):
  55           if objet.definition.position == 'global' :
  56             self.append_mc_global(objet)
  57           #XXX et global_jdc ??
  58         mc_liste.append(objet)
  59         k=k+1
  60       return mc_liste
  61
  62    def isvalid(self,cr='non'):
  63       """
  64           Indique si self (MCNUPLET) est un objet valide ou non : retourne 1 si oui, 0 sinon
  65       """
  66       if self.state == 'unchanged' :
  67         return self.valid
  68       else:
  69         valid = 1
  70         if hasattr(self,'valid'):
  71           old_valid = self.valid
  72         else:
  73           old_valid = None
  74         for child in self.mc_liste :
  75           if not child.isvalid():
  76             valid = 0
  77             break
  78         if len(self.mc_liste) != len(self.definition.entites):
  79           valid=0
  80           if cr == 'oui' :
  81             self.cr.fatal(string.join(("Nuplet : ",self.nom," Longueur incorrecte")))
  82         self.valid = valid
  83         self.state = 'unchanged'
  84         if old_valid:
  85           if old_valid != self.valid : self.init_modif_up()
  86         return self.valid
  87
  88    def __getitem__(self,key):
  89       """
  90           Retourne le key ème élément du nuplet
  91       """
  92       # Un nuplet est toujours une liste de mots cles simples
  93       # On retourne donc la valeur
  94       return self.mc_liste[key].valeur
  95
  96    def __str__(self):
  97       """
  98            Retourne une représentation du nuplet sous forme de chaine
  99            de caractères
 100       """
 101       s='('
 102       for e in self.mc_liste:
 103         s=s + str(e.valeur) + ','
 104       return s + ')'
 105
 106    def __repr__(self):
 107       """
 108            Retourne une représentation du nuplet sous forme de chaine
 109            de caractères
 110       """
 111       s='('
 112       for e in self.mc_liste:
 113         s=s + str(e.valeur) + ','
 114       return s + ')'
 115
 116    def get_regles(self):
 117       """
 118          Retourne la liste des règles attachées au nuplet
 119       """
 120       return []
 121
 122    def verif_condition_bloc(self):
 123       """
 124           Vérifie s'il y a des blocs sous le nuplet et retourne
 125           les blocs en question
 126       """
 127       # Il n y a pas de BLOCs sous un NUPLET
 128       return [],[]
 129
 130    def isrepetable(self):
 131       """
 132           Indique si le NUPLET peut etre répété.
 133           Retourne 1 si c'est le cas.
 134           Retourne 0 dans le cas contraire.
 135           L'information est donnée par le catalogue, cad la définition de self
 136       """
 137       if self.definition.min != self.definition.max :
 138         return 1
 139       else :
 140         return 0
 141
 142    def makeobjet(self):
 143       return self.definition(val = None, nom = self.nom,parent = self.parent)
 144
 145    def get_valeur(self):
 146       """
 147           Cette méthode doit retourner la valeur de l'objet. Elle est utilisée par
 148           cree_dict_valeurs pour construire un dictionnaire contenant les mots clés
 149           d'une étape.
 150           Dans le cas d'un nuplet, on retournera comme valeur une liste des valeurs
 151           des mots clé simples contenus.
 152       """
 153       l=[]
 154       for v in self.mc_liste:
 155          l.append(v.valeur)
 156       return l
 157
 158    def get_val(self):
 159       """
 160           Une autre méthode qui retourne une "autre" valeur du mot clé facteur.
 161           Elle est utilisée par la méthode get_mocle
 162       """
 163       l=[]
 164       for v in self.mc_liste:
 165          l.append(v.valeur)
 166       return l
 167
 168    def isoblig(self):
 169       return self.definition.statut=='o'
 170
 171
 172