#include <boost/mpl/pair.hpp>
#include <bitset>
#include <climits>
#include <boost/iostreams/utility/indent_scoped_ostreambuf.hpp>

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 Derived
  , typename... Pairs
  >
struct compressed_enums_impl
;  
  template
  < typename Derived
  >
struct compressed_enums_impl
  < Derived
  >
{
        static 
      unsigned const
    offset=0;
 protected:
   //only allow subclasses to access Derived::storage().
      void const*
    get_ol()const
      {
          return static_cast<Derived const*>(this)->storage();
      }
      void*
    put_ol()
      {
          return static_cast<Derived*>(this)->storage();
      }
};  
  template
  < typename Derived
  , typename Tag
  , typename Enum
  , typename... Pairs
  >
struct compressed_enums_impl
  < Derived
  , pair<Tag,Enum>
  , Pairs...
  >
: compressed_enums_impl
  < Derived
  , Pairs...
  >  
{
        typedef
      compressed_enums_impl
      < Derived
      , Pairs...
      >  
    super_t;
        static 
      unsigned const
    offset=enum_bits<Enum>::size+super_t::offset;
    
      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
      {
          void const*pv=get_ol();
          std::bitset<offset>const&pb=*static_cast<std::bitset<offset>const*>(pv);
          unsigned const size=enum_bits<Enum>::size;
          std::bitset<size> eb;
          for(unsigned i=0; i<size; ++i) eb[i]=pb[super_t::offset+i];
          unsigned long l=eb.to_ulong();
          Enum e=Enum(l);
          return e;
      }
      void
    put_ol(Tag*, Enum e)
      {
          void*pv=put_ol();
          std::bitset<offset>&pb=*static_cast<std::bitset<offset>*>(pv);
          unsigned const size=enum_bits<Enum>::size;
          unsigned long l=e;
          std::bitset<size> eb(l);
          for(unsigned i=0; i<size; ++i) pb[super_t::offset+i]=eb[i];
      }
};  
  template
  < typename... Pairs
  >
struct compressed_enums
;
  template
  < typename... Tags
  , typename... Enums
  >
struct compressed_enums
  < pair<Tags,Enums>...
  >
: compressed_enums_impl
  < compressed_enums
    < pair<Tags,Enums>...
    >//the CRTP pattern.
  , pair<Tags,Enums>...
  >
{
        typedef
      compressed_enums
      < pair<Tags,Enums>...
      >
    this_t
      ;
        typedef
      compressed_enums_impl
      < this_t
      , pair<Tags,Enums>...
      >
    super_t
      ;
      friend class
    compressed_enums_impl
      < this_t
      >
      //Allow top class to access the storage() member function.
      //That access is in protected section
      //of top class, which thus allows all 
      //subclasses to access storage().
      ;
 private:      
      std::bitset<super_t::offset>
    my_bitset
      ;
      void const*
    storage()const
      {
          return static_cast<void const*>(&my_bitset);
      }
      void*
    storage()
      {
          return static_cast<void*>(&my_bitset);
      }
 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)
      {
          return 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;

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;

  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 ;\
    }\
};
TYPE_PRINTER(T1)
TYPE_PRINTER(T2)
TYPE_PRINTER(T3)
TYPE_PRINTER(E1)
TYPE_PRINTER(E2)
TYPE_PRINTER(E3)

  template
  < typename Derived
  >
struct type_printer
  < compressed_enums_impl
    < Derived
    >
  >
{
        typedef
      compressed_enums_impl
      < Derived
      >
    this_t;
        static 
      std::ostream&
    _
      ( std::ostream&sout
      )
    {
        sout<<"compressed_enums_impl\n< Derived\n>::offset="<<this_t::offset<<"\n";
        return sout;
    }
};
  
  template
  < typename Derived
  , typename Tag
  , typename Enum
  , typename... Pairs
  >
struct type_printer
  < compressed_enums_impl
    < Derived
    , pair<Tag,Enum>
    , Pairs...
    >
  >
{
        typedef
      compressed_enums_impl
      < Derived
      , pair<Tag,Enum>
      , Pairs...
      >
    this_t;
        static 
      std::ostream&
    _
      ( std::ostream&sout
      )
    {
        sout<<"compressed_enums_impl"
        <<"\n< "<<"Derived"
        <<", pair< "<<type_printer<Tag>()<<", "<<type_printer<Enum>()<<"> \n"
        <<", "
        <<indent_buf_in
        <<type_printer<typename this_t::super_t>()
        <<indent_buf_out
        <<">::offset="<<this_t::offset<<"\n";
        return sout;
    }
};
  
int main()
{
    boost::iostreams::indent_scoped_ostreambuf<char> indent_outbuf(std::cout,2);
    std::cout<<":eos_t::offset="<<eos_t::offset<<"\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<"<<type_printer<T1>()<<">="<<eos_v.get<T1>()<<"\n";
    std::cout<<":get<T2>="<<eos_v.get<T2>()<<"\n";
    std::cout<<":get<T3>="<<eos_v.get<T3>()<<"\n";
    std::cout<<type_printer<eos_t::super_t>();
    return 0;
}