Aboria
PrevUpHomeNext

Struct template zip_pointer<thrust::tuple< TT1, TT2, TT3, TT4, TT5, TT6, TT7, TT8, TT9 >, MplVector>

Aboria::zip_pointer<thrust::tuple< TT1, TT2, TT3, TT4, TT5, TT6, TT7, TT8, TT9 >, MplVector> — specialisation of zip_pointer for thrust::tuple

Synopsis

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

template<typename MplVector, typename TT1, typename TT2, typename TT3, 
         typename TT4, typename TT5, typename TT6, typename TT7, typename TT8, 
         typename TT9> 
struct zip_pointer<thrust::tuple< TT1, TT2, TT3, TT4, TT5, TT6, TT7, TT8, TT9 >, MplVector> {
  // types
  typedef thrust::tuple< TT1, TT2, TT3, TT4, TT5, TT6, TT7, TT8, TT9 > tuple_type;     
  typedef MplVector                                                    mpl_vector_type;
  typedef unspecified                                                  elem_by_type;   
  typedef unspecified                                                  return_type;    
  typedef unspecified                                                  reference;      
  typedef unspecified                                                  difference_type;
  typedef unspecified                                                  index_type;     

  // construct/copy/destruct
  zip_pointer();
  explicit zip_pointer(const tuple_type &);
  zip_pointer(const zip_pointer &);
  zip_pointer(zip_pointer &&);
  template<typename tuple_type2, 
           typename  = typename std::enable_if<                std::is_convertible<tuple_type2, tuple_type>::value>::type> 
    zip_pointer(const zip_pointer< tuple_type2, mpl_vector_type > &);
  template<typename tuple_type2, 
           typename  = typename std::enable_if<                std::is_convertible<tuple_type2, tuple_type>::value>::type> 
    zip_pointer(const zip_pointer< tuple_type2, mpl_vector_type > &&);
  template<typename T1, typename T2, typename... T3> 
    zip_pointer(T1 &&, T2 &&, T3 &&...);
  zip_pointer& operator=(const zip_pointer &);
  zip_pointer& operator=(zip_pointer &&);
  template<typename T1, typename T2> 
    zip_pointer& operator=(const zip_pointer< T1, T2 > &);
  template<typename T1, typename T2> 
    zip_pointer& operator=(zip_pointer< T1, T2 > &&);

  // public member functions
  void swap(zip_pointer &);
  const tuple_type & get_tuple() const;
  tuple_type & get_tuple();
  bool operator==(const zip_pointer &) const;
  zip_pointer & operator++();
  zip_pointer operator++(int);
  zip_pointer operator+(const difference_type &) const;
  zip_pointer & operator+=(const difference_type &);
  zip_pointer operator-(const difference_type &) const;
  difference_type operator-(const zip_pointer &) const;
  zip_pointer & operator--();
  zip_pointer operator--(int);
  bool operator<(const zip_pointer &) const;
  bool operator<=(const zip_pointer &) const;
  bool operator>(const zip_pointer &) const;
  bool operator>=(const zip_pointer &) const;
  reference operator*() const;
  void increment();
  void decrement();
  bool equal(zip_pointer const &) const;
  reference dereference() const;
  difference_type distance_to(zip_pointer const &) const;
  void advance(difference_type);

  // public data members
  tuple_type data;
};

Description

Use device only code in this specialisation

zip_pointer public construct/copy/destruct

  1. zip_pointer();
  2. explicit zip_pointer(const tuple_type & data);
  3. zip_pointer(const zip_pointer & other);
  4. zip_pointer(zip_pointer && other);
  5. template<typename tuple_type2, 
         typename  = typename std::enable_if<                std::is_convertible<tuple_type2, tuple_type>::value>::type> 
  zip_pointer(const zip_pointer< tuple_type2, mpl_vector_type > & other);
  6. template<typename tuple_type2, 
         typename  = typename std::enable_if<                std::is_convertible<tuple_type2, tuple_type>::value>::type> 
  zip_pointer(const zip_pointer< tuple_type2, mpl_vector_type > && other);
  7. template<typename T1, typename T2, typename... T3> 
  zip_pointer(T1 && arg1, T2 && arg2, T3 &&... args);
  8. zip_pointer& operator=(const zip_pointer & other);
  9. zip_pointer& operator=(zip_pointer && other);
  10. template<typename T1, typename T2> 
  zip_pointer& operator=(const zip_pointer< T1, T2 > & other);
  11. template<typename T1, typename T2> 
  zip_pointer& operator=(zip_pointer< T1, T2 > && other);

zip_pointer public member functions

  1. void swap(zip_pointer & other);
  2. const tuple_type & get_tuple() const;
  3. tuple_type & get_tuple();
  4. bool operator==(const zip_pointer & other) const;
  5. zip_pointer & operator++();
  6. zip_pointer operator++(int);
  7. zip_pointer operator+(const difference_type & n) const;
  8. zip_pointer & operator+=(const difference_type & n);
  9. zip_pointer operator-(const difference_type & n) const;
  10. difference_type operator-(const zip_pointer & other) const;
  11. zip_pointer & operator--();
  12. zip_pointer operator--(int);
  13. bool operator<(const zip_pointer & other) const;
  14. bool operator<=(const zip_pointer & other) const;
  15. bool operator>(const zip_pointer & other) const;
  16. bool operator>=(const zip_pointer & other) const;
  17. reference operator*() const;
  18. void increment();
  19. void decrement();
  20. bool equal(zip_pointer const & other) const;
  21. reference dereference() const;
  22. difference_type distance_to(zip_pointer const & other) const;
  23. void advance(difference_type n);
Copyright © 2015-2018 Martin Robinson
PrevUpHomeNext