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,typename memory_traits_lin<S>::type,memory_traits_lin,gp,impl> & v_src, vect_dst & v_dst)
    {
#ifdef SE_CLASS2
        check_valid(&v_src,8);
        check_valid(&v_dst,8);
#endif
        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,typename memory_traits_lin<S>::type,memory_traits_lin,gp,impl> & v_src, vect_dst & v_dst)
    {
#ifdef SE_CLASS2
        check_valid((void *)&v_dst,8);
        check_valid((void *)&v_src,8);
#endif
            // Add a new element
            v_dst.add();

            // equal object
            v_dst.get(v_dst.size()-1) = v_src;
    }
};


template<typename T>
class vector<T,HeapMemory,typename memory_traits_lin<T>::type,memory_traits_lin,grow_policy_double,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 vector_key_iterator iterator_key;
    typedef T value_type;

    typedef void base_to_copy;

    //This file implements a pack and unpack for std vector
#include "vector_std_pack_unpack.ipp"

    inline size_t size() const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return base.size();
    }


    inline void resize(size_t slot)
    {
#ifdef SE_CLASS2
        check_valid(this,8);

        // here we have to check if the vector go into reallocation
        void * ptr_old = &base[0];
#endif

        base.resize(slot);

#ifdef SE_CLASS2
        if (ptr_old != &base[0])
        {
            check_delete(ptr_old);
            check_new(&base[0],slot*sizeof(T),VECTOR_STD_EVENT,1);
        }
#endif
    }

    inline void clear()
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        base.clear();
    }

    inline void add(const T & v)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
        void * ptr_old = &base[0];
#endif

        base.push_back(v);

#ifdef SE_CLASS2

        if (ptr_old != &base[0])
        {
            check_delete(ptr_old);
            check_new(&base[0],base.size()*sizeof(T),VECTOR_STD_EVENT,1);
        }

#endif
    }

    inline void add(T && v)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
        void * ptr_old = &base[0];
#endif

        base.emplace_back(v);

#ifdef SE_CLASS2

        if (ptr_old != &base[0])
        {
            check_delete(ptr_old);
            check_new(&base[0],base.size()*sizeof(T),VECTOR_STD_EVENT,1);
        }

#endif
    }

    inline void add()
    {
#ifdef SE_CLASS2
        check_valid(this,8);
        void * ptr_old = &base[0];
#endif

        base.emplace_back(T());

#ifdef SE_CLASS2

        if (ptr_old != &base[0])
        {
            check_delete(ptr_old);
            check_new(&base[0],base.size()*sizeof(T),VECTOR_STD_EVENT,1);
        }

#endif
    }

    template<typename Mem,typename l,template<typename> class lb,typename gp> inline void add(const openfpm::vector<T,Mem,l,lb,gp> & eles)
    {

#ifdef SE_CLASS2
        check_valid(this,8);
        void * ptr_old = &base[0];
#endif

        size_t start = base.size();
        base.resize(base.size() + eles.size());

        // copy the elements
        std::copy(eles.begin(),eles.end(),base.begin()+start);

#ifdef SE_CLASS2

        if (ptr_old != &base[0])
        {
            check_delete(ptr_old);
            check_new(&base[0],base.size()*sizeof(T),VECTOR_STD_EVENT,1);
        }

#endif
    }

    template<typename S> inline void add(const S & v)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
        void * ptr_old = &base[0];
#endif

        push_back_op<is_vector<T>::value,is_vector<S>::value,T,S>::push_back(base,v);

#ifdef SE_CLASS2

        if (ptr_old != &base[0])
        {
            check_delete(ptr_old);
            check_new(&base[0],base.size()*sizeof(T),VECTOR_STD_EVENT,1);
        }

#endif
    }

    template<typename S> inline void add(const S && v)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
        void * ptr_old = &base[0];
#endif

        base.push_back(v);

#ifdef SE_CLASS2

        if (ptr_old != &base[0])
        {
            check_delete(ptr_old);
            check_new(&base[0],base.size()*sizeof(T),VECTOR_STD_EVENT,1);
        }

#endif
    }

    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,typename layout_base<S>::type,layout_base,gp,impl> & v)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif

        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)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        add(v);
    }

    void erase(typename std::vector<T>::iterator start, typename std::vector<T>::iterator end)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif

        base.erase(start,end);
    }

    void remove(size_t key)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        vector_overflow(key);
#endif
        base.erase(base.begin() + key);
    }

    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_CLASS2
        check_valid(this,8);
#endif
#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_CLASS2
        check_valid(this,8);
#endif
#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
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return *this;
    }

    void swap(std::vector<T> && v)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        base.swap(v);
    }

    void unique()
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        auto it = std::unique(base.begin(),base.end());
        base.resize( std::distance(base.begin(),it) );
    }

    void sort()
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        std::sort(base.begin(), base.end());
    }

    template <unsigned int p>inline T& get(size_t id)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#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_CLASS2
        check_valid(this,8);
#endif
#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_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        vector_overflow(id);
#endif
        return base[id];
    }

    inline const T & get(size_t id) const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        vector_overflow(id);
#endif
        return base[id];
    }

    inline void fill(unsigned char fl)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        memset(&base[0],fl,base.size() * sizeof(T));
    }

    inline void reserve(size_t ns)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        base.reserve(ns);
    }

    vector() noexcept
    :err_code(0)
    {
#ifdef SE_CLASS2
        check_new(this,8,VECTOR_STD_EVENT,1);
#endif
    }

    vector(size_t sz) noexcept
    :base(sz),err_code(0)
    {
#ifdef SE_CLASS2
        check_new(this,8,VECTOR_STD_EVENT,1);
        check_new(&base[0],sizeof(T)*sz,VECTOR_STD_EVENT,1);
#endif
    }

    vector(const vector<T,HeapMemory,layout,memory_traits_lin,grow_policy_double,STD_VECTOR> & v) noexcept
    :err_code(0)
    {
#ifdef SE_CLASS2
        check_new(this,8,VECTOR_STD_EVENT,1);
        void * ptr_old = &base[0];
#endif

        base = v.base;

#ifdef SE_CLASS2

        if (ptr_old != &base[0])
        {
            check_delete(ptr_old);
            check_new(&base[0],base.size()*sizeof(T),VECTOR_STD_EVENT,1);
        }

#endif
    }

    vector(const std::initializer_list<T> & v)
    :base(v)
    {
#ifdef SE_CLASS2
        check_new(this,8,VECTOR_STD_EVENT,1);
        check_new(&base[0],sizeof(T)*v.size(),VECTOR_STD_EVENT,1);
#endif
    }

    vector(vector<T,HeapMemory,layout,memory_traits_lin,grow_policy_double,STD_VECTOR> && v) noexcept
    :err_code(0)
    {
#ifdef SE_CLASS2
        check_new(this,8,VECTOR_STD_EVENT,1);
#endif

        base.swap(v.base);
    }

    ~vector() noexcept
    {
#ifdef SE_CLASS2
        check_delete(this);
        check_delete(&base[0]);
#endif
    }

    void swap(openfpm::vector<T,HeapMemory,layout,memory_traits_lin,grow_policy_double,STD_VECTOR> & v)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        base.swap(v.base);
    }

    void swap(openfpm::vector<T,HeapMemory,layout,memory_traits_lin,grow_policy_double,STD_VECTOR> && v)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        base.swap(v.base);
    }

    vector<T,HeapMemory,layout,memory_traits_lin,grow_policy_double,STD_VECTOR> & operator=(const vector<T,HeapMemory,layout,memory_traits_lin,grow_policy_double,STD_VECTOR> & v)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
        void * ptr_old = &base[0];
#endif

        base = v.base;

#ifdef SE_CLASS2

        if (ptr_old != &base[0])
        {
            check_delete(ptr_old);
            check_new(&base[0],base.size()*sizeof(T),VECTOR_STD_EVENT,1);
        }

#endif

        return *this;
    }

    template<typename Mem, typename gp> vector<T,HeapMemory,layout,memory_traits_lin,grow_policy_double,STD_VECTOR> & operator=(const vector<T,Mem,layout,memory_traits_lin,gp,STD_VECTOR> & v)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
        void * ptr_old = &base[0];
#endif

        base_copy<has_base_to_copy<vector<T,Mem,layout,memory_traits_lin,gp,STD_VECTOR>>::value,
                  decltype(*this),
                  vector<T,Mem,layout,memory_traits_lin,gp,STD_VECTOR> >::copy(*this,v);

#ifdef SE_CLASS2

        if (ptr_old != &base[0])
        {
            check_delete(ptr_old);
            check_new(&base[0],base.size()*sizeof(T),VECTOR_STD_EVENT,1);
        }

#endif

        return *this;
    }

    vector<T,HeapMemory,layout,memory_traits_lin,grow_policy_double,STD_VECTOR> & operator=(vector<T,HeapMemory,layout,memory_traits_lin,grow_policy_double,STD_VECTOR> && v)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        base.swap(v.base);

        return *this;
    }

    template<typename Mem, typename gp>  vector<T,HeapMemory,layout,memory_traits_lin,grow_policy_double,STD_VECTOR> & operator=(vector<T,Mem,layout,memory_traits_lin,gp,STD_VECTOR> && v)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        base.swap(v.base);

        return *this;
    }

    bool operator!=(const vector<T, HeapMemory, layout, memory_traits_lin,grow_policy_double,STD_VECTOR> & v) const
    {
        return base != v.base;
    }

    bool operator==(const vector<T, HeapMemory, layout, memory_traits_lin,grow_policy_double,STD_VECTOR> & v) const
    {
        return base == v.base;
    }

    vector_key_iterator getIterator() const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return vector_key_iterator(base.size());
    }

    vector_key_iterator getIteratorTo(size_t k) const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        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, layout, 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()
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return &base[0];
    }

    const void * getPointer() const
    {
        return &base[0];
    }

    static bool noPointers()
    {
        return false;
    }

    size_t getLastError()
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        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);\
        }
    }

    /* \brief It return the id of structure in the allocation list
     *
     * \see print_alloc and SE_CLASS2
     *
     * \return the allocation id of this class
     *
     */
    long int who()
    {
#ifdef SE_CLASS2
        return check_whoami(this,8);
#else
        return -1;
#endif
    }
};



#endif /* MAP_VECTOR_STD_HPP_ */