/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F O N C T I O N S   M A T H E M A T I Q U E S   D E   G E S T I O N   D E S   A P P L Y s  :                               */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition :                                                                                                               */
/*                                                                                                                                   */
/*                    Dans ce fichier, se trouvent les                                                                               */
/*                  fonctions de base utilisees par                                                                                  */
/*                  la gestion des applys. Pour des                                                                                  */
/*                  raisons liees a la generation des                                                                                */
/*                  fichiers "$EXT", ces definitions                                                                                 */
/*                  doivent etre seules dans ce fichier.                                                                             */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$ximd/operator.2$DEF' :                                                                                         */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 19890000000000).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   E T   G E S T I O N   D E S   A P P L Y S  :                                                         */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition :                                                                                                               */
/*                                                                                                                                   */
/*                    De facon a pouvoir appliquer optionnellement                                                                   */
/*                  des fonctions de transformation a des valeurs                                                                    */
/*                  quelconques, la notion d'"apply" est creee.                                                                      */
/*                  Elle n'utilise pas de 'Struc' car en effet,                                                                      */
/*                  leurs initialisations est delicate ; on                                                                          */
/*                  utilise donc quelque chose qui est formellement                                                                  */
/*                  identique : le pseudo-operateur "`" de concatenation                                                             */
/*                  du pre-processeur.                                                                                               */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Utilisation :                                                                                                              */
/*                                                                                                                                   */
/*                  DEFINITION_D_UN_APPLY(nom_de_l_apply,type_des_fonctions,fonction_neutre);                                        */
/*                  AUTORISATION_D_UN_APPLY(nom_de_l_apply,fonction_a_appliquer);                                                    */
/*                  INHIBITION_D_UN_APPLY(nom_de_l_apply,fonction_neutre);                                                           */
/*                  APPLY(nom_de_l_apply,valeur)                                                                                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Important :                                                                                                                */
/*                                                                                                                                   */
/*                    On utilise "=define" et non pas "#define" pour                                                                 */
/*                  faciliter le travail de la generation des fichiers                                                               */
/*                  du type '$EXT'.                                                                                                  */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Tres important :                                                                                                           */
/*                                                                                                                                   */
/*                    A compter du 20101222210836 le nom des fonctions                                                               */
/*                  qui peuvent etre pointees par le pointeur 'afPOINTEUR_1(...)'                                                    */
/*                  defini dans 'DEFINITION_D_UN_APPLY(...)' doivent necessairement                                                  */
/*                  debuter par "fAPPLY_____" a cause de la contrainte expliquee                                                     */
/*                  dans 'v $xcg/LArgTypFo$vv$Z 20101222210652'...                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
=define   DEFINITION_D_UN_APPLY(nom_de_l_apply,type_des_fonctions,fonction_neutre)                                                      \
                    DEFV(Common,DEFV(Logical,INIT(etat_de_l_apply____`nom_de_l_apply,INVALIDE)));                                       \
                                        /* Indicateur precisant si l'on doit appliquer ('VALIDE') la fonction ou pas ('INVALIDE').   */ \
                    DEFV(Common,DEFV(type_des_fonctions,INIT(afPOINTEUR_1p(fonction_de_l_apply____`nom_de_l_apply)                      \
                                                            ,aFONCTION(fAPPLY`___`fonction_neutre`___`nom_de_l_apply)                   \
                                                             )                                                                          \
                                     )                                                                                                  \
                         )
                                        /* Ce pointeur 'fonction_de_l_apply' contient en permanence l'adresse d'une fonction a       */
                                        /* appliquer a une valeur, lorsque l'indicateur 'etat_de_l_apply' le permet... On fera       */
                                        /* attention a l'absence de ";" a la fin de la directive precedente. Enfin, on utilise       */
                                        /* "=define" et non pas "#define" afin que lors de la generation des fichiers '$EXT'         */
                                        /* il n'y ait pas elimination des lignes du type "#if" par 'cpp$X'...                        */
=define   AUTORISATION_D_UN_APPLY(nom_de_l_apply,fonction_a_appliquer)                                                                  \
                    Bblock                                                                                                              \
                    EGAL(etat_de_l_apply____`nom_de_l_apply,VALIDE);                                                                    \
                    EGAL(fonction_de_l_apply____`nom_de_l_apply,aFONCTION(fAPPLY`___`fonction_a_appliquer`___`nom_de_l_apply));         \
                                        /* On autorise et met en place la fonction a appliquer...                                    */ \
                    Eblock
=define   INHIBITION_D_UN_APPLY(nom_de_l_apply,fonction_neutre)                                                                         \
                    Bblock                                                                                                              \
                    EGAL(fonction_de_l_apply____`nom_de_l_apply,aFONCTION(fAPPLY`___`fonction_neutre`___`nom_de_l_apply));              \
                    EGAL(etat_de_l_apply____`nom_de_l_apply,INVALIDE);                                                                  \
                                        /* On inhibe la fonction a appliquer en mettant (par hygiene) une fonction "neutre"...       */ \
                    Eblock
=define   APPLY_ACTIF(nom_de_l_apply)                                                                                                   \
                    EST_VALIDE(etat_de_l_apply____`nom_de_l_apply)
                                        /* Afin de tester si un 'APPLY' est actif ou pas...                                          */
=define   APPLY(nom_de_l_apply,valeur)                                                                                                  \
                    COND(APPLY_ACTIF(nom_de_l_apply)                                                                                    \
                        ,fPOINTEUR(fonction_de_l_apply____`nom_de_l_apply)(valeur)                                                      \
                        ,valeur                                                                                                         \
                         )
                                        /* Application, si cela est valide, de la fonction 'fonction' a la valeur 'valeur'.          */