Ihm/I_VALIDATOR.py

   1 """
   2    Ce module contient des classes permettant de définir des validateurs
   3    pour EFICAS. Ces classes constituent un complément à des classes existantes
   4    dans Noyau/N_VALIDATOR.py ou de nouvelles classes de validation.
   5    Ces classes complémentaires ne servent que pour l'IHM d'EFICAS.
   6    Elles servent essentiellement à ajouter des comportements spécifiques
   7    IHM aux classes existantes dans le Noyau.
   8    Ces comportements pourront etre rapatries dans le Noyau quand leur
   9    interface sera stabilisée.
  10 """
  11
  12 class Valid:
  13    """
  14         Cette classe est la classe mere de toutes les classes complémentaires
  15         que l'on trouve dans Ihm.
  16         Elle porte les comportements par défaut des méthodes des validateurs.
  17    """
  18
  19    def info_erreur_item(self):
  20        """
  21           Cette méthode permet d'avoir un message d'erreur pour un item
  22           dans une liste dans le cas ou le validateur fait des vérifications
  23           sur les items d'une liste. Si le validateur fait des vérifications
  24           sur la liste elle meme et non sur ses items, la méthode
  25           doit retourner une chaine vide.
  26        """
  27        return ""
  28
  29    def aide(self):
  30        """
  31           Cette methode retourne une chaine de caractère qui permet à EFICAS de construire
  32           un message d'aide en ligne
  33           En général, le message retourné est le meme que celui retourné par la
  34           méthode info
  35        """
  36        return self.info()
  37
  38    def info_erreur_liste(self):
  39        """
  40           Cette méthode a un comportement complémentaire de celui de info_erreur_item.
  41           Elle retourne un message d'erreur lié uniquement aux vérifications sur la liste
  42           elle meme et pas sur ses items. Dans le cas où le validateur ne fait pas de vérification
  43           sur des listes, elle retourne une chaine vide
  44        """
  45        return ""
  46
  47    def is_list(self):
  48        """
  49           Cette méthode retourne un entier qui indique si le validateur permet les listes (valeur 1)
  50           ou ne les permet pas (valeur 0).
  51           Par défaut, un validateur n'autorise que des scalaires.
  52        """
  53        return 0
  54
  55    def has_into(self):
  56        """
  57           Cette méthode retourne un entier qui indique si le validateur propose une liste de choix (valeur 1)
  58           ou n'en propose pas.
  59           Par défaut, un validateur n'en propose pas.
  60        """
  61        return 0
  62
  63    def get_into(self,liste_courante=None,into_courant=None):
  64        """
  65           Cette méthode retourne la liste de choix proposée par le validateur. Si le validateur ne propose
  66           pas de liste de choix, la méthode retourne None.
  67           L'argument d'entrée liste_courante, s'il est différent de None, donne la liste des choix déjà
  68           effectués par l'utilisateur. Dans ce cas, la méthode get_into doit calculer la liste des choix
  69           en en tenant compte. Par exemple, si le validateur n'autorise pas les répétitions, la liste des
  70           choix retournée ne doit pas contenir les choix déjà contenus dans liste_courante.
  71           L'argument d'entrée into_courant, s'il est différent de None, donne la liste des choix proposés
  72           par d'autres validateurs. Dans ce cas, la méthode get_into doit calculer la liste des choix à retourner
  73           en se limitant à cette liste initiale. Par exemple, si into_courant vaut (1,2,3) et que le validateur
  74           propose la liste de choix (3,4,5), la méthode ne doit retourner que (3,).
  75
  76           La méthode get_into peut retourner une liste vide [], ce qui veut dire qu'il n'y a pas (ou plus) de choix possible
  77           Cette situation peut etre normale : l''utilisateur a utilisé tous les choix, ou résulter d'une incohérence
  78           des validateurs : choix parmi (1,2,3) ET choix parmi (4,5,6). Il est impossible de faire la différence entre
  79           ces deux situations.
  80        """
  81        return into_courant
  82
  83 class FunctionVal(Valid):pass
  84
  85 class OrVal(Valid):
  86    def is_list(self):
  87        """
  88           Si plusieurs validateurs sont reliés par un OU
  89           il suffit qu'un seul des validateurs attende une liste
  90           pour qu'on considère que leur union attende une liste.
  91        """
  92        for validator in self.validators:
  93            v=validator.is_list()
  94            if v :
  95               return 1
  96        return 0
  97
  98    def has_into(self):
  99        """
 100           Dans le cas ou plusieurs validateurs sont reliés par un OU
 101           il faut que tous les validateurs proposent un choix pour
 102           qu'on considère que leur union propose un choix.
 103           Exemple : Enum(1,2,3) OU entier pair, ne propose pas de choix
 104           En revanche, Enum(1,2,3) OU Enum(4,5,6) propose un choix (1,2,3,4,5,6)
 105        """
 106        for validator in self.validators:
 107            v=validator.has_into()
 108            if not v :
 109               return 0
 110        return 1
 111
 112    def get_into(self,liste_courante=None,into_courant=None):
 113        """
 114           Dans le cas ou plusieurs validateurs sont reliés par un OU
 115           tous les validateurs doivent proposer un choix pour
 116           qu'on considère que leur union propose un choix.
 117           Tous les choix proposés par les validateurs sont réunis (opérateur d'union)
 118           Exemple : Enum(1,2,3) OU entier pair, ne propose pas de choix
 119           En revanche, Enum(1,2,3) OU Enum(4,5,6) propose un choix (1,2,3,4,5,6)
 120        """
 121        validator_into=[]
 122        for validator in self.validators:
 123            v_into=v.get_info(liste_courante,into_courant)
 124            if v_into is None:
 125               return v_into
 126            validator_into.extend(v_into)
 127        return validator_into
 128
 129 class AndVal(Valid):
 130    def is_list(self):
 131        """
 132           Si plusieurs validateurs sont reliés par un ET
 133           il faut que tous les validateurs attendent une liste
 134           pour qu'on considère que leur intersection attende une liste.
 135           Exemple Range(2,5) ET Card(1) n'attend pas une liste
 136           Range(2,5) ET Pair attend une liste
 137        """
 138        for validator in self.validators:
 139            v=validator.is_list()
 140            if v == 0 :
 141               return 0
 142        return 1
 143
 144    def has_into(self):
 145        """
 146           Dans le cas ou plusieurs validateurs sont reliés par un ET
 147           il suffit qu'un seul validateur propose un choix pour
 148           qu'on considère que leur intersection propose un choix.
 149           Exemple : Enum(1,2,3) ET entier pair, propose un choix
 150           En revanche, entier pair ET superieur à 10 ne propose pas de choix
 151        """
 152        for validator in self.validators:
 153            v=validator.has_into()
 154            if v :
 155               return 1
 156        return 0
 157
 158    def get_into(self,liste_courante=None,into_courant=None):
 159        """
 160           Dans le cas ou plusieurs validateurs sont reliés par un ET
 161           il suffit qu'un seul validateur propose un choix pour
 162           qu'on considère que leur intersection propose un choix.
 163
 164           Tous les choix proposés par les validateurs sont croisés (opérateur d'intersection)
 165           Exemple : Enum(1,2,3) ET entier pair, propose un choix (2,)
 166           En revanche, Enum(1,2,3) ET Enum(4,5,6) ne propose pas de choix
 167        """
 168        for validator in self.validators:
 169            into_courant=v.get_info(liste_courante,into_courant)
 170            if into_courant in ([],None):
 171               return into_courant
 172        return into_courant
 173
 174 class CardVal(Valid):
 175    def is_list(self):
 176        if self.max == '**' or self.max > 1:
 177              return 1
 178        else:
 179              return 0
 180
 181    def get_into(self,liste_courante=None,into_courant=None):
 182        if into_courant is None:
 183           return None
 184        elif liste_courante is None:
 185           return into_courant
 186        elif self.max == '**':
 187           return into_courant
 188        elif len(liste_courante) < self.max:
 189           return into_courant
 190        else:
 191           return []
 192
 193 class ListVal(Valid):
 194    def is_list(self):
 195        return 1
 196
 197    def get_into(self,liste_courante=None,into_courant=None):
 198        """
 199           Cette méthode get_into effectue un traitement général qui consiste
 200           a filtrer la liste de choix into_courant, si elle existe, en ne conservant
 201           que les valeurs valides (appel de la méthode valid)
 202        """
 203        if into_courant is None:
 204           return None
 205        else:
 206           liste_choix=[]
 207           for e in into_courant:
 208               if self.verif(e):
 209                  liste_choix.append(e)
 210           return liste_choix
 211
 212 class EnumVal(ListVal):
 213    def has_into(self):
 214        return 1
 215
 216    def get_into(self,liste_courante=None,into_courant=None):
 217        if into_courant is None:
 218           liste_choix= list(self.into)
 219        else:
 220           liste_choix=[]
 221           for e in into_courant:
 222               if e in self.into:
 223                  liste_choix.append(e)
 224        return liste_choix
 225
 226 class LongStr(ListVal):pass
 227 class RangeVal(ListVal):pass
 228 class TypeVal(ListVal):pass
 229 class PairVal(ListVal):pass
 230 class InstanceVal(ListVal):pass
 231
 232 class NoRepeat(ListVal):
 233    def get_into(self,liste_courante=None,into_courant=None):
 234        """
 235           Methode get_into spécifique pour validateur NoRepeat
 236           on retourne une liste de choix qui ne contient aucune valeur de into_courant
 237           déjà contenue dans liste_courante
 238        """
 239        if into_courant is None:
 240           return None
 241        else:
 242           liste_choix=[]
 243           for e in into_courant:
 244               if e in liste_choix: continue
 245               if liste_courante is not None and e in liste_courante: continue
 246               liste_choix.append(e)
 247           return liste_choix
 248
 249 class OrdList(ListVal):
 250    def get_into(self,liste_courante=None,into_courant=None):
 251        """
 252           Methode get_into spécifique pour validateur OrdList
 253           on retourne une liste de choix qui ne contient aucune valeur de into_courant
 254           dont la valeur est inférieure à la dernière valeur de liste_courante, si
 255           elle est différente de None.
 256        """
 257        if into_courant is None:
 258           return None
 259        elif not liste_courante :
 260           return into_courant
 261        else:
 262           liste_choix=[]
 263           last_val=liste_choix[-1]
 264           for e in into_courant:
 265               if self.ord=='croissant' and e <= last_val:continue
 266               if self.ord=='decroissant' and e >= last_val:continue
 267               liste_choix.append(e)
 268           return liste_choix
 269
 270
 271
 272
 273
 274
 275