map_vector_std_ptr.hpp

/*
 * map_vector_std_ptr.hpp
 *
 *  Created on: Feb 9, 2016
 *      Author: i-bird
 */

#ifndef OPENFPM_DATA_SRC_VECTOR_MAP_VECTOR_STD_PTR_HPP_
#define OPENFPM_DATA_SRC_VECTOR_MAP_VECTOR_STD_PTR_HPP_


template<typename T,typename gp>
class vector<T,PtrMemory,memory_traits_lin,gp,STD_VECTOR>
{
    typedef typename memory_traits_lin<T>::type layout;

    template <typename lb> using layout_base = memory_traits_lin<lb>;

    size_t v_size;

    PtrMemory * mem;

    size_t err_code;

public:

    typedef int yes_i_am_vector;

    typedef vector_key_iterator iterator_key;
    typedef T value_type;

    inline size_t size() const
    {
        return v_size;
    }


    inline void resize(size_t slot)
    {
        // resize is valid only if v_size is 0 and it match the size of PtrMemory
        if (slot > mem->size()/sizeof(T))
            std::cerr << __FILE__ << ":" << __LINE__ << " error: this vector cannot be bigger than " << mem->size()/sizeof(T) << " elements\n";
        v_size = slot;
    }

    inline void clear()
    {
        v_size = 0;
    }

    inline void add(const T & v)
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " error: you cannot add a new element to this vector \n";
    }

    inline void add(T && v)
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " error: you cannot add new element to this vector \n";
    }

    inline void add()
    {
        v_size++;

        if (v_size > mem->size()/sizeof(T))
            std::cerr << __FILE__ << ":" << __LINE__ << " error: you cannot resize a PtrMemory vector over the size stored by PtrMemory";
    }

    void erase(typename std::vector<T>::iterator start, typename std::vector<T>::iterator end)
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " error: you cannot erase element from this vector \n";
    }

    void remove(size_t key)
    {
#ifdef SE_CLASS1
        vector_overflow(key);
#endif
        std::cerr << __FILE__ << ":" << __LINE__ << " error: you cannot remove elements from this vector \n";
    }

    inline T * begin()
    {
        return mem->getPointer();
    }

    inline T * end()
    {
        return &((T *)mem->getPointer())[v_size];
    }

    inline const T * begin() const
    {
        return (T *)mem->getPointer();
    }

    inline const T * end() const
    {
        return &((T *)mem->getPointer())[v_size];
    }

    inline T & last()
    {
#ifdef SE_CLASS1
        if (v_size == 0)
            std::cerr << "Error vector: " << __FILE__ << ":" << __LINE__ << " vector of size 0\n";
#endif
        return ((T *)mem->getPointer())[v_size-1];
    }

    inline const T & last() const
    {
#ifdef SE_CLASS1
        if (v_size == 0)
            std::cerr << "Error vector: " << __FILE__ << ":" << __LINE__ << " vector of size 0" << std::endl;
#endif
        return ((T *)mem->getPointer())[v_size-1];
    }

    template <unsigned int p>inline T& get(size_t id)
    {
#ifdef SE_CLASS1
        if (p != 0)
        {std::cerr << "Error the property does not exist" << "\n";}

        vector_overflow(id);
#endif

        return ((T *)mem->getPointer())[id];
    }

    inline void setMemory(PtrMemory & mem)
    {
        this->mem = &mem;
    }

    template <unsigned int p>inline const T& get(size_t id) const
    {
#ifdef SE_CLASS1
        if (p != 0)
        {std::cerr << "Error the property does not exist" << "\n";}

        vector_overflow(id);
#endif

        return ((T *)mem->getPointer())[id];
    }

    inline T & get(size_t id)
    {
#ifdef SE_CLASS1
        if (id >= v_size)
            std::cerr << "Error vector: " << __FILE__ << ":" << __LINE__ << " overflow id: " << id << "\n";
#endif
        return ((T *)mem->getPointer())[id];
    }

    inline const T & get(size_t id) const
    {
#ifdef SE_CLASS1
        vector_overflow(id);
#endif
        return ((T *)mem->getPointer())[id];
    }

    inline void fill(unsigned char fl)
    {
        memset(mem->getPointer(),fl,v_size * sizeof(T));
    }

    inline void reserve(size_t ns)
    {
    }

    vector() noexcept
    :v_size(0),mem(NULL),err_code(0)
    {
    }

    vector(size_t sz) noexcept
    :v_size(sz),err_code(0)
    {
    }

    vector(const vector<T,PtrMemory,layout_base,gp,STD_VECTOR> & v) noexcept
    :v_size(0),err_code(0)
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " error: copy constructor is not supported by this vector \n";
    }


    vector(vector<T,PtrMemory,layout_base,gp,STD_VECTOR> && v) noexcept
    :v_size(0),err_code(0)
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " error: copy constructor is not supported by this vector \n";
    }

    ~vector() noexcept
    {
    }

    void swap(openfpm::vector<T,PtrMemory,layout_base,gp,STD_VECTOR> & v)
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " error: swap is not supported by this vector \n";
    }

    vector<T,HeapMemory,layout_base,grow_policy_double,STD_VECTOR> & operator=(const vector<T,HeapMemory,layout_base,grow_policy_double,STD_VECTOR> & v)
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " error: operator= is not supported by this vector \n";

        return *this;
    }

    vector<T,HeapMemory,layout_base,grow_policy_double,STD_VECTOR> & operator=(vector<T,HeapMemory,layout_base,grow_policy_double,STD_VECTOR> && v)
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " error: operator= is not supported by this vector \n";

        return *this;
    }

    bool operator!=(const vector<T, HeapMemory, layout_base,grow_policy_double,STD_VECTOR> & v) const
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " error: operator!= is not supported by this vector \n";

        return false;
    }

    bool operator==(const vector<T, HeapMemory, layout_base,grow_policy_double,STD_VECTOR> & v) const
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " error: operator== is not supported by this vector \n";

        return false;
    }

    vector_key_iterator getIterator() const
    {
        return vector_key_iterator(v_size);
    }

#ifdef CUDA_GPU

    template<unsigned int ... prp> void hostToDevice()
    {}

    template<unsigned int ... prp> void deviceToHost()
    {}

    template<unsigned int ... prp> void deviceToHost(size_t start, size_t stop)
    {}

#endif

    void * getPointer()
    {
        return mem->getPointer();
    }

    const void * getPointer() const
    {
        return mem->getPointer();
    }

    static bool noPointers()
    {
        return false;
    }

    size_t getLastError()
    {
        return err_code;
    }

    inline void vector_overflow(size_t v1) const
    {
        if (v1 >= v_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 /* OPENFPM_DATA_SRC_VECTOR_MAP_VECTOR_STD_PTR_HPP_ */