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)
    {
    }

    vector(vector<T,CudaMemory,memory_traits_inte,grow_policy_double,STD_VECTOR> && v) noexcept
    :err_code(0)
    {
        base.swap(v.base);
    }

    ~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_ */