On Fri, Jun 6, 2008 at 10:21 PM, Joel FALCOU <joel.falcou@u-psud.fr> wrote:
Andrew James a écrit :
I myself have also implemented a class that has these features within a "traited" framework (explanation to follow). The challenge I have seen, that I'm not clear if it is expressed here, is what if the type whose name you want to dump is also dependent on some template parameter that a frameword user is in charge of? [...] These things being said, I realize this is specific to my framework but it illustrates some issues a boost supported solution could provide. We should be able to debug types like std::vector< SomeTypeTheDebugLibraryIsCluelessAbout > w/o requiring the user do a similar amount of work to writing the facility him/herself.
I'm not sure if I understood the problem but currently my identify<> class can take care of user defined type or user_defined tempalte by using a simple register macro. I also have a on going list of pre-registered type for STD and parts of BOOST.
Here is a small example :
#include <boost/identify/identify.hpp> #include <boost/identify/support/std.hpp>
// Some user template classes template<class A1,class A2,class A3,class A4,size_t A5> struct foo {}; template<class A1,class A2> struct chu{};
// some class struct coin {};
BOOST_IDENTIFY_REGISTER_TYPE_ID(coin) BOOST_IDENTIFY_REGISTER_CUSTOM_TEMPLATE_TYPE_ID( (class)(class)(class)(class)(size_t), foo) BOOST_IDENTIFY_REGISTER_TEMPLATE_TYPE_ID(chu,2)
template<class T> struct Test { static inline void Do() { cout << boost::identify<T>::Name() << endl; } };
int main() { Test<char>::Do(); Test<coin>::Do(); Test<chu<float,coin> >::Do(); Test< std::vector< chu<void,void*>& > >::Do(); Test<foo<float,long*,volatile double,coin,3> >::Do(); }
The results are :
char coin chu<float, coin> std::vector< chu<void,void*>& foo< float, signed long*, volatile double, coin, 3 >
the identify.hpp grants the main identify class ans supports for basic types (POD, pointer, reference, cv qualified types, function types, function pointers and array mostly) while the support/std.hpp provides pre-registered identify overload for STD types.
The macro BOOST_IDENTIFY_REGISTER_TYPE_ID declares a new user types to be displayed. BOOST_IDENTIFY_REGISTER_TEMPLATE_TYPE_ID does the same for template class with less than 5 tempalte parameters which are all of tpye class. BOOST_IDENTIFY_REGISTER_CUSTOM_TEMPLATE_TYPE_ID allows registering tempalte class with more than 5 parameters and with integralk parameters by specifying a BOOST_PP_SEQ of the arguments. The burden is no greater for me than registering a type for BOOST_TYPEOF and is fairly acceptable.
Not sure if other cases are needed. My main concern is being able to display non-instanciated template class, eg:
identify<std::vector>::Name() displaying std::vector
but this may need another class (like incomplete_identify<> maybe).
-- Joel FALCOU Research Engineer @ Institut d'Electronique Fondamentale Université PARIS SUD XI France
The mirror library works from the programmer's point of view this way: // define a rather complex type T // typedef tuple<int, double, const string*> T1; typedef tuple<const bool, volatile float, void * const, char> T2; typedef pair<T1, T2> T3; typedef tuple<void*, const wstring& , const string&> T4; typedef tuple<char, wchar_t, short int const> T5; typedef pair<T4, T5> T6; typedef vector<tuple<T1, T2, T3, T4, T5, T6> > T7; typedef set<map<list<T1>, T7> > T; // // reflect the class using mirror. the "result" is a meta_class typedef BOOST_MIRROR_REFLECT_CLASS(T) meta_T; // // among many other things there are member functions // that return the typename of the reflected type // // the base_name returns the type/class/template // names without nested-name-specifiers // i.e. vector<pair<int, string> > // bcout << "The type name is: "<< meta_T::base_name() << endl; // // this version returns the fully qualified name like // ::std::vector<::std::pair<int, ::std::string> > bcout << "The full type name is: "<< meta_T::full_name() << endl; there are several examples showing this in the sandbox: http://svn.boost.org/svn/boost/sandbox/mirror/libs/mirror/example/ especially http://svn.boost.org/svn/boost/sandbox/mirror/libs/mirror/example/special/st... http://svn.boost.org/svn/boost/sandbox/mirror/libs/mirror/example/special/bo... (sry for the long links) the meta_class specializations for the templates like pair, vector, tuple, etc. are currently hand-coded, and using some common boilerplate to handle the template param names, but I'm working on some registering macros similar to Joel's. see for example: http://svn.boost.org/svn/boost/sandbox/mirror/boost/mirror/meta_classes/std_... -- ________________ ::matus_chochlik