fork(2) download

copy

template <class T, class Tuple>
  struct Index;
 
  template <class T, class... Types>
  struct Index<T, std::tuple<T, Types...>> {
      static const std::size_t value = 0;
  };
 
  template <class T, class U, class... Types>
  struct Index<T, std::tuple<U, Types...>> {
      static const std::size_t value = 1 + Index<T, std::tuple<Types...>>::value;
  };
 
template<class EnumType, template<class T, T> class Element, EnumType... enumValues>
class Map
  {
  public:
    using Type = std::tuple<Element<EnumType, enumValues>...>;
 
    template<EnumType enumValue>
      using index = Index<Element<EnumType, enumValue>, Type>;
 
    template<EnumType enumValue>
    Element<EnumType, enumValue>& get();
 
    Type storage_;
  };
 
template<class EnumType, template<class T, T> class StorageElement, EnumType... enumValues>
template<EnumType enumValue>
StorageElement<EnumType, enumValue>& Map<EnumType, StorageElement, enumValues...>::get()
  {
  return std::get<index<enumValue>::value>(storage_);
  }

prog.cpp:5:19: error: ‘tuple’ is not a member of ‘std’
   struct Index<T, std::tuple<T, Types...>> {
                   ^~~
prog.cpp:5:19: error: ‘tuple’ is not a member of ‘std’
prog.cpp:5:38: error: wrong number of template arguments (3, should be 2)
   struct Index<T, std::tuple<T, Types...>> {
                                      ^~~
prog.cpp:2:10: note: provided for ‘template<class T, class Tuple> struct Index’
   struct Index;
          ^~~~~
prog.cpp:5:41: error: expected unqualified-id before ‘>’ token
   struct Index<T, std::tuple<T, Types...>> {
                                         ^~
prog.cpp:10:19: error: ‘tuple’ is not a member of ‘std’
   struct Index<T, std::tuple<U, Types...>> {
                   ^~~
prog.cpp:10:19: error: ‘tuple’ is not a member of ‘std’
prog.cpp:10:38: error: wrong number of template arguments (3, should be 2)
   struct Index<T, std::tuple<U, Types...>> {
                                      ^~~
prog.cpp:2:10: note: provided for ‘template<class T, class Tuple> struct Index’
   struct Index;
          ^~~~~
prog.cpp:10:41: error: expected unqualified-id before ‘>’ token
   struct Index<T, std::tuple<U, Types...>> {
                                         ^~
prog.cpp:18:23: error: ‘tuple’ in namespace ‘std’ does not name a template type
     using Type = std::tuple<Element<EnumType, enumValues>...>;
                       ^~~~~
prog.cpp:21:57: error: ‘Type’ was not declared in this scope
       using index = Index<Element<EnumType, enumValue>, Type>;
                                                         ^~~~
prog.cpp:21:61: error: template argument 2 is invalid
       using index = Index<Element<EnumType, enumValue>, Type>;
                                                             ^
prog.cpp:26:5: error: ‘Type’ does not name a type
     Type storage_;
     ^~~~
prog.cpp: In member function ‘StorageElement<EnumType, enumValue>& Map<EnumType, Element, enumValues>::get()’:
prog.cpp:33:10: error: ‘get’ is not a member of ‘std’
   return std::get<index<enumValue>::value>(storage_);
          ^~~
prog.cpp:33:19: error: ‘index’ was not declared in this scope
   return std::get<index<enumValue>::value>(storage_);
                   ^~~~~
prog.cpp:33:35: error: ‘::value’ has not been declared
   return std::get<index<enumValue>::value>(storage_);
                                   ^~
prog.cpp:33:44: error: ‘storage_’ was not declared in this scope
   return std::get<index<enumValue>::value>(storage_);
                                            ^~~~~~~~

Standard output is empty