// In header: </home/travis/build/martinjrobins/Aboria/src/Traits.h>

template<typename traits, unsigned int DomainD, unsigned int SelfD, 
         typename... TYPES> 
struct TraitsCommon<std::tuple< TYPES...>, DomainD, SelfD, traits> : public traits {
  // types
  typedef typename traits::template tuple_type< T...>::type                                                                                                                                                                                                                                     tuple;                               
  typedef typename traits::template tuple_element< I, T >::type                                                                                                                                                                                                                                 tuple_element;                       
  typedef typename traits::template vector_type< T >::type                                                                                                                                                                                                                                      vector;                              
  typedef vector< Vector< double, DomainD > >                                                                                                                                                                                                                                                   vector_double_d;                     
  typedef vector_double_d::iterator                                                                                                                                                                                                                                                             vector_double_d_iterator;            
  typedef vector_double_d::const_iterator                                                                                                                                                                                                                                                       vector_double_d_const_iterator;      
  typedef traits::template vector_type< Vector< int, DomainD > >::type                                                                                                                                                                                                                          vector_int_d;                        
  typedef traits::template vector_type< Vector< unsigned int, DomainD > >::type                                                                                                                                                                                                                 vector_unsigned_int_d;               
  typedef vector_unsigned_int_d::iterator                                                                                                                                                                                                                                                       vector_unsigned_int_d_iterator;      
  typedef vector_unsigned_int_d::const_iterator                                                                                                                                                                                                                                                 vector_unsigned_int_d_const_iterator;
  typedef traits::template vector_type< Vector< bool, DomainD > >::type                                                                                                                                                                                                                         vector_bool_d;                       
  typedef traits::template vector_type< int >::type                                                                                                                                                                                                                                             vector_int;                          
  typedef traits::template vector_type< double >::type                                                                                                                                                                                                                                          vector_double;                       
  typedef traits::template vector_type< size_t >::type                                                                                                                                                                                                                                          vector_size_t;                       
  typedef traits::template vector_type< unsigned int >::type                                                                                                                                                                                                                                    vector_unsigned_int;                 
  typedef vector_unsigned_int::iterator                                                                                                                                                                                                                                                         vector_unsigned_int_iterator;        
  typedef vector_unsigned_int::const_iterator                                                                                                                                                                                                                                                   vector_unsigned_int_const_iterator;  
  typedef traits::template vector_type< Vector< int, 2 > >::type                                                                                                                                                                                                                                vector_int2;                         
  typedef Vector< double, dimension >                                                                                                                                                                                                                                                           double_d;                            
  typedef Vector< int, dimension >                                                                                                                                                                                                                                                              int_d;                               
  typedef Vector< unsigned int, dimension >                                                                                                                                                                                                                                                     unsigned_int_d;                      
  typedef Vector< bool, dimension >                                                                                                                                                                                                                                                             bool_d;                              
  typedef std::conditional<(SelfD > 1), particles_d< SelfD >, position_d< dimension > >::type                                                                                                                                                                                                   position;                            
  typedef position::value_type                                                                                                                                                                                                                                                                  position_value_type;                 
  typedef alive::value_type                                                                                                                                                                                                                                                                     alive_value_type;                    
  typedef id::value_type                                                                                                                                                                                                                                                                        id_value_type;                       
  typedef generator::value_type                                                                                                                                                                                                                                                                 random_value_type;                   
  typedef traits::template vector_type< position_value_type >::type                                                                                                                                                                                                                             position_vector_type;                
  typedef traits::template vector_type< alive_value_type >::type                                                                                                                                                                                                                                alive_vector_type;                   
  typedef traits::template vector_type< id_value_type >::type                                                                                                                                                                                                                                   id_vector_type;                      
  typedef traits::template vector_type< random_value_type >::type                                                                                                                                                                                                                               random_vector_type;                  
  typedef traits                                                                                                                                                                                                                                                                                traits_type;                         
  typedef mpl::vector< position, id, alive, generator, TYPES...>                                                                                                                                                                                                                                mpl_type_vector;                     
  typedef tuple< typename position_vector_type::iterator, typename id_vector_type::iterator, typename alive_vector_type::iterator, typename random_vector_type::iterator, typename traits::template vector_type< typename TYPES::value_type >::type::iterator...>                               tuple_of_iterators_type;             
  typedef tuple< typename position_vector_type::const_iterator, typename id_vector_type::const_iterator, typename alive_vector_type::const_iterator, typename random_vector_type::const_iterator, typename traits::template vector_type< typename TYPES::value_type >::type::const_iterator...> tuple_of_const_iterators_type;       
  typedef std::tuple< position_vector_type, id_vector_type, alive_vector_type, random_vector_type, typename traits::template vector_type< typename TYPES::value_type >::type...>                                                                                                                vectors_data_type;                   
  typedef Aboria::zip_iterator< tuple_of_iterators_type, mpl_type_vector >                                                                                                                                                                                                                      iterator;                            
  typedef Aboria::zip_iterator< tuple_of_const_iterators_type, mpl_type_vector >                                                                                                                                                                                                                const_iterator;                      
  typedef iterator::reference                                                                                                                                                                                                                                                                   reference;                           
  typedef iterator::value_type                                                                                                                                                                                                                                                                  value_type;                          
  typedef iterator::pointer                                                                                                                                                                                                                                                                     pointer;                             
  typedef iterator::getter_raw_pointer                                                                                                                                                                                                                                                          raw_pointer;                         
  typedef iterator::getter_raw_reference                                                                                                                                                                                                                                                        raw_reference;                       
  typedef const_iterator::getter_raw_reference                                                                                                                                                                                                                                                  raw_const_reference;                 
  typedef const_iterator::reference                                                                                                                                                                                                                                                             const_reference;                     
  typedef Aboria::getter_type< vectors_data_type, mpl_type_vector >                                                                                                                                                                                                                             data_type;                           
  typedef position_vector_type::size_type                                                                                                                                                                                                                                                       size_type;                           
  typedef position_vector_type::difference_type                                                                                                                                                                                                                                                 difference_type;                     

  // public static functions
  template<std::size_t... I> 
    static iterator begin_impl(data_type &, unspecified);
  template<std::size_t... I> 
    static iterator end_impl(data_type &, unspecified);
  template<std::size_t... I> 
    static const_iterator cbegin_impl(const data_type &, unspecified);
  template<std::size_t... I> 
    static const_iterator cend_impl(const data_type &, unspecified);
  template<std::size_t... I> 
    static reference 
    index_impl(data_type &, const size_t, unspecified, std::true_type);
  template<std::size_t... I> 
    static reference 
    index_impl(data_type &, const size_t, unspecified, std::false_type);
  template<std::size_t... I> 
    static const_reference 
    index_const_impl(const data_type &, const size_t, unspecified, 
                     std::true_type);
  template<std::size_t... I> 
    static const_reference 
    index_const_impl(const data_type &, const size_t, unspecified, 
                     std::false_type);
  template<std::size_t... I> static void clear_impl(data_type &, unspecified);
  template<std::size_t... I> 
    static void resize_impl(data_type &, const size_t, unspecified);
  template<std::size_t... I> 
    static void push_back_impl(data_type &, const value_type &, unspecified);
  template<std::size_t... I> 
    static void pop_back_impl(data_type &, unspecified);
  template<std::size_t... I> 
    static iterator erase_impl(data_type &, iterator, unspecified);
  template<std::size_t... I> 
    static iterator erase_impl(data_type &, iterator, iterator, unspecified);
  template<std::size_t... I> 
    static iterator 
    insert_impl(data_type &, iterator, const value_type &, unspecified);
  template<std::size_t... I> 
    static void insert_impl(data_type &, iterator, size_t, const value_type &, 
                            unspecified);
  template<typename InputIterator, std::size_t... I> 
    static iterator 
    insert_impl(data_type &, iterator, InputIterator, InputIterator, 
                unspecified);
  template<typename InputIterator, std::size_t... I> 
    static data_type construct_impl(InputIterator, InputIterator, unspecified);
  template<std::size_t... I> 
    static void header_to_stream_impl(std::ostream &, unspecified);
  template<typename InputIterator, std::size_t... I> 
    static void to_stream_impl(InputIterator, std::ostream &, unspecified);
  template<typename InputIterator, std::size_t... I> 
    static void from_stream_impl(InputIterator, std::istream &, unspecified);
  template<typename Archive, std::size_t... I> 
    static void serialize_impl(const data_type &, Archive &, 
                               const unsigned int, unspecified);
  template<typename Indices = detail::make_index_sequence<N> > 
    static iterator begin(data_type &);
  template<typename Indices = detail::make_index_sequence<N> > 
    static iterator end(data_type &);
  template<typename Indices = detail::make_index_sequence<N> > 
    static const_iterator cbegin(const data_type &);
  template<typename Indices = detail::make_index_sequence<N> > 
    static const_iterator cend(const data_type &);
  template<typename Indices = detail::make_index_sequence<N> > 
    static reference index(data_type &, const size_t);
  template<typename Indices = detail::make_index_sequence<N> > 
    static const_reference index(const data_type &, const size_t);
  template<typename Indices = detail::make_index_sequence<N> > 
    static void clear(data_type &);
  template<typename Indices = detail::make_index_sequence<N> > 
    static void resize(data_type &, const size_t);
  template<typename Indices = detail::make_index_sequence<N> > 
    static void push_back(data_type &, const value_type &);
  template<typename Indices = detail::make_index_sequence<N> > 
    static void pop_back(data_type &);
  template<typename Indices = detail::make_index_sequence<N> > 
    static iterator erase(data_type &, iterator);
  template<typename Indices = detail::make_index_sequence<N> > 
    static iterator erase(data_type &, iterator, iterator);
  template<typename Indices = detail::make_index_sequence<N> > 
    static iterator insert(data_type &, iterator, const value_type &);
  template<typename Indices = detail::make_index_sequence<N> > 
    static void insert(data_type &, iterator, size_t, const value_type &);
  template<typename InputIterator, 
           typename Indices = detail::make_index_sequence<N> > 
    static iterator 
    insert(data_type &, iterator, InputIterator, InputIterator);
  template<typename InputIterator, 
           typename Indices = detail::make_index_sequence<N> > 
    static data_type construct(InputIterator, InputIterator);
  template<typename Indices = detail::make_index_sequence<N> > 
    static void header_to_stream(std::ostream &);
  template<typename InputIterator, 
           typename Indices = detail::make_index_sequence<N> > 
    static void to_stream(InputIterator, std::ostream &);
  template<typename InputIterator, 
           typename Indices = detail::make_index_sequence<N> > 
    static void from_stream(InputIterator, std::istream &);
  template<typename Archive, 
           typename Indices = detail::make_index_sequence<N> > 
    static void serialize(const data_type &, Archive &, const unsigned int);

  // public data members
  static const unsigned int dimension;
  static const size_t N;
};