memory_c.hpp

/*
 * memory_c.hpp
 *
 *  Created on: Aug 17, 2014
 *      Author: Pietro Incardona
 */

#include <boost/multi_array.hpp>
#include <boost/fusion/mpl.hpp>
#include <boost/fusion/include/mpl.hpp>
#include <boost/mpl/vector.hpp>
#include <array>
#include "util/ct_array.hpp"
#include "memory_array.hpp"
#include "memory/memory.hpp"

#ifndef MEMORY_C_HPP_
#define MEMORY_C_HPP_

template<typename T, typename D = memory>
class memory_c
{
    public:

    typedef memory_c<T> type;

    typedef T& reference;

    typedef T vtype;

    D * mem;

    memory_array<T> * mem_r;

    void setMemory(memory & mem)
    {
        if (this->mem != NULL)
        {
            this->mem->decRef();

            if (this->mem->ref() == 0 && &mem != this->mem)
                delete(this->mem);
        }
//          this->mem->decRef();
        mem.incRef();
        this->mem = &mem;
    }

    memory& getMemory()
    {
        return *this->mem;
    }

    const memory& getMemory() const
    {
        return *this->mem;
    }

    bool allocate(const size_t sz, bool skip_initialization = false)
    {
        memory * mem = this->mem;

        mem->resize( sz*sizeof(T) );

        mem_r = new memory_array<T>(mem->getPointer(),sz,mem->isInitialized() | skip_initialization);

        return true;
    }

    void move_copy(memory_c & mem_c)
    {
        // if mem_r is allocated delete it
        if (mem_r != NULL)
            delete(mem_r);

        //if mem is already allocated, deallocate it
        if (mem != NULL)
            delete(mem);

        // move the pointer
        mem = mem_c.mem;

        // Null the pointer to avoid double deallocation
        mem_c.mem = NULL;

        // move the pointer
        mem_r = mem_c.mem_r;

        // Null the pointer to avoid double deallocation
        mem_c.mem_r = NULL;
    }

    memory_c():mem(NULL),mem_r(NULL){}

    ~memory_c()
    {
        delete(mem_r);
        if (mem != NULL)
        {
            mem->decRef();

            if (mem->ref() == 0)
                delete(mem);
        }
    }

    void swap(memory_c & mem_obj)
    {
        // Save on temporal

        void * mem_tmp = static_cast<void*>(mem);
        void * mem_r_tmp = static_cast<void*>(mem_r);

        // swap the memory between objects

        mem = mem_obj.mem;
        mem_r = mem_obj.mem_r;

        mem_obj.mem = static_cast<D*>(mem_tmp);
        mem_obj.mem_r = static_cast<memory_array<T>*>(mem_r_tmp);
    }

};

template<typename T>
class multi_array
{
    typedef T type;
};

template<typename T>
class key
{
    typedef T type;
};


template<typename T, unsigned int N>
struct mult
{
    enum { value = mult<T,N-1>::value * boost::mpl::at<T,boost::mpl::int_<N>>::type::value };
};

template <typename T>
struct mult<T,1>
{
    enum { value = boost::mpl::at<T,boost::mpl::int_<1>>::type::value };
};

template<typename T, typename D>
class memory_c<multi_array<T>, D>
{
//  typedef T type;

    template<int S> using int_ = boost::mpl::int_<S>;

    typedef typename boost::mpl::size<T> size_p;

    template< typename S, unsigned int n> using at = boost::mpl::at<S,boost::mpl::int_<n> >;

    typedef typename at<T,0>::type base;

    typedef typename boost::multi_array_ref<base,size_p::value>::size_type size_type;


    template<size_t index,size_t N> struct ordering
    {
        enum { value = (N-index) % N };
    };

    template<size_t index,size_t N> struct ascending
    {
        enum { value = true };
    };

    public:

    void setMemory(memory & mem)
    {
        if (this->mem != NULL)
        {
            this->mem->decRef();

            if (this->mem->ref() == 0 && &mem != this->mem)
                delete(this->mem);
        }
        mem.incRef();
        this->mem = &mem;
    }

    memory& getMemory()
    {
        return *this->mem;
    }

    bool allocate(const size_t sz)
    {
        memory * mem = this->mem;

        mem->resize( sz*mult<T,size_p::value-1>::value*sizeof(base) );

        // We create an array dims from the boost::mpl::vector
        typedef typename generate_array_vector<size_type,T>::result dims;

        std::array<size_type ,size_p::value> dimensions;

        // fill runtime, and the other dimensions
        dimensions[0] = sz;
        for (int i = 0 ; i < size_p::value-1 ; i++)
        {dimensions[i+1] = dims::data[i];}

        typedef typename generate_array<typename boost::multi_array<T,size_p::value>::size_type,size_p::value, ordering>::result ord;

        // we generate the ascending buffer
        typedef typename generate_array<bool,size_p::value, ascending>::result asc;

        mem_r = new boost::multi_array_ref<base,size_p::value>(static_cast<base *>(mem->getPointer()),dimensions,boost::general_storage_order<size_p::value>(ord::data,asc::data));

        return true;
    }

    typedef boost::multi_array<base,size_p::value> type;

    D * mem;

    boost::multi_array_ref<base,boost::mpl::size<T>::value> * mem_r;

    memory_c():mem(NULL),mem_r(NULL){}

    ~memory_c()
    {
        delete(mem_r);
        if (mem != NULL)
        {
            mem->decRef();
            if (mem->ref() == 0)
                delete(mem);
        }
    }

    void set_mem(memory & mem)
    {
        this->mem = &mem;
    }

    void swap(memory_c & mem_obj)
    {
        // Save on temporal

        void * mem_tmp = static_cast<void*>(mem);
        void * mem_r_tmp = static_cast<void*>(mem_r);

        // swap the memory between objects

        mem = mem_obj.mem;
        mem_r = mem_obj.mem_r;

        mem_obj.mem = static_cast<D*>(mem_tmp);
        mem_obj.mem_r = static_cast<decltype(mem_obj.mem_r)>(mem_r_tmp);
    }
};

#endif