Gestionnaire d'exceptions générique

Bonjour,

Suite =E0 une astuce que j'avais crois=E9e sur la FAQ C++-lite [1],
j'avais commenc=E9 =E0 factoriser ma gestion des exceptions. Ce qui me
permet de ne pas parasiter mes fonctions d'interface (CORBA), et
autres fonctions de thread, de blocs try-catch plus longs que le corp
utile de la fonction.

Jusque l=E0, tout va bien. Sauf que. Toutes ces fonctions
handleException() se ressemblent beaucoup tout en connaissant des
subtiles variations. Un coup un type d'exception doit circuler sans
=EAtre intercept=E9, un coup d'autres types doivent =EAtre convertis vers un
type tier, etc., etc.

Du coup, je me posais la question d'avoir un truc encore plus
g=E9n=E9rique, quelque chose qui pourrait p.ex. s'utiliser de la sorte:

try {
actions...
} catch (...) {
handleException<
ExceptionToThrow, // vers laquelle on convertit,
possiblement void
TYPE_LIST_2(CORBA::SystemException,
Metier::ErrorCorbaFormat), // exceptions non filtr=E9es
TYPE_LIST_3(Metier::ErrorCppFormat, std::bad_catch,
std::exception)// exceptions =E0 convertir
>
(stringContexte, divers bool=E9ns pour les traces);
}

Ce qui en gros serait =E9quivalent (c=F4t=E9 HandleException) =E0 :

try {
throw;
} catch (CORBA::SystemException const&e ) {
if (trace) TRACE(contexte,
exception_traits<CORBA::SystemException>::toString(e));
throw;
} catch (Metier::ErrorCorbaFormat const&e ) {
if (trace) TRACE(contexte,
exception_traits<Metier::ErrorCorbaFormat>::toString(e));
throw;
} catch (Metier::ErrorCppFormatconst&e ) {
if (trace) TRACE(contexte,
exception_traits<Metier::ErrorCppFormat>::toString(e));
throw exception_traits<ExceptionToThrow>::build(
exception_traits<Metier::ErrorFormatCpp>::toString(e));
} ......


Mon gros probl=E8me est "comment y arriver?". Sans partir sur la
g=E9n=E9ration d'un mini HandleException pour chaque type des TYPE_LIST
(i.e. le catch(...) de chaque HandleException appelant un autre
HandleException o=F9 l'on aurait d=E9pil=E9 un type d'exception de la
liste), ou sans partir sur des macros =E0 profusion, je s=EAche un peu.
(Je ne suis pas s=FBr que la premi=E8re solution usine =E0 gaz soit tr=E8s
efficace, ni tr=E8s maintenable. Quant =E0 la la deuxi=E8me, elle peut
rapidement devenir un cauchemar =E0 debugguer le jour o=F9 cela devient
n=E9cessaire (core)).


Bref, Vous =EAtes-vous d=E9j=E0 pos=E9 ce probl=E8me ? Et si oui, =E0 quelle
conclusion avez-vous abouti?


[1] http://www.parashift.com/c++-faq-lite/exceptions.html#faq-17.9

--
Luc Hermitte