Re: template Typelist of all possible permutations of templates

From:

Carl Barron <cbarron413@adelphia.net>

Newsgroups:

comp.lang.c++.moderated

Date:

Sat, 11 Aug 2007 08:12:17 CST

Message-ID:

<110820070420395240%cbarron413@adelphia.net>

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! ]