host_vector.h

Go to the documentation of this file.

/*
 *  Copyright 2008-2018 NVIDIA Corporation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */


#pragma once

#include <thrust/detail/config.h>
#include <thrust/detail/memory_wrapper.h>
#include <thrust/detail/vector_base.h>
#include <vector>
#include <utility>

THRUST_NAMESPACE_BEGIN

template<typename T, typename Alloc = std::allocator<T> >
  class host_vector
    : public detail::vector_base<T,Alloc>
{
  private:
    typedef detail::vector_base<T,Alloc> Parent;

  public:
    typedef typename Parent::size_type  size_type;
    typedef typename Parent::value_type value_type;
    __host__
    host_vector(void)
      :Parent() {}

    __host__
    host_vector(const Alloc &alloc)
      :Parent(alloc) {}

    //  Define an empty destructor to explicitly specify
    //  its execution space qualifier, as a workaround for nvcc warning
    __host__
    ~host_vector(void) {}

    __host__
    explicit host_vector(size_type n)
      :Parent(n) {}

    __host__
    explicit host_vector(size_type n, const Alloc &alloc)
      :Parent(n,alloc) {}

    __host__
    explicit host_vector(size_type n, const value_type &value)
      :Parent(n,value) {}

    __host__
    explicit host_vector(size_type n, const value_type &value, const Alloc &alloc)
      :Parent(n,value,alloc) {}

    __host__
    host_vector(const host_vector &v)
      :Parent(v) {}

    __host__
    host_vector(const host_vector &v, const Alloc &alloc)
      :Parent(v,alloc) {}

  #if THRUST_CPP_DIALECT >= 2011

     __host__
    host_vector(host_vector &&v)
      :Parent(std::move(v)) {}

     __host__
    host_vector(host_vector &&v, const Alloc &alloc)
      :Parent(std::move(v),alloc) {}
  #endif

  __host__
  host_vector &operator=(const host_vector &v)
  { Parent::operator=(v); return *this; }

  #if THRUST_CPP_DIALECT >= 2011

     __host__
     host_vector &operator=(host_vector &&v)
     { Parent::operator=(std::move(v)); return *this; }
  #endif

    template<typename OtherT, typename OtherAlloc>
    __host__
    host_vector(const host_vector<OtherT,OtherAlloc> &v)
      :Parent(v) {}

    template<typename OtherT, typename OtherAlloc>
    __host__
    host_vector &operator=(const host_vector<OtherT,OtherAlloc> &v)
    { Parent::operator=(v); return *this; }

    template<typename OtherT, typename OtherAlloc>
    __host__
    host_vector(const std::vector<OtherT,OtherAlloc> &v)
      :Parent(v) {}

    template<typename OtherT, typename OtherAlloc>
    __host__
    host_vector &operator=(const std::vector<OtherT,OtherAlloc> &v)
    { Parent::operator=(v); return *this;}

    template<typename OtherT, typename OtherAlloc>
    __host__
    host_vector(const detail::vector_base<OtherT,OtherAlloc> &v)
      :Parent(v) {}

    template<typename OtherT, typename OtherAlloc>
    __host__
    host_vector &operator=(const detail::vector_base<OtherT,OtherAlloc> &v)
    { Parent::operator=(v); return *this; }

    template<typename InputIterator>
    __host__
    host_vector(InputIterator first, InputIterator last)
      :Parent(first, last) {}

    template<typename InputIterator>
    __host__
    host_vector(InputIterator first, InputIterator last, const Alloc &alloc)
      :Parent(first, last, alloc) {}

// declare these members for the purpose of Doxygenating them
// they actually exist in a derived-from class
#if 0

    void resize(size_type new_size, const value_type &x = value_type());

    size_type size(void) const;

    size_type max_size(void) const;

    void reserve(size_type n);

    size_type capacity(void) const;

    void shrink_to_fit(void);

    reference operator[](size_type n);

    const_reference operator[](size_type n) const;

    iterator begin(void);

    const_iterator begin(void) const;

    const_iterator cbegin(void) const;

    reverse_iterator rbegin(void);

    const_reverse_iterator rbegin(void) const;

    const_reverse_iterator crbegin(void) const;

    iterator end(void);

    const_iterator end(void) const;

    const_iterator cend(void) const;

    reverse_iterator rend(void);

    const_reverse_iterator rend(void) const;

    const_reverse_iterator crend(void) const;

    const_reference front(void) const;

    reference front(void);

    const_reference back(void) const;

    reference back(void);

    pointer data(void);

    const_pointer data(void) const;

    void clear(void);

    bool empty(void) const;

    void push_back(const value_type &x);

    void pop_back(void);

    void swap(host_vector &v);

    iterator erase(iterator pos);

    iterator erase(iterator first, iterator last);

    iterator insert(iterator position, const T &x);

    void insert(iterator position, size_type n, const T &x);

    template<typename InputIterator>
    void insert(iterator position, InputIterator first, InputIterator last);

    void assign(size_type n, const T &x);

    template<typename InputIterator>
    void assign(InputIterator first, InputIterator last);

    allocator_type get_allocator(void) const;
#endif // end doxygen-only members
};

template<typename T, typename Alloc>
  void swap(host_vector<T,Alloc> &a, host_vector<T,Alloc> &b)
{
  a.swap(b);
}

THRUST_NAMESPACE_END