map_vector_std.hpp

/*
 * map_vector_std.hpp
 *
 *  Created on: Mar 8, 2015
 *      Author: i-bird
 */
 
#ifndef MAP_VECTOR_STD_HPP_
#define MAP_VECTOR_STD_HPP_
 
#include "se_vector.hpp"
#include "map_vector_std_ptr.hpp"
 
#define OBJECT_ADD false
#define VECTOR_ADD true
 
template<bool objv, typename vect_dst>
struct add_prp_impl
{
    template <typename S, typename M, typename gp, unsigned int impl, unsigned int ...args> 
    inline static void add(const vector<S,M,memory_traits_lin,gp,impl> & v_src, vect_dst & v_dst)
    {
        for (size_t i = 0 ; i < v_src.size() ; i++)
        {
            // Add a new element
            v_dst.add();
 
            // equal object
            v_dst.get(v_dst.size()-1) = v_src.get(i);
        }
    }
};
 
template<typename vect_dst>
struct add_prp_impl<OBJECT_ADD,vect_dst>
{
    template <typename S, typename M, typename gp, unsigned int impl, unsigned int ...args> inline static void add(const vector<S,M,memory_traits_lin,gp,impl> & v_src, vect_dst & v_dst)
    {
            // Add a new element
            v_dst.add();
 
            // equal object
            v_dst.get(v_dst.size()-1) = v_src;
    }
};
 
 
template<typename T, typename grow_p>
class vector<T,HeapMemory,memory_traits_lin,grow_p,STD_VECTOR>
{
    // Memory layout
    typedef typename memory_traits_lin<T>::type layout;
//      Doeas not work on gcc 4.8.4
//  template <typename lb> using layout_base = memory_traits_lin<lb>;
 
    std::vector<T> base;
 
    size_t err_code = 0;
 
public:
 
    typedef int yes_i_am_vector;
 
    typedef memory_traits_lin<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_lin<Tobj> type;
    };
 
    //This file implements a pack and unpack for std vector
#include "vector_std_pack_unpack.ipp"
 
    inline size_t size() const
    {
        return base.size();
    }
 
 
    inline void resize(size_t slot)
    {
        base.resize(slot);
    }
 
    inline void clear()
    {
        base.clear();
    }
 
    inline void shrink_to_fit()
    {
        base.shrink_to_fit();
    }
 
    inline void add(const T & v)
    {
        if (std::is_same<grow_p,openfpm::grow_policy_identity>::value == true)
        {
            // we reserve just one space more to avoid the capacity to increase by two
            base.reserve(base.size()+1);
        }
 
        base.push_back(v);
    }
 
    inline void add(T && v)
    {
        if (std::is_same<grow_p,openfpm::grow_policy_identity>::value == true)
        {
            // we reserve just one space more to avoid the capacity to increase by two
            base.reserve(base.size()+1);
        }
 
        base.emplace_back(v);
    }
 
    inline void add()
    {
        base.emplace_back(T());
    }
 
    template<typename Mem,template<typename> class lb,typename gp> inline void add(const openfpm::vector<T,Mem,lb,gp> & eles)
    {
        if (std::is_same<grow_p,openfpm::grow_policy_identity>::value == true)
        {
            // we reserve just one space more to avoid the capacity to increase by two
            base.reserve(base.size() + eles.size());
        }
 
        size_t start = base.size();
        base.resize(base.size() + eles.size());
 
        // copy the elements
        std::copy(eles.begin(),eles.end(),base.begin()+start);
    }
 
    template<typename S> inline void add(const S & v)
    {
        push_back_op<is_vector<T>::value,is_vector<S>::value,T,S>::push_back(base,v);
    }
 
    template<typename S> inline void add(const S && v)
    {
        if (std::is_same<grow_p,openfpm::grow_policy_identity>::value == true)
        {
            // we reserve just one space more to avoid the capacity to increase by two
            base.reserve(base.size() + 1);
        }
 
        base.push_back(v);
    }
 
    template <typename S,
              typename M,
              typename gp,
              unsigned int impl,
              template <typename> class layout_base,
              unsigned int ...args>
    void add_prp(const vector<S,M,layout_base,gp,impl> & v)
    {
        add_prp_impl<std::is_same<S,T>::value,typename std::remove_pointer<decltype(*this)>::type>::template add<S,M,gp,impl,args...>(v,*this);
    }
 
    template <typename S,
              typename M,
              typename gp,
              unsigned int impl,
              template <typename> class layout_base,
              unsigned int ...args>
    void add_prp_device(const vector<S,M,layout_base,gp,impl> & v)
    {
        add_prp_impl<std::is_same<S,T>::value,typename std::remove_pointer<decltype(*this)>::type>::template add<S,M,gp,impl,args...>(v,*this);
    }
 
    template <typename S,
              typename M,
              typename gp,
              unsigned int impl,
              template <typename> class layout_base,
              unsigned int ...args>
    void add_prp(const T & v)
    {
        add(v);
    }
 
    void erase(typename std::vector<T>::iterator start, typename std::vector<T>::iterator end)
    {
        base.erase(start,end);
    }
 
    void remove(size_t key)
    {
#ifdef SE_CLASS1
        vector_overflow(key);
#endif
        base.erase(base.begin() + key);
    }
 
    void remove(openfpm::vector<size_t> & keys, size_t start = 0)
    {
        // Nothing to remove return
        if (keys.size() <= start )
            return;
 
        size_t a_key = start;
        size_t d_k = keys.get(a_key);
        size_t s_k = keys.get(a_key) + 1;
 
        // keys
        while (s_k < size())
        {
            // s_k should always point to a key that is not going to be deleted
            while (a_key+1 < keys.size() && s_k == keys.get(a_key+1))
            {
                a_key++;
                s_k = keys.get(a_key) + 1;
            }
 
            // In case of overflow
            if (s_k >= size())
                break;
 
            base[d_k] = base[s_k];
            d_k++;
            s_k++;
        }
 
        // re-calculate the vector size
 
        base.resize(base.size() - (keys.size() - start));
    }
 
    inline auto begin() -> decltype(base.begin())
    {
        return base.begin();
    }
 
    inline auto end() -> decltype(base.begin())
    {
        return base.end();
    }
 
    inline auto begin() const -> const decltype(base.begin())
    {
        return base.begin();
    }
 
    inline auto end() const -> const decltype(base.begin())
    {
        return base.end();
    }
 
    inline T & last()
    {
#ifdef SE_CLASS1
        if (base.size() == 0)
            std::cerr << "Error vector: " << __FILE__ << ":" << __LINE__ << " vector of size 0\n";
#endif
        return base[base.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[base.size()-1];
    }
 
    openfpm::vector<T> duplicate() const
    {
        return *this;
    }
 
    void swap(std::vector<T> && v)
    {
        base.swap(v);
    }
 
    void unique()
    {
        auto it = std::unique(base.begin(),base.end());
        base.resize( std::distance(base.begin(),it) );
    }
 
    void sort()
    {
        std::sort(base.begin(), base.end());
    }
 
    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 base[id];
    }
 
    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 base[id];
    }
 
    inline T & get(size_t id)
    {
#ifdef SE_CLASS1
        vector_overflow(id);
#endif
        return base[id];
    }
 
    inline const T & get(size_t id) const
    {
#ifdef SE_CLASS1
        vector_overflow(id);
#endif
        return base[id];
    }
 
    inline void fill(unsigned char fl)
    {
        memset(&base[0],fl,base.size() * sizeof(T));
    }
 
    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,HeapMemory,memory_traits_lin,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,HeapMemory,memory_traits_lin,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(openfpm::vector<T,HeapMemory,memory_traits_lin,grow_policy_double,STD_VECTOR> & v)
    {
        base.swap(v.base);
    }
 
    void swap(openfpm::vector<T,HeapMemory,memory_traits_lin,grow_policy_double,STD_VECTOR> && v)
    {
        base.swap(v.base);
    }
 
    vector<T,HeapMemory,memory_traits_lin,grow_policy_double,STD_VECTOR> & operator=(const vector<T,HeapMemory,memory_traits_lin,grow_policy_double,STD_VECTOR> & v)
    {
        base = v.base;
 
        return *this;
    }
 
    template<typename Mem, typename gp> vector<T,HeapMemory,memory_traits_lin,grow_policy_double,STD_VECTOR> & operator=(const vector<T,Mem,memory_traits_lin,gp,STD_VECTOR> & v)
    {
        base_copy<has_base_to_copy<vector<T,Mem,memory_traits_lin,gp,STD_VECTOR>>::value,
                  decltype(*this),
                  vector<T,Mem,memory_traits_lin,gp,STD_VECTOR> >::copy(*this,v);
 
        return *this;
    }
 
    vector<T,HeapMemory,memory_traits_lin,grow_policy_double,STD_VECTOR> & operator=(vector<T,HeapMemory,memory_traits_lin,grow_policy_double,STD_VECTOR> && v)
    {
        base.swap(v.base);
 
        return *this;
    }
 
    template<typename Mem, typename gp>  vector<T,HeapMemory,memory_traits_lin,grow_policy_double,STD_VECTOR> & operator=(vector<T,Mem,memory_traits_lin,gp,STD_VECTOR> && v)
    {
        base.swap(v.base);
 
        return *this;
    }
 
    bool operator!=(const vector<T, HeapMemory, memory_traits_lin,grow_policy_double,STD_VECTOR> & v) const
    {
        return base != v.base;
    }
 
    bool operator==(const vector<T, HeapMemory, memory_traits_lin,grow_policy_double,STD_VECTOR> & v) const
    {
        return base == v.base;
    }
 
    vector_key_iterator getIterator() const
    {
        return vector_key_iterator(base.size());
    }
 
    vector_key_iterator getIteratorTo(size_t k) const
    {
        return vector_key_iterator(k);
    }
 
    template<int ... prp> inline size_t packMem(size_t n, size_t e) const
    {
        if (n == 0)
            return 0;
        else
        {
            packMem_cond<has_packMem<T>::type::value, openfpm::vector<T, HeapMemory, memory_traits_lin, grow_policy_double>, prp...> cm;
            return cm.packMemory(*this,n,0);
        }
    }
 
    inline static size_t calculateMemDummy(size_t n, size_t e)
    {
        return n*sizeof(T);
    }
 
    inline static size_t calculateNMem(size_t n)
    {
 
        return 1;
    }
 
    void * getPointer()
    {
        return &base[0];
    }
 
    template<unsigned int ... prp> void hostToDevice()
    {}
 
    template<unsigned int ... prp> void deviceToHost()
    {}
 
    template<unsigned int ... prp> void deviceToHost(size_t start, size_t stop)
    {}
 
    template<unsigned int ... prp> void hostToDevice(size_t start, size_t stop)
    {}
 
    const void * getPointer() const
    {
        return &base[0];
    }
 
    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);\
        }
    }
};
 
template<typename T>
class vector_fr
:private vector<T,HeapMemory,memory_traits_lin,grow_policy_double,STD_VECTOR>
{
    typedef vector<T,HeapMemory,memory_traits_lin,grow_policy_double,STD_VECTOR> base_type;
 
    size_t v_size = 0;
 
public:
 
    size_t size()
    {
        return v_size;
    }
 
    size_t size_base()
    {
        return base_type::size();
    }
 
    void resize(size_t sz)
    {
        if (sz <= base_type::size())
        {
            v_size = sz;
            return;
        }
 
        base_type::resize(sz);
 
        v_size = sz;
    }
 
    void clear()
    {
        resize(0);
    }
 
    void add()
    {
        resize(v_size+1);
    }
 
    void resize_base(size_t sz)
    {
        base_type::resize(sz);
        v_size = sz;
    }
 
    inline T & get(size_t id)
    {
        return base_type::get(id);
    }
 
    inline T & operator[](size_t id)
    {
        return base_type::get(id);
    }
 
    inline T & last()
    {
        return base_type::get(size()-1);
    }
 
    void swap(openfpm::vector_fr<T> & v)
    {
        size_t v_size_tmp = v.v_size;
        v.v_size = v_size;
        v_size = v_size_tmp;
 
        base_type::swap(v);
    }
};
 
#endif /* MAP_VECTOR_STD_HPP_ */