#include <boost/mpl/pair.hpp>
#include <bitset>
#include <climits>
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... Pairs
  >
struct enums_offsets_impl
;  
  template
  < typename Derived
  >
struct enums_offsets_impl
  < Derived
  >
{
        static 
      unsigned const
    offset=0;
 protected://only allow subclasses to access get_ol.
      unsigned char const*
    get_ol()const
    {
        return static_cast<Derived const&>(*this).buffer();
    }
      unsigned char*
    put_ol()
    {
        return static_cast<Derived&>(*this).buffer();
    }
};  
  template
  < typename Derived
  , typename Tag
  , typename Enum
  , typename... Pairs
  >
struct enums_offsets_impl
  < Derived
  , pair<Tag,Enum>
  , Pairs...
  >
: enums_offsets_impl
  < Derived
  , Pairs...
  >  
{
        typedef
      enums_offsets_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(Tag)'s from super types
      //in scope.
      ;  
      using super_t::
    put_ol
      //bring overloaded get_ol(Tag)'s from super types
      //in scope.
      ;  
      Enum
    get_ol(Tag*)const
      {
          unsigned const beg_bit=super_t::offset%CHAR_BIT;
          unsigned char const*pc=get_ol();
          void const*pv=static_cast<void const*>(pc);
          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)[beg_bit+i];
          unsigned long l=eb.to_ulong();
          Enum e=Enum(l);
          return e;
      }
      void
    put_ol(Tag*, Enum e)
      {
          unsigned const beg_bit=super_t::offset%CHAR_BIT;
          unsigned char*pc=put_ol();
          void*pv=static_cast<void*>(pc);
          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)[beg_bit+i]=eb[i];
      }
};  
  template
  < typename... Pairs
  >
struct enums_offsets
;
  template
  < typename... Tags
  , typename... Enums
  >
struct enums_offsets
  < pair<Tags,Enums>...
  >
: enums_offsets_impl
  < enums_offsets
    < pair<Tags,Enums>...
    >//the CRTP pattern.
  , pair<Tags,Enums>...
  >
{
        typedef
      enums_offsets
      < pair<Tags,Enums>...
      >
    this_t
      ;
        typedef
      enums_offsets_impl
      < this_t
      , pair<Tags,Enums>...
      >
    super_t
      ;
      friend class
    enums_offsets_impl
      < this_t
      >
      //Allow top class to access the buffer() member function.
      //That access is in protected section
      //of top class, which thus allows all 
      //subclasses to access buffer().
      ;
 private:      
      unsigned char
    my_buffer
      [ super_t::offset/CHAR_BIT
      ]
      ;
      unsigned char const*
    buffer()const
      {
          return my_buffer;
      }
      unsigned char*
    buffer()
      {
          return my_buffer;
      }
 public:      
    enums_offsets()
      {
          for(unsigned i=0; i<super_t::offset; ++i)
            my_buffer[i]=i;
      }
      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
  enums_offsets
  < pair<T1,E1>
  , pair<T2,E2>
  , pair<T3,E3>
  >
eos_t;

#include <iostream>
int main()
{
    std::cout<<":eos_t::offset="<<eos_t::offset<<"\n";
    eos_t eos_v;
    //std::cout<<":eos_v.buffer()[2]="<<eos_v.buffer()[2]<<"\n";
    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>(e11);
    eos_v.put<T2>(e22);
    eos_v.put<T3>(e33);
    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;
}