map_vector.hpp

/*
 * map_vector.hpp
 *
 *  Created on: Aug 30, 2014
 *      Author: Pietro Incardona
 */

#ifndef MAP_VECTOR_HPP
#define MAP_VECTOR_HPP

#include <iostream>
#include <typeinfo>
#include "util/common.hpp"
#include "memory/PtrMemory.hpp"
#include "util/object_util.hpp"
#include "Grid/util.hpp"
#include "Vector/util.hpp"
#include "Vector/map_vector_grow_p.hpp"
#include "memory/ExtPreAlloc.hpp"
#include "util/util_debug.hpp"
#include "util/Pack_stat.hpp"
#include "Grid/map_grid.hpp"
#include "memory/HeapMemory.hpp"
#include "vect_isel.hpp"
#include "util/object_s_di.hpp"
#include "util.hpp"
#ifdef HAVE_MPI
#include <mpi.h>
#endif
#include "util/Pack_stat.hpp"
#include "memory/ExtPreAlloc.hpp"
#include <string.h>
#include "Packer_Unpacker/Unpacker.hpp"
#include "Packer_Unpacker/Packer.hpp"
#include <fstream>
#include "Packer_Unpacker/Packer_util.hpp"
#include "Packer_Unpacker/has_pack_agg.hpp"
#include "timer.hpp"
#include "map_vector_std_util.hpp"
#include "data_type/aggregate.hpp"
#include "vector_map_iterator.hpp"

namespace openfpm
{

    template<typename T, typename Memory, typename layout, template<typename> class layout_base, typename grow_p, unsigned int impl>
    class vector
    {
        size_t size()
        {
            std::cerr << __FILE__ << ":" << __LINE__ << " Error stub vector created" << std::endl;
            return 0;
        }
    };

    #include "map_vector_std.hpp"
    #include "map_vector_std_ptr.hpp"

    template<typename T,typename Memory, typename layout, template <typename> class layout_base, typename grow_p>
    class vector<T,Memory,layout,layout_base,grow_p,OPENFPM_NATIVE>
    {
        size_t v_size;

        grid_cpu<1,T,Memory,typename layout_base<T>::type> base;

        void non_zero_one(size_t sz[1], size_t arg)
        {
            if (arg == 0)
            {sz[0] = 1;}
            else
            {sz[0] = arg;}
        }

#ifdef SE_CLASS1

        void check_overflow(size_t id) const
        {
            if (id >= v_size)
            {
                std::cerr << "Error " << __FILE__ << ":" << __LINE__ << " overflow id: " << id << "\n";
                ACTION_ON_ERROR(VECTOR_ERROR_OBJECT);
            }
        }

#endif

    public:

        typedef int yes_i_am_vector;

        typedef layout layout_type;

        typedef vector_key_iterator iterator_key;

        // you can access all the properties of T
        typedef typename grid_cpu<1,T,Memory,typename layout_base<T>::type>::container container;

        typedef T value_type;

        // Implementation of packer and unpacker for vector
#include "vector_pack_unpack.ipp"

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

        void reserve(size_t sp)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            if (sp > base.size())
            {
                size_t sz[1] = {sp};
                base.resize(sz);
            }
        }

        void clear()
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            resize(0);
        }

        void resize(size_t slot)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            // If we need more space than what we allocated, allocate new memory

            if (slot > base.size())
            {
                size_t gr = grow_p::grow(base.size(),slot);

                size_t sz[1] = {gr};
                base.resize(sz);
            }

            // update the vector size
            v_size = slot;
        }

        typedef size_t access_key;

        void add()
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif

            if (v_size >= base.size())
            {
                size_t sz[1];
                non_zero_one(sz,2*base.size());
                base.resize(sz);
            }

            v_size++;
        }

        void add(const T & v)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif

            if (v_size >= base.size())
            {
                size_t sz[1];
                non_zero_one(sz,2*base.size());
                base.resize(sz);
            }

            base.set(v_size,v);

            v_size++;
        }

        void add(const typename grid_cpu<1,T,Memory,typename layout_base<T>::type>::container & v)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif

            if (v_size >= base.size())
            {
                size_t sz[1];
                non_zero_one(sz,2*base.size());
                base.resize(sz);
            }

            base.set(v_size,v);

            v_size++;
        }

        template <typename M, typename gp> void add(const vector<T, M,layout, layout_base,gp,OPENFPM_NATIVE> & v)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            for (size_t i = 0 ; i < v.size() ; i++)
                add(v.get(i));
        }

        template <template<typename,typename> class op, typename S, typename M, typename gp, unsigned int ...args>
        void merge_prp(const vector<S,M,typename layout_base<S>::type,layout_base,gp,OPENFPM_NATIVE> & v,
                       const openfpm::vector<size_t> & opart)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#ifdef SE_CLASS1

            if (v.size() != opart.size())
                std::cerr << __FILE__ << ":" << __LINE__ << " error merge_prp: v.size()=" << v.size() << " must be the same as o_part.size()" << opart.size() << std::endl;

#endif
            for (size_t i = 0 ; i < v.size() ; i++)
            {
#ifdef SE_CLASS1

                if (opart.get(i) > size())
                    std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " try to access element " << opart.get(i) << " but the vector has size " << size() << std::endl;

#endif
                // write the object in the last element
                object_s_di_op<op,decltype(v.get(i)),decltype(get(size()-1)),OBJ_ENCAP,args...>(v.get(i),get(opart.get(i)));
            }
        }


        template <template<typename,typename> class op,
                  typename S,
                  typename M,
                  typename gp,
                  template <typename> class layout_base2,
                  unsigned int ...args>
        void merge_prp_v(const vector<S,M,typename layout_base2<S>::type,layout_base2,gp,OPENFPM_NATIVE> & v,
                         const openfpm::vector<aggregate<size_t,size_t>> & opart)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#ifdef SE_CLASS1

            if (v.size() != opart.size())
                std::cerr << __FILE__ << ":" << __LINE__ << " error merge_prp: v.size()=" << v.size() << " must be the same as o_part.size()" << opart.size() << std::endl;

#endif
            for (size_t i = 0 ; i < v.size() ; i++)
            {
#ifdef SE_CLASS1

                if (i >= opart.size())
                    std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " try to access element " << opart.template get<0>(i) << " but the vector has size " << size() << std::endl;

#endif
                // write the object in the last element
                object_s_di_op<op,decltype(v.get(i)),decltype(get(size()-1)),OBJ_ENCAP,args...>(v.get(i),get(opart.template get<0>(i)));
            }
        }

        template <template<typename,typename> class op,
                  typename S,
                  typename M,
                  typename gp,
                  template <typename> class layout_base2,
                  unsigned int ...args>
        void merge_prp_v(const vector<S,M,typename layout_base2<S>::type,layout_base2,gp,OPENFPM_NATIVE> & v,
                         size_t start)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            for (size_t i = 0 ; i < v.size() ; i++)
            {
#ifdef SE_CLASS1

                if (start + i >= v_size)
                    std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " try to access element " << start+i << " but the vector has size " << size() << std::endl;

#endif
                // write the object in the last element
                object_s_di_op<op,decltype(v.get(0)),decltype(get(0)),OBJ_ENCAP,args...>(v.get(i),get(start+i));
            }
        }

        template <typename S,
                  typename M,
                  typename gp,
                  unsigned int impl,
                  template <typename> class layout_base2,
                  unsigned int ...args>
        void add_prp(const vector<S,M,typename layout_base2<S>::type,layout_base2,gp,impl> & v)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            for (size_t i = 0 ; i < v.size() ; i++)
            {
                // Add a new element
                add();

                // write the object in the last element
                object_s_di<decltype(v.get(i)),decltype(get(size()-1)),OBJ_ENCAP,args...>(v.get(i),get(size()-1));
            }
        }

        void insert(size_t key)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            add();

            long int d_k = (long int)size()-1;
            long int s_k = (long int)size()-2;

            // keys
            while (s_k >= (long int)key)
            {
                set(d_k,get(s_k));
                d_k--;
                s_k--;
            }
        }


        void remove(size_t key)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            size_t d_k = key;
            size_t s_k = key + 1;

            // keys
            while (s_k < size())
            {
                set(d_k,get(s_k));
                d_k++;
                s_k++;
            }

            // re-calculate the vector size

            v_size--;
        }

        void remove(openfpm::vector<size_t> & keys, size_t start = 0)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            // 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;

                set(d_k,get(s_k));
                d_k++;
                s_k++;
            }

            // re-calculate the vector size

            v_size -= keys.size() - start;
        }

        template <unsigned int p>
        inline auto get(size_t id) const -> decltype(base.template get<p>(grid_key_dx<1>(0)))
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#ifdef SE_CLASS1
            check_overflow(id);
#endif
            grid_key_dx<1> key(id);

            return base.template get<p>(key);
        }

        inline auto get(size_t id) -> decltype(base.get_o(grid_key_dx<1>(id)))
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#ifdef SE_CLASS1
            check_overflow(id);
#endif
            grid_key_dx<1> key(id);

            return base.get_o(key);
        }

        inline auto get(size_t id) const -> const decltype(base.get_o(grid_key_dx<1>(id)))
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#ifdef SE_CLASS1
            check_overflow(id);
#endif
            grid_key_dx<1> key(id);

            return base.get_o(key);
        }

        inline const typename grid_cpu<1,T,Memory,typename layout_base<T>::type>::container get_o(size_t id) const
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#ifdef SE_CLASS1
            check_overflow(id);
#endif
            grid_key_dx<1> key(id);

            return base.get_o(key);
        }

        inline const typename grid_cpu<1,T,Memory,typename layout_base<T>::type >::container last() const
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            grid_key_dx<1> key(size()-1);

            return base.get_o(key);
        }

        template <unsigned int p>
        inline auto get(size_t id) -> decltype(base.template get<p>(grid_key_dx<1>(0)))
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#ifdef SE_CLASS1
            check_overflow(id);
#endif
            grid_key_dx<1> key(id);

            return base.template get<p>(key);
        }

        inline typename grid_cpu<1,T,Memory,typename layout_base<T>::type >::container last()
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            grid_key_dx<1> key(size()-1);

            return base.get_o(key);
        }

        ~vector() THROW
        {
            // Eliminate the pointer
    #ifdef SE_CLASS2
            check_delete(this);
    #endif
        }

        vector<T, Memory,layout,layout_base,grow_p,OPENFPM_NATIVE> duplicate() const
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            vector<T, Memory,layout,layout_base,grow_p,OPENFPM_NATIVE> dup;

            dup.v_size = v_size;
            dup.base.swap(base.duplicate());

            return dup;
        }

        vector(vector<T, Memory,layout,layout_base,grow_p,OPENFPM_NATIVE> && v)
        :v_size(0)
        {
            // Add this pointer
#ifdef SE_CLASS2
            check_new(this,8,VECTOR_EVENT,1);
#endif
            swap(v);
        }

        vector(const vector<T, Memory,layout,layout_base,grow_p,OPENFPM_NATIVE> & v) THROW
        :v_size(0)
        {
#ifdef SE_CLASS2
            check_new(this,8,VECTOR_EVENT,1);
#endif
            swap(v.duplicate());
        }

        vector() THROW
        :v_size(0),base(0)
        {
#ifdef SE_CLASS2
            check_new(this,8,VECTOR_EVENT,1);
#endif
            base.setMemory();
        }

        vector(size_t sz) THROW
        :v_size(sz),base(sz)
        {
#ifdef SE_CLASS2
            check_new(this,8,VECTOR_EVENT,1);
#endif
            base.setMemory();
        }

        void set(size_t id, const typename grid_cpu<1,T,Memory,typename layout_base<T>::type>::container & obj)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#ifdef SE_CLASS1
            check_overflow(id);
#endif
            base.set(id,obj);
        }

        template <typename encap_S, unsigned int ...args> void set_o(size_t i, const encap_S & obj)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif

            // write the object in the last element
            object_s_di<encap_S,decltype(get(i)),OBJ_ENCAP,args...>(obj,get(i));
        }

        void set(size_t id, const T & obj)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#ifdef SE_CLASS1
            check_overflow(id);
#endif
            base.set(id,obj);
        }

        void set(size_t id, vector<T,Memory,layout,layout_base,grow_p,OPENFPM_NATIVE> & v, size_t src)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#ifdef SE_CLASS1
            check_overflow(id);
#endif
            base.set(id,v.base,src);
        }

        vector<T, Memory,layout,layout_base,grow_p,OPENFPM_NATIVE> & operator=(vector<T, Memory, layout, layout_base,grow_p,OPENFPM_NATIVE> && mv)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            v_size = mv.v_size;
            base.swap(mv.base);

            return *this;
        }

        vector<T, Memory,layout,layout_base,grow_p,OPENFPM_NATIVE> & operator=(const vector<T, Memory, layout, layout_base ,grow_p,OPENFPM_NATIVE> & mv)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            v_size = mv.v_size;
            size_t rsz[1] = {v_size};
            if (base.size() < v_size)
                base.resize(rsz);

            // copy the object
            for (size_t i = 0 ; i < v_size ; i++ )
            {
                grid_key_dx<1> key(i);
                base.set(key,mv.base,key);
            }

            return *this;
        }

        template<typename Mem, typename gp> vector<T, Memory,layout,layout_base,grow_p,OPENFPM_NATIVE> & operator=(vector<T, Mem, layout, layout_base,gp,OPENFPM_NATIVE> && mv)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            v_size = mv.v_size;
            base.swap(mv.base);

            return *this;
        }

        template<typename Mem, typename gp> vector<T, Memory,layout,layout_base,grow_p,OPENFPM_NATIVE> & operator=(const vector<T, Mem, layout, layout_base ,gp,OPENFPM_NATIVE> & mv)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            v_size = mv.getInternal_v_size();
            size_t rsz[1] = {v_size};
            base.resize(rsz);

            // copy the object
            for (size_t i = 0 ; i < v_size ; i++ )
            {
                grid_key_dx<1> key(i);
                base.set(key,mv.getInternal_base(),key);
            }

            return *this;
        }

        bool operator!=(const vector<T, Memory, layout, layout_base,grow_p,OPENFPM_NATIVE> & v) const
        {
            return !this->operator==(v);
        }

        bool operator==(const vector<T, Memory, layout, layout_base, grow_p,OPENFPM_NATIVE> & v) const
        {
            if (v_size != v.v_size)
                return false;

            // check object by object
            for (size_t i = 0 ; i < v_size ; i++ )
            {
                grid_key_dx<1> key(i);

                if (base.get_o(key) != v.base.get_o(key))
                    return false;
            }

            return true;
        }

        void swap(openfpm::vector<T,Memory,layout, layout_base,grow_p,OPENFPM_NATIVE> & v)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            size_t sz_sp = v_size;

            // swap the v_size
            v_size = v.v_size;

            base.swap(v.base);
            v.v_size = sz_sp;
        }

        void swap(openfpm::vector<T,Memory,layout, layout_base,grow_p,OPENFPM_NATIVE> && v)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            size_t sz_sp = v_size;

            // swap the v_size
            v_size = v.v_size;

            base.swap(v.base);
            v.v_size = sz_sp;
        }

        vector_key_iterator getIteratorFrom(size_t start) const
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            return vector_key_iterator(v_size,start);
        }

        vector_key_iterator getIteratorTo(size_t stop) const
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            return vector_key_iterator(stop,0);
        }

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

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

        size_t packObject(void * mem)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            return base.packObject(mem);
        }

        template<int ... prp> static inline size_t calculateMem(size_t n, size_t e)
        {
            if (n == 0)
            {
                return 0;
            }
            else
            {
                if (sizeof...(prp) == 0)
                    return grow_p::grow(0,n) * sizeof(typename T::type);

                typedef object<typename object_creator<typename T::type,prp...>::type> prp_object;

                return grow_p::grow(0,n) * sizeof(prp_object);
            }
        }

        template<int ... prp> static inline size_t packMem(size_t n, size_t e)
        {
            if (sizeof...(prp) == 0)
                return n * sizeof(typename T::type);

            typedef object<typename object_creator<typename T::type,prp...>::type> prp_object;

            return n * sizeof(prp_object);
        }

        inline static size_t calculateNMem(size_t n)
        {
            return 1;
        }

        void setMemory(Memory & mem)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            base.setMemory(mem);
        }

        void * getPointer()
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            return base.getPointer();
        }

        const void * getPointer() const
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            return base.getPointer();
        }

        static bool noPointers()
        {
            return false;
        }

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

        const size_t & getInternal_v_size() const
        {
            return v_size;
        }

        const grid_cpu<1,T,Memory,layout> & getInternal_base() const
        {
            return base;
        }
    };

    template <typename T> using vector_std = vector<T, HeapMemory, typename memory_traits_lin<T>::type, memory_traits_lin, openfpm::grow_policy_double, STD_VECTOR>;

}

#endif