map_vector_std_cuda.hpp

/*
 * map_vector_std_cuda.hpp
 *
 *  Created on: Mar 7, 2019
 *      Author: i-bird
 */
 
#ifndef MAP_VECTOR_STD_CUDA_HPP_
#define MAP_VECTOR_STD_CUDA_HPP_
 
#include "map_vector_std_cuda_ker.cuh"
 
template<typename T>
class vector<T,CudaMemory,memory_traits_inte,grow_policy_double,STD_VECTOR>
{
    // Memory layout
    typedef typename memory_traits_inte<aggregate<T>>::type layout;
 
    vector<aggregate<T>,CudaMemory,memory_traits_inte,grow_policy_double> base;
 
    size_t err_code = 0;
 
public:
 
    typedef int yes_i_am_vector;
 
    typedef memory_traits_inte<T> layout_base_;
 
    typedef vector_key_iterator iterator_key;
    typedef T value_type;
 
    typedef void base_to_copy;
 
    typedef grow_policy_double grow_policy;
 
    template<typename Tobj>
    struct layout_base__
    {
        typedef memory_traits_inte<Tobj> type;
    };
 
    inline size_t size() const
    {
        return base.size();
    }
 
 
    inline void resize(size_t slot)
    {
        base.resize_no_device(slot);
    }
 
    inline void clear()
    {
        base.clear();
    }
 
    inline void add(const T & v)
    {
        base.add_no_device();
        base.template get<0>(size()-1) = v;
    }
 
    inline void add(T && v)
    {
        base.add_no_device();
        base.template get<0>(size()-1).swap(v);
    }
 
    inline void add()
    {
        base.add_no_device();
    }
 
    inline T & last()
    {
#ifdef SE_CLASS1
        if (base.size() == 0)
            std::cerr << "Error vector: " << __FILE__ << ":" << __LINE__ << " vector of size 0\n";
#endif
        return base.template get<0>(size()-1);
    }
 
    inline const T & last() const
    {
#ifdef SE_CLASS1
        if (base.size() == 0)
            std::cerr << "Error vector: " << __FILE__ << ":" << __LINE__ << " vector of size 0\n";
#endif
        return base.template get<0>(size()-1);
    }
 
    void swap(vector<T,CudaMemory,memory_traits_inte,grow_policy_double,STD_VECTOR> && v)
    {
        base.swap(v.base);
    }
 
    inline T& at(int i)
    {
        return get(i);
    }
 
    inline T& operator[](int id)
    {
#ifdef SE_CLASS1
        vector_overflow(id);
#endif
 
        return base.template get<0>(id);
    }
 
    inline T& get(int id)
    {
#ifdef SE_CLASS1
        vector_overflow(id);
#endif
 
        return base.template get<0>(id);
    }
 
    inline const T& get(int id) const
    {
#ifdef SE_CLASS1
        vector_overflow(id);
#endif
 
        return base.template get<0>(id);
    }
 
    inline T & get(size_t id)
    {
#ifdef SE_CLASS1
        vector_overflow(id);
#endif
        return base.template get<0>(id);
    }
 
    inline const T & get(size_t id) const
    {
#ifdef SE_CLASS1
        vector_overflow(id);
#endif
        return base.template get<0>(id);
    }
 
    inline void reserve(size_t ns)
    {
        base.reserve(ns);
    }
 
    vector() noexcept
    :err_code(0)
    {
    }
 
    vector(size_t sz) noexcept
    :base(sz),err_code(0)
    {
    }
 
    vector(const vector<T,CudaMemory,memory_traits_inte,grow_policy_double,STD_VECTOR> & v) noexcept
    :err_code(0)
    {
        base = v.base;
    }
 
    vector(const std::initializer_list<T> & v)
    // :base(v)
    {
        // causes error if simply passed to base
        for (T t: v)
            add(t);
    }
 
    vector(vector<T,CudaMemory,memory_traits_inte,grow_policy_double,STD_VECTOR> && v) noexcept
    :err_code(0)
    {
        base.swap(v.base);
    }
 
    template< class InputIt >
    vector(InputIt first, InputIt last)
    {
        while(first != last) {
            add(*first);
            ++first;
        }
    }
 
    ~vector() noexcept
    {
    }
 
    void swap(vector<T,CudaMemory,memory_traits_inte,grow_policy_double,STD_VECTOR> & v)
    {
        base.swap(v.base);
    }
 
    vector<T,CudaMemory,memory_traits_inte,grow_policy_double,STD_VECTOR> &
    operator=(const vector<T,CudaMemory,memory_traits_inte,grow_policy_double,STD_VECTOR> & v)
    {
        base = v.base;
 
        return *this;
    }
 
    vector_key_iterator getIterator() const
    {
        return vector_key_iterator(base.size());
    }
 
    vector_key_iterator getIteratorTo(size_t k) const
    {
        return vector_key_iterator(k);
    }
 
    void * getPointer()
    {
        return &base.template get<0>(0);
    }
 
    const void * getPointer() const
    {
        return &base.template get<0>(0);
    }
 
    template<unsigned int ... prp> void hostToDevice()
    {
        base.template hostToDevice<0>();
    }
 
    template<unsigned int ... prp> void deviceToHost()
    {
        base.template deviceToHost<0>();
    }
 
    template<unsigned int ... prp> void deviceToHost(size_t start, size_t stop)
    {
        base.template deviceToHost<0>(start,stop);
    }
 
    template<unsigned int ... prp> void hostToDevice(size_t start, size_t stop)
    {
        base.template hostToDevice<0>(start,stop);
    }
 
    vector_custd_ker<typename apply_transform<memory_traits_inte,aggregate<T>>::type,memory_traits_inte> toKernel()
    {
        vector_custd_ker<typename apply_transform<memory_traits_inte,aggregate<T>>::type,memory_traits_inte> v(base.size(),this->base.toKernel());
 
        return v;
    }
 
    static bool noPointers()
    {
        return false;
    }
 
    size_t getLastError()
    {
        return err_code;
    }
 
    inline void vector_overflow(size_t v1) const
    {
        if (v1 >= base.size())
        {
            std::cerr << "Error vector: " << __FILE__ << ":" << __LINE__ << " overflow id: " << v1 << "\n";\
            size_t * err_code_pointer = (size_t *)&this->err_code;\
            *err_code_pointer = 2001;\
 
            ACTION_ON_ERROR(VECTOR_ERROR_OBJECT);\
        }
    }
};
 
 
#endif /* MAP_VECTOR_STD_CUDA_HPP_ */