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 "vect_isel.hpp"
#include "Packer_Unpacker/Unpacker.hpp"
#include "Packer_Unpacker/Packer.hpp"
#include <fstream>

namespace openfpm
{
    class vector_key_iterator
    {
        size_t end;

    protected:

        size_t gk;

    public:

        vector_key_iterator(size_t end, size_t start = 0)
        : end(end),gk(start)
        {}


        vector_key_iterator operator++()
        {

            gk++;

            return *this;
        }

        void set(int d, size_t sz)
        {
            // set the counter dim to sz

            gk = sz;
        }

        bool isNext()
        {
            if (gk < end)
            {

                return true;
            }

            return false;
        }

        size_t get()
        {
            return gk;
        }
    };

    template<typename T, typename Memory, typename grow_p, unsigned int impl>
    class vector
    {
    };

    #include "map_vector_std.hpp"

    template<typename T,typename Memory, typename grow_p>
    class vector<T,Memory,grow_p,OPENFPM_NATIVE>
    {
        typedef typename grid_cpu<1,T,Memory>::memory_lin memory_lin;

        size_t v_size;

        grid_cpu<1,T,Memory> base;

        size_t err_code;

        std::vector<size_t> getV(size_t sz)
        {
            std::vector<size_t> tmp;

            tmp.push_back(sz);

            return tmp;
        }

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

    public:

        typedef int yes_i_am_vector;

        typedef typename grid_cpu<1,T>::memory_conf memory_conf;

        typedef vector_key_iterator iterator_key;

        // you can access all the properties of T
        typedef typename grid_cpu<1,T>::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>::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,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 <typename S, typename M, typename gp, unsigned int ...args> void add_prp(const vector<S, M,gp,OPENFPM_NATIVE> & 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 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 const typename type_cpu_prop<p,memory_lin>::type & get(size_t id) const
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#ifdef SE_CLASS1
            VECTOR_OVERFLOW_NATIVE(id)
#endif
            grid_key_dx<1> key(id);

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

        inline const typename grid_cpu<1,T>::container get(size_t id) const
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#ifdef SE_CLASS1
            VECTOR_OVERFLOW_NATIVE(id)
#endif
            grid_key_dx<1> key(id);

            return base.get_o(key);
        }

        inline const typename grid_cpu<1,T>::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 typename type_cpu_prop<p,memory_lin>::type & get(size_t id)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#ifdef SE_CLASS1
            VECTOR_OVERFLOW_NATIVE(id)
#endif
            grid_key_dx<1> key(id);

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

        inline typename grid_cpu<1,T>::container get(size_t id)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#ifdef SE_CLASS1
            VECTOR_OVERFLOW_NATIVE(id)
#endif
            grid_key_dx<1> key(id);

            return base.get_o(key);
        }

        inline typename grid_cpu<1,T>::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,grow_p,OPENFPM_NATIVE> duplicate() const
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            vector<T, Memory,grow_p,OPENFPM_NATIVE> dup;

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

            return dup;
        }

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

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

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

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

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

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

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

        vector<T, Memory,grow_p,OPENFPM_NATIVE> & operator=(vector<T, Memory,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,grow_p,OPENFPM_NATIVE> & operator=(const vector<T, Memory,grow_p,OPENFPM_NATIVE> & mv)
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            v_size = mv.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.base,key);
            }

            return *this;
        }

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

        bool operator==(const vector<T, Memory,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,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,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 mark) const
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            return vector_key_iterator(v_size,mark);
        }

        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;
#ifdef DEBUG
                std::cout << "Inside calculateMem() (map_vector)" << std::endl;
#endif
                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;
#ifdef DEBUG
            std::cout << "Inside packMem() (map_vector)" << std::endl;
#endif
            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();
        }

        size_t getLastError()
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            return err_code;
        }

        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
        }
    };

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

}

#endif