#include <boost/mpl/pair.hpp>
using namespace boost::mpl;
  template
  < typename Enum
  >
struct enum_size
{
        static
      unsigned const
    size=0
      //specializations should return
      //the actual value for given Enum.
      ;
};  
  template
  < typename... Pairs
  >
struct enums_offsets_impl
;  
  template
  < typename Derived
  >
struct enums_offsets_impl
  < Derived
  >
{
        static 
      unsigned const
    offset=0;
    
      int*
    get()
    {
        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_size<Enum>::size+super_t::offset;
    
      using super_t::
    get
      //bring overloaded get(Tag)'s from super types
      //in scope.
      ;  
      int
    get(Tag)
      {
          return get()[super_t::offset];
      }
};  
  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>...
    >
  , pair<Tags,Enums>...
  >
{
        typedef
      enums_offsets_impl
      < enums_offsets
        < pair<Tags,Enums>...
        >
      , pair<Tags,Enums>...
      >
    super_t;
    
      int
    my_buffer[super_t::offset];
    enums_offsets()
      {
          for(unsigned i=0; i<super_t::offset; ++i)
            my_buffer[i]=i;
      }
      int*
    buffer()
      {
          return my_buffer;
      }
};

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

struct T1{};
struct T2{};
struct T3{};

template<>struct enum_size<E1>
{  static unsigned const size=2;
};
template<>struct enum_size<E2>
{  static unsigned const size=3;
};
template<>struct enum_size<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(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;
}