Re: template Typelist of all possible permutations of templates
In article <1186784971.453810.289840@d30g2000prg.googlegroups.com>, Joe
<joh3@anatexis.net> wrote:
HI,
I am following the TypeList template description in Modern C++
Design,by A Alexandrescu,
I have been fighting this for a while and i want to ask the
experts. i am a little new to the metaprograming with templates
technique, so if it is my fundamental design that is failing me then
please let me know.
If i have the basic type set (char, int, long) defined like this
typedef Typelist_3{ char, int, long } basic_type_list;
then i have RGB, and HSB as two templates
template < typename image_type, int Size_X, int Size_Y> class RGB
{};
template < typename image_type, int Size_X, int Size_Y> class HSB
{};
where HSB, RGB are orthogonal, so cant easily be made polymorphic
(yes i know these names make that sound unlikely, but i think it is
the case here)
currently they are in a manually entered typelist like this
typelist_ { HSB< char, Size_X, Size_Y>, RGB< char, Size_X, Size_Y>,
HSB< int, Size_X, Size_Y>, RGB<int, Size_X, Size_Y>,
HSB< long, Size_X, Size_Y>, RGB< long, Size_X, Size_Y> }
all_permutations_list;
how do i automatically generate a typelist containing all posible
combinations at the logical same depth,
so the resulting typelist would look like this
typedef Typelist_N{HSB<? how_to_put_basic_type_here?, Size_X, Size_Y>,
RGB<? how_to_put_basic_type_here?, Size_X, Size_Y> , etc }
Well make the HSB,RGB,etc classs as specializations of something like
template <class Tag,class image_item, int SizeX,int SizeY> class
basic_image even if the specializations just inherit the existing class
and forward the construction to the original class.
Now we can create a list of lists if we have a list of the tags, and a
list of the basic_types, then we can create [I use boost::mpl as it is
higher level than Loki.]
typedef boost::mpl::vector<char,short,long,float,double> basic_types;
struct A_tag{};
struct B_tag{};
struct C_tag{};
struct D_tag{};
typedef boost::mpl::vector<A_tag,B_tag,C_tag,D_tag> tag_list;
template <class Tag,class Image,int SizeX,int SizeY> class
basic_image;
// inner list of all basic_images with a given Tag.
template <class Tag,class BasicTypes,int SizeX,int SizeY>
struct one_tag:boost::mpl::transform
<
BasicTypes,
basic_image<Tag,_,SizeX,SizeY>
>
{
};
what we want is a joint_view of all these lists,that is:
template <int SizeX,int SizeY>
struct all_types_of_sizes:boost::mpl::fold
<
tag_list,
boost::mpl::joint_view
<
_2,
one_tag
<
_1,
basic_types,
SizeX,
SixeY
>
>,
boost::mpl::vector<>,
>
{
};
typedef all_types_sizes<20,30> all_types;
now all_types is a sequence of all the basic_image types with given
sizes.
comes to mind but not with type lists of Loki.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]