[Boost-users] Re: Metaprogramming woes

From: David Abrahams (dave_at_[hidden])
Date: 2005-05-31 14:24:21

"White Wolf" <wolof_at_[hidden]> writes:

> Hi Dave,

Hi Atilla,

In future please post your questions to the boost-users list so that
the whole community can benefit.

> I am trying to do something very simple, but I am going bananas.  I have
> types, each of them has a "static member" (enum label) called nr_.  I
> make a boost::mpl::list of them, and I would like to add them all
> together.  But if I write _2::nr_, it says there is no nr_.  

Well, the author of _2 can't anticipate all the nested values you
might be using.  _2 is not magic; it's just a type.

  // !! untested code !!
  #include <boost/mpl/size_t.hpp>
  #include <boost/mpl/plus.hpp>
  using namespace mpl::placeholders;

  // A metafunction to get an Element's ::nr_ value
  template <class Element>
  struct get_nr_
  {
      // all metadata are types, so wrap it in a type.
      typedef mpl::size_t<Element::nr_> type; 
  };

  typedef mpl::fold<
      some_list, mpl::size_t<0>
    , mpl::plus<
          _1
        , get_nr_<_2> 
      >
  >::type sum;

  // sum::value contains the value you're interested in.

> I fugured it wants a type.  So I have made a typedef inside called
> type, which has a boost::mpl::integer_c<size_t, nr_> in it.  But it
> does not work, it gives me back the type of the last list element as
> a result.  I try to use mpl::accumulate.  

Yes, that's a synonym for fold if you have a version of the MPL that
includes accumulate.

> Finally I guess I will have to use transform in some way, because I
> need a list which has an mpl::pair (if there is one) 

http://www.boost.org/libs/mpl/doc/refmanual/pair.html

> of the original type and the sum of all nr_'s before it.

Seems like it's still a job for fold.  In this case I'd use mpl::vector
because lists can only be push_front-ed and you probably don't want to
end up with your elements in "reverse" order.

  typedef mpl::fold<
      some_list

    , mpl::pair<                // initial state
          mpl::vector0          // initial sequence
        , mpl::size_t<0>        // initial sum
      >

    , mpl::pair<               // the state at each step is a pair containing

          mpl::push_front<     // added to the front of...
               mpl::first<_1> // the sequence from the previous step

             , mpl::pair<     // a new element, a pair containing
                   _2         // the original type

                  , mpl::plus<         // and the sum of 
                       mpl::second<_1> // the sum from previous step
                     , get_nr_<_2>     // the ::nr_ of the original type
                   >
               >
          >

        , mpl::plus<          // and the sum of 
              mpl::second<_1> // the sum from previous step
            , get_nr_<_2>     // the ::nr_ of the original type
          >
      >
  >::type pair_seq_sum;
  
  typedef pair_seq_sum::first new_sequence;

So this is pretty verbose using lambdas because the sum is repeated,
among other things. You might do better to build a custom metafunction
that gets you the new state:

    template <class PrevState, class Element>
    struct next_state
    {
         typedef typename PrevState::first prev_sequence;
         typedef typename PrevState::second prev_sum;
         typedef mpl::size_t<(prev_sum::value + Element::nr_)>  new_sum;
         typedef typename mpl::push_back<
             prev_sequence
           , mpl::pair<Element, new_sum>
         >::type new_sequence;
         typedef mpl::pair<new_sequence, new_sum> type;
    };

    typedef mpl::fold< some_list, mpl::fold<_,_> >::type pair_seq_sum;

    typedef pair_seq_sum::first new_sequence;

> Can you help me?  I have
> something like this:
>
> struct T1 {
>   enum x {
>     label1,
>     label2,
>     nr_;
>   };
> };
>
> // Same for T2, possibly less or more labels etc.
>
> And I would like to end up with a type which looks like this:
>
> struct something {
>   int get(T1::x n) {
>     return arr_[n];
>   }
>   int get(T2::x n) {
>     return arr_[n+2];

Where does n+2 come from?

>   }
>   // etc.
> private:
>     int arr_[sum_of_all_nr_];
> };

?? that doesn't look anything like what you just described.

Sheesh.  The above is still a job for fold.

I suggest you start with a base type:

  template <class Derived>
  struct base
  {
      enum { sum = 0 };
      void get(); // never used.
  };

then build layers:

  template <class Base, class T, class MostDerived>
  struct layer : mpl::apply<Base, MostDerived>::type
  {
       typedef typename mpl::apply<Base, MostDerived>::type super;

       enum { sum = T::nr_ + super::sum };

       using Base::get;

       int get(T::x n)
       {
           return static_cast<MostDerived*>(this)->arr_[n];
       }
  };

  template <class Folded>
  struct outer : Folded
  {
       int arr_[Folded::sum];
  };

Well, the above "solution" won't work and I don't have time to write
something that does for you right now.  It would take maybe another 15
minutes and I've already spent 30 on this email.  I guess you'll
probably do best to make 2 passes over the sequence: one to compute
the sums and the other to build the result type.  Good luck!

-- 
Dave Abrahams
Boost Consulting
www.boost-consulting.com