//Purpose:
//  Implement a compressed_enum class using:
//
//    http://svn.boost.org/svn/boost/sandbox/variadic_templates/boost/mpl/if_recur.hpp
//
//Motivation:
//  The following post:
//
//    http://article.gmane.org/gmane.comp.lib.boost.user/72228
//
#include <boost/mpl/pair.hpp>
#include <bitset>
#include <climits>
#include <boost/mpl/package.hpp>
#include <boost/mpl/integral_c.hpp>
#include <boost/mpl/if_recur.hpp>
#include <iostream>

  template
  < typename T
  >
struct type_printer
;
  template
  < typename T
  >
  std::ostream&
operator<<
  ( std::ostream& sout
  , type_printer<T> const&
  )
  {
        return type_printer<T>::_(sout);
  }

#define TYPE_PRINTER(TYPE) \
  template\
  <\
  >\
struct type_printer\
  < TYPE\
  >\
{\
        static\
      std::ostream&\
    _\
      ( std::ostream&sout\
      )\
    {\
        return sout<< #TYPE ;\
    }\
};

using namespace boost::mpl;

  template
  < typename Enum //an enumeration.
  >
struct enum_bits
{
        static
      unsigned const
    size=0
      //specializations should return
      //the actual size for given Enum.
      //This size is the number of bits
      //used to hold the value of an Enum.
      ;
};

  template
  < typename FwdSeq
  , typename Bits
  >
struct state_down
{
        typedef
      state_down
    type
    ;
};

  template
  < typename StateDown
  >
struct fwd_not_empty
: false_
{
};  
  template
  < typename FwdHead
  , typename... FwdTail
  , typename Bits
  >
struct fwd_not_empty
  < state_down
    < package<FwdHead, FwdTail...>
    , Bits
    >
  >
: true_
{
};
  template
  < typename StateDown
  >
struct sum_bits
;  
  template
  < typename Tag
  , typename Enum
  , typename... FwdTail
  , unsigned Bits
  >
struct sum_bits
  < state_down
    < package
      < pair< Tag, Enum>
      , FwdTail...
      >
    , integral_c<unsigned,Bits>
    >
  >
{
        typedef
      state_down
      < package
        <  FwdTail...
        >
      , integral_c<unsigned,Bits+enum_bits<Enum>::size>
      >
    type
    ;
};

  template
  < unsigned Bits
  >
struct sum_bits
  < state_down
    < package
      <
      >
    , integral_c<unsigned,Bits>
    >
  >
{
        typedef
      integral_c<unsigned,Bits>
    type
    ;
};

  template
  < typename StateDown
  , typename StateUp
  >
struct inherit_get_put
;
  template
  < typename Tag
  , typename Enum
  , typename... FwdTail
  , typename Bits
  , typename StateUp
  >
struct inherit_get_put
  < state_down
    < package< pair< Tag, Enum>, FwdTail...>
    , Bits
    >
  , StateUp
  >
{
      struct
    type
      : StateUp
      {
              typedef
            StateUp
          super_t
          ;
              static
            unsigned const
          offset=super_t::offset-enum_bits<Enum>::size
            ;
            using super_t::
          get_ol
            //bring overloaded get_ol's from super types
            //in scope.
            ;  
            using super_t::
          put_ol
            //bring overloaded put_ol's from super types
            //in scope.
            ;  
            Enum
          get_ol( Tag*)const
            {
                return this->template get_ol<Enum,offset>();
            }
            void
          put_ol( Tag*, Enum e)
            {
                this->template put_ol<Enum,offset>(e);
            }
      };
};

  template
  < typename StateDown
  >
struct top_storage
;  
  template
  < unsigned Bits
  >
struct top_storage
  <  state_down
     < package<>
     , integral_c<unsigned,Bits>
     >
  >
  /**@brief
   *  Create storage.
   */
{
      struct 
    type
      {
              static
            unsigned const
          size_bits=Bits
            ;
              static
            unsigned const
          offset=Bits
            ;
            template
            < typename Enum
            , unsigned Offset
            >
            Enum
          get_ol()const
            {
                unsigned const n=enum_bits<Enum>::size;
                std::bitset<n> eb;
                for( unsigned i=0; i<n; ++i) eb[i]=my_bits[Offset+i];
                Enum e=Enum(eb.to_ulong());
                std::cout<<":get_ol<"<<type_printer<Enum>()<<","<<Offset<<">";
                return e;
            }
            template
            < typename Enum
            , unsigned Offset
            >
            void
          put_ol( Enum e)
            {
                unsigned const n=enum_bits<Enum>::size;
                std::bitset<n> eb(e);
                for( unsigned i=0; i<n; ++i) my_bits[Offset+i]=eb[i];
            }
       private:
            std::bitset<Bits>
          my_bits
            ;            
      };
};

  template
  < typename... Pairs
  >
struct compressed_enums
;
  template
  < typename... Tags
  , typename... Enums
  >
struct compressed_enums
  < pair<Tags,Enums>...
  >
: if_recur
  < state_down
    < package< pair< Tags, Enums>...>
    , integral_c< unsigned, 0>
    >
  , fwd_not_empty< arg< 1> >
  , sum_bits< arg<1> >
  , inherit_get_put< arg<1>, arg<2> >
  , top_storage< arg<1> >
  >::type
{
        typedef
      compressed_enums
      < pair<Tags,Enums>...
      >
    this_t
      ;
        typedef
      typename if_recur
      < state_down
        < package< pair< Tags, Enums>...>
        , integral_c< unsigned, 0>
        >
      , fwd_not_empty< arg< 1> >
      , sum_bits< arg<1> >
      , inherit_get_put< arg<1>, arg<2> >
      , top_storage< arg<1> >
      >::type
    super_t
      ;
 public:      
    compressed_enums()
      {
      }
      template
      < typename Tag
      >
    struct get_result
      {
              typedef
            decltype((static_cast<super_t*>(0))->get_ol(static_cast<Tag*>(0)))
          type;
      };
      template
      < typename Tag
      >
      typename get_result<Tag>::type
    get()const
      {
          return this->super_t::get_ol((Tag*)0);
      }
      template
      < typename Tag
      , typename Enum
      >
      void
    put( Enum e)
      {
          this->super_t::put_ol((Tag*)0, e);
      }
};

enum E1{e11,e12};
enum E2{e21,e22,e23};
enum E3{e31,e32,e33,e34};

struct T1;
struct T2;
struct T3;

TYPE_PRINTER(T1)
TYPE_PRINTER(T2)
TYPE_PRINTER(T3)
TYPE_PRINTER(E1)
TYPE_PRINTER(E2)
TYPE_PRINTER(E3)

template<>struct enum_bits<E1>
{  static unsigned const size=2;
};
template<>struct enum_bits<E2>
{  static unsigned const size=3;
};
template<>struct enum_bits<E3>
{  static unsigned const size=4;
};
    typedef
  compressed_enums
  < pair<T1,E1>
  , pair<T2,E2>
  , pair<T3,E3>
  >
eos_t;

int main()
{
    std::cout<<":eos_t::size_bits="<<eos_t::size_bits<<"\n";
    eos_t eos_v;
    std::cout<<":get_ol(T1)="<<eos_v.get_ol((T1*)0)<<"\n";
    std::cout<<":get_ol(T2)="<<eos_v.get_ol((T2*)0)<<"\n";
    std::cout<<":get_ol(T3)="<<eos_v.get_ol((T3*)0)<<"\n";
    std::cout<<":get<T3>="<<eos_v.get<T3>()<<"\n";
    std::cout<<"putting:\n";
    eos_v.put<T1>(e12);
    eos_v.put<T2>(e23);
    eos_v.put<T3>(e34);
    std::cout<<":get<T1>="<<eos_v.get<T1>()<<"\n";
    std::cout<<":get<T2>="<<eos_v.get<T2>()<<"\n";
    std::cout<<":get<T3>="<<eos_v.get<T3>()<<"\n";
    return 0;
}