]> SALOME platform Git repositories - tools/eficas.git/blob - Validation/V_MCSIMP.py
Salome HOME
CCAR: mise a niveau du noyau avec Aster 6.3.20 (Noyau, Validation, Macro, Cata)
[tools/eficas.git] / Validation / V_MCSIMP.py
1 #@ MODIF V_MCSIMP Validation  DATE 27/03/2002   AUTEUR DURAND C.DURAND 
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 """
22    Ce module contient la classe mixin MCSIMP qui porte les méthodes
23    nécessaires pour réaliser la validation d'un objet de type MCSIMP
24    dérivé de OBJECT.
25
26    Une classe mixin porte principalement des traitements et est
27    utilisée par héritage multiple pour composer les traitements.
28 """
29 # Modules Python
30 import string,types
31 import traceback
32
33 # Modules EFICAS
34 from Noyau import N_CR
35 from Noyau.N_Exception import AsException
36
37 class MCSIMP:
38    """
39       COMMENTAIRE CCAR
40         Cette classe est quasiment identique à la classe originale d'EFICAS
41         a part quelques changements cosmétiques et des chagements pour la
42         faire fonctionner de facon plus autonome par rapport à l'environnement
43         EFICAS
44  
45         A mon avis, il faudrait aller plus loin et réduire les dépendances
46         amont au strict nécessaire.
47
48         - Est il indispensable de faire l'évaluation de la valeur dans le contexte
49           du jdc dans cette classe.
50
51         - Ne pourrait on pas doter les objets en présence des méthodes suffisantes
52           pour éviter les tests un peu particuliers sur GEOM, PARAMETRE et autres. J'ai
53           d'ailleurs modifié la classe pour éviter l'import de GEOM
54    """
55
56    CR=N_CR.CR
57    
58    def __init__(self):
59       self.state='undetermined'
60
61    def isvalid(self,cr='non'):
62       """
63          Cette méthode retourne un indicateur de validité de l'objet
64          de type MCSIMP 
65          
66          - 0 si l'objet est invalide
67  
68          - 1 si l'objet est valide
69
70          Le pramètre cr permet de paramétrer le traitement. Si cr == 'oui'
71          la méthode construit également un comte-rendu de validation
72          dans self.cr qui doit avoir été créé préalablement.
73       """
74       if self.state == 'unchanged':
75         return self.valid
76       else:
77         valid = 1
78         if hasattr(self,'valid'):
79           old_valid = self.valid
80         else:
81           old_valid = None
82         v=self.valeur
83         #  presence
84         if self.isoblig() and v == None :
85           if cr == 'oui' :
86             self.cr.fatal(string.join(("Mot-clé : ",self.nom," obligatoire non valorisé")))
87           valid = 0
88         # type,into ...
89         valid = self.verif_type(cr=cr)*self.verif_into(cr=cr)*self.verif_card(cr=cr)
90         self.valid = valid
91         self.state = 'unchanged'
92         # Si la validité du mot clé a changé, on le signale à l'objet parent
93         if old_valid:
94           if old_valid != self.valid : self.init_modif_up()
95         return self.valid
96
97    def isoblig(self):
98       """ indique si le mot-clé est obligatoire
99       """
100       return self.definition.statut=='o'
101
102    def verif_card(self,cr='non'):
103       """ 
104          un mot-clé simple ne peut etre répété :
105            la cardinalité ici s'entend par la vérification que le nombre d'arguments de self.valeur
106            est bien compris entre self.min et self.max dans le cas où il s'agit d'une liste
107       """
108       card = 1
109       min=self.definition.min
110       max=self.definition.max
111       if type(self.valeur) in (types.ListType,types.TupleType) and 'C' not in self.definition.type :
112         if len(self.valeur) < min or len(self.valeur)>max:
113           if cr == 'oui':
114             self.cr.fatal("Nombre d'arguments %s incorrects pour %s (min = %s, max = %s)" %(`self.valeur`,self.nom,min,max))
115           card = 0
116       else:
117         if self.valeur == None :
118           if min >= 1 :
119             # on n'a pas d'objet et on en attend au moins un
120             card=0
121         else :
122           if min > 1:
123             # on n'a qu'un objet et on en attend plus d'1
124             card = 0
125       return card
126
127    def verif_type(self,val=None,cr='non'):
128       """
129         FONCTION :
130          Cette méthode a plusieurs modes de fonctionnement liés à la valeur de val et de cr.
131          Si cr ne vaut pas 'oui' : elle ne remplit pas le compte-rendu self.cr
132          Si val vaut None, elle vérifie le type de self.valeur
133          Si val ne vaut pas None, elle vérifie le type de val
134         PARAMETRE DE RETOUR :
135          Cette méthode retourne une valeur booléenne qui vaut 1 si le type est correct ou 0 sinon
136          
137       """
138       if val != None:
139         valeur = val
140       else:
141         valeur = self.valeur
142       if valeur == None :
143         if cr == 'oui':
144           self.cr.fatal("None n'est pas une valeur autorisée")
145         return 0
146       if type(valeur) == types.TupleType:
147         # on peut avoir à faire à un complexe ou une liste de valeurs ...
148         if self.is_complexe(valeur) : return 1
149         else:
150           for val in valeur:
151             if not self.verif_type(val=val,cr=cr) : return 0
152           return 1
153       elif type(valeur) == types.ListType:
154         for val in valeur:
155             if not self.verif_type(val=val,cr=cr) : return 0
156         return 1
157       else:
158         # on n'a pas de tuple ...il faut tester sur tous les types ou les valeurs possibles
159         # XXX Pourquoi into est il traité ici et pas seulement dans verif_into ???
160         if self.definition.into != None :
161           try:
162             if valeur in self.definition.into :
163               return 1
164             else:
165               if cr == 'oui':
166                 self.cr.fatal("%s n'est pas une valeur autorisée" %valeur)
167               return 0
168           except:
169             print "problème avec :",self.nom
170             print 'valeur =',valeur
171             return 0
172         for type_permis in self.definition.type:
173           if self.compare_type(valeur,type_permis) : return 1
174         # si on sort de la boucle précédente par ici c'est que l'on n'a trouvé aucun type valable --> valeur refusée
175         if cr =='oui':
176           self.cr.fatal("%s n'est pas d'un type autorisé" %`valeur`)
177         return 0
178
179    def verif_into(self,cr='non'):
180       """
181       Vérifie si la valeur de self est bien dans l'ensemble discret de valeurs
182       donné dans le catalogue derrière l'attribut into ou vérifie que valeur est bien compris
183       entre val_min et val_max
184       """
185       if self.definition.into == None :
186         #on est dans le cas d'un ensemble continu de valeurs possibles (intervalle)
187         if type(self.valeur)==types.TupleType :
188           test = 1
189           for val in self.valeur :
190             if type(val)!=types.StringType and type(val)!=types.InstanceType:
191               test = test*self.isinintervalle(val,cr=cr)
192           return test
193         else :
194           val = self.valeur
195           if type(val)!=types.StringType and type(val)!=types.InstanceType:
196             return self.isinintervalle(self.valeur,cr=cr)
197           else :
198             return 1
199       else :
200         # on est dans le cas d'un ensemble discret de valeurs possibles (into)
201         if type(self.valeur) == types.TupleType :
202           for e in self.valeur:
203             if e not in self.definition.into:
204               if cr=='oui':
205                 self.cr.fatal(string.join(("La valeur :",`e`," n'est pas permise pour le mot-clé :",self.nom)))
206               return 0
207         else:
208           if self.valeur == None or self.valeur not in self.definition.into:
209             if cr=='oui':
210               self.cr.fatal(string.join(("La valeur :",`self.valeur`," n'est pas permise pour le mot-clé :",self.nom)))
211             return 0
212         return 1
213
214    def is_complexe(self,valeur):
215       """ Retourne 1 si valeur est un complexe, 0 sinon """
216       if type(valeur) == types.StringType :
217         # on teste une valeur issue d'une entry (valeur saisie depuis EFICAS)
218         #XXX Il serait peut etre plus judicieux d'appeler une méthode de self.jdc
219         #XXX qui retournerait l'objet résultat de l'évaluation
220         #XXX ou meme de faire cette evaluation a l'exterieur de cette classe ??
221         if not self.jdc :return 0
222         try :
223           valeur = eval(valeur,self.jdc.g_context)
224         except:
225           return 0
226       if type(valeur) == types.InstanceType :
227         #XXX je n'y touche pas pour ne pas tout casser mais il serait
228         #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('C'), par exemple
229         if valeur.__class__.__name__ in ('EVAL','complexe'):
230           return 1
231         elif valeur.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
232           # il faut tester si la valeur du parametre est un entier
233           #XXX ne serait ce pas plutot complexe ???? sinon expliquer
234           return self.is_entier(valeur.valeur)
235         else:
236           print "Objet non reconnu dans is_complexe %s" %`valeur`
237           return 0
238       elif type(valeur) != types.TupleType :
239         return 0
240       else:
241         if len(valeur) != 3 :
242           return 0
243         else:
244           if type(valeur[0]) != types.StringType : return 0
245           if string.strip(valeur[0]) not in ('RI','MP'):
246             return 0
247           else:
248             if not self.is_reel(valeur[1]) or not self.is_reel(valeur[2]) : return 0
249             else: return 1
250
251    def is_reel(self,valeur):
252       """
253       Retourne 1 si valeur est un reel, 0 sinon
254       """
255       if type(valeur) == types.StringType :
256         # on teste une valeur issue d'une entry (valeur saisie depuis EFICAS)
257         if not self.jdc :return 0
258         try :
259           valeur = eval(valeur,self.jdc.g_context)
260         except:
261           return 0
262       if type(valeur) == types.InstanceType :
263         #XXX je n'y touche pas pour ne pas tout casser mais il serait
264         #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('R'), par exemple
265         #XXX ou valeur.is_reel()
266         #XXX ou encore valeur.compare(self.is_reel)
267         if valeur.__class__.__name__ in ('EVAL','reel') :
268           return 1
269         elif valeur.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
270           # il faut tester si la valeur du parametre est un réel
271           return self.is_reel(valeur.valeur)
272         else:
273           print "Objet non reconnu dans is_reel %s" %`valeur`
274           return 0
275       elif type(valeur) not in (types.IntType,types.FloatType,types.LongType):
276         # ce n'est pas un réel
277         return 0
278       else:
279         return 1
280
281    def is_entier(self,valeur):
282       """ Retourne 1 si valeur est un entier, 0 sinon """
283       if type(valeur) == types.StringType :
284         # on teste une valeur issue d'une entry (valeur saisie depuis EFICAS)
285         if not self.jdc :return 0
286         try :
287           valeur = eval(valeur,self.jdc.g_context)
288         except:
289           return 0
290       if type(valeur) == types.InstanceType :
291         #XXX je n'y touche pas pour ne pas tout casser mais il serait
292         #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('I'), par exemple
293         if valeur.__class__.__name__ in ('EVAL','entier') :
294           return 1
295         elif valeur.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
296           # il faut tester si la valeur du parametre est un entier
297           return self.is_entier(valeur.valeur)
298         else:
299           print "Objet non reconnu dans is_reel %s" %`valeur`
300           return 0
301       elif type(valeur) not in (types.IntType,types.LongType):
302         # ce n'est pas un entier
303         return 0
304       else:
305         return 1
306         
307    def is_shell(self,valeur):
308       """ 
309           Retourne 1 si valeur est un shell, 0 sinon
310           Pour l'instant aucune vérification n'est faite
311           On impose juste que valeur soit une string
312       """
313       if type(valeur) != types.StringType:
314         return 0
315       else:
316         return 1
317
318    def is_object_from(self,objet,classe):
319       """ 
320            Retourne 1 si valeur est un objet de la classe classe ou d'une sous-classe de classe,
321            0 sinon 
322       """
323       if type(objet) != types.InstanceType :
324         if type(objet) == types.StringType:
325           if not self.jdc :return 0
326           try :
327             objet = eval(objet,self.jdc.g_context)
328             if type(objet) != types.InstanceType : return 0
329           except:
330             return 0
331         else:
332           return 0
333       if not objet.__class__ == classe and not issubclass(objet.__class__,classe):
334         return 0
335       else:
336         return 1
337
338    def compare_type(self,valeur,type_permis):
339       """
340           Fonction booléenne qui retourne 1 si valeur est du type type_permis, 0 sinon
341       """
342       if type(valeur) == types.InstanceType and valeur.__class__.__name__ == 'PARAMETRE':
343         if type(valeur.valeur) == types.TupleType :
344           # on a à faire à un PARAMETRE qui définit une liste d'items
345           # --> on teste sur la première car on n'accepte que les liste homogènes
346           valeur = valeur.valeur[0]
347       if type_permis == 'R':
348         return self.is_reel(valeur)
349       elif type_permis == 'I':
350         return self.is_entier(valeur)
351       elif type_permis == 'C':
352         return self.is_complexe(valeur)
353       elif type_permis == 'shell':
354         return self.is_shell(valeur)
355       elif type_permis == 'TXM':
356         if type(valeur) != types.InstanceType:
357           return type(valeur)==types.StringType
358         else:
359           #XXX je n'y touche pas pour ne pas tout casser mais il serait
360           #XXX préférable d'appeler une méthode de valeur : return valeur.is_type('TXM'), par exemple
361           if valeur.__class__.__name__ == 'chaine' :
362             return 1
363           elif valeur.__class__.__name__ == 'PARAMETRE':
364             # il faut tester si la valeur du parametre est une string
365             return type(valeur.valeur)==types.StringType
366           else:
367             return 0
368       elif type(type_permis) == types.ClassType:
369         # on ne teste pas certains objets de type GEOM , assd, ...
370         # On appelle la méthode de classe is_object de type_permis.
371         # Comme valeur peut etre de n'importe quel type on utilise la fonction (is_object.im_func)
372         # et non pas la methode (is_object) ce qui risquerait de provoquer des erreurs
373         if type_permis.is_object.im_func(valeur):
374           return 1
375         else :
376           return self.is_object_from(valeur,type_permis)
377       else:
378         print "Type non encore géré %s" %`type_permis`
379         print self.nom,self.parent.nom,self.jdc.fichier
380
381    def isinintervalle(self,valeur,cr='non'):
382       """
383       Booléenne qui retourne 1 si la valeur passée en argument est comprise dans
384       le domaine de définition donné dans le catalogue, 0 sinon.
385       """
386       if type(valeur) not in (types.IntType,types.FloatType,types.LongType) :
387         return 1
388       else :
389         min = self.definition.val_min
390         max = self.definition.val_max
391         if min == '**': min = valeur -1
392         if max == '**': max = valeur +1
393         if valeur < min or valeur > max :
394           if cr=='oui':
395             self.cr.fatal(string.join(("La valeur :",`valeur`," du mot-clé ",self.nom,\
396                                        " est en dehors du domaine de validité [",`min`,",",`max`,"]")))
397           return 0
398         else :
399           return 1
400
401    def init_modif_up(self):
402       """
403          Propage l'état modifié au parent s'il existe et n'est l'objet 
404          lui-meme
405       """
406       if self.parent and self.parent != self :
407         self.parent.state = 'modified'
408
409    def report(self):
410       """ génère le rapport de validation de self """
411       self.cr=self.CR()
412       self.cr.debut = "Mot-clé simple : "+self.nom
413       self.cr.fin = "Fin Mot-clé simple : "+self.nom
414       self.state = 'modified'
415       try:
416         self.isvalid(cr='oui')
417       except AsException,e:
418         if CONTEXT.debug : traceback.print_exc()
419         self.cr.fatal(string.join(("Mot-clé simple : ",self.nom,str(e))))
420       return self.cr
421
422
423
424
425
426