Boost logo

Boost :

From: Matus Chochlik (chochlik_at_[hidden])
Date: 2008-06-07 03:56:50

On Fri, Jun 6, 2008 at 10:21 PM, Joel FALCOU <joel.falcou_at_[hidden]> 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 {};
> (class)(class)(class)(class)(size_t), foo)
> 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
> 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).
> --
> 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
// 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:


(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:


Boost list run by bdawes at, gregod at, cpdaniel at, john at