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"

template<typename T>
class vector<T,HeapMemory,grow_policy_double,STD_VECTOR>
{
    size_t v_size;

    std::vector<T> base;

    size_t err_code;

public:

    typedef int yes_i_am_vector;

    typedef vector_key_iterator iterator_key;
    typedef T value_type;

    //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);
#endif
        v_size = slot;

        base.resize(slot);
    }

    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);
#endif
        base.push_back(v);
    }

    inline void add(T && v)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        base.emplace_back(v);
    }

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

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

    std::vector<T> duplicate()
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return base;
    }

    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
        if (id >= base.size())
            std::cerr << "Error vector: " << __FILE__ << ":" << __LINE__ << " overflow id: " << id << "\n";
#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
    :v_size(0),err_code(0)
    {
#ifdef SE_CLASS2
        check_new(this,8,VECTOR_STD_EVENT,1);
#endif
    }

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

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

        base = v.base;
    }

    vector(const std::initializer_list<T> & v)
    :base(v)
    {}

    vector(vector<T,HeapMemory,grow_policy_double,STD_VECTOR> && v) noexcept
    :v_size(0),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);
#endif
    }

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

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

        return *this;
    }

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

        return *this;
    }

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

    bool operator==(const vector<T, HeapMemory,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());
    }

    template<int ... prp> inline size_t packMem(size_t n, size_t e)
    {
        if (n == 0)
            return 0;
        else {
#ifdef DEBUG
            std::cout << "Inside map_vector_std.hpp packMem()" << std::endl;
#endif
            packMem_cond<has_packMem<T>::type::value, openfpm::vector<T, HeapMemory, 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);\
        }
    }

    /* \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
    }
};


#endif /* MAP_VECTOR_STD_HPP_ */