BHeapMemory.hpp

/*
 * RHeapMempory.hpp
 *
 *  Created on: Aug 17, 2014
 *      Author: Pietro Incardona
 */
 
 
#ifndef BHEAP_MEMORY_HPP
#define BHEAP_MEMORY_HPP
 
#include "config.h"
#include "memory.hpp"
#include <cstddef>
#include <cstdint>
#include <iostream>
 
typedef unsigned char byte;
 
#define MEM_ALIGNMENT 32
 
template<typename Memory>
class BMemory : public Memory
{
    size_t buf_sz;
 
public:
 
    BMemory(const BMemory<Memory> & mem)
    :Memory(mem),buf_sz(mem.size())
    {
    }
 
    BMemory(BMemory<Memory> && mem) noexcept
    :Memory((Memory &&)mem),buf_sz(mem.size())
    {
    }
 
    BMemory()
    :Memory(),buf_sz(0)
    {};
 
    virtual ~BMemory() noexcept
    {
    };
 
    virtual bool allocate(size_t sz)
    {
        bool ret = Memory::allocate(sz);
 
        if (ret == true)
            buf_sz = sz;
 
        return ret;
    }
 
    virtual bool resize(size_t sz)
    {
        bool ret = Memory::resize(sz);
 
        // if the allocated memory is enough, do not resize
        if (ret == true)
            buf_sz = sz;
 
        return ret;
    }
 
    virtual size_t size() const
    {
        return buf_sz;
    }
 
    size_t msize()
    {
        return Memory::size();
    }
 
    BMemory & operator=(const BMemory<Memory> & mem)
    {
        buf_sz = mem.buf_sz;
        static_cast<Memory *>(this)->operator=(mem);
 
        return *this;
    }
 
    BMemory & operator=(BMemory<Memory> && mem)
    {
        buf_sz = mem.buf_sz;
        static_cast<Memory *>(this)->operator=(mem);
 
        return *this;
    }
 
    void destroy()
    {
        Memory::destroy();
        buf_sz = 0;
    }
 
    void swap(BMemory<Memory> & mem)
    {
        Memory::swap(mem);
 
        size_t buf_sz_t = mem.buf_sz;
        mem.buf_sz = buf_sz;
        buf_sz = buf_sz_t;
    }
};
 
 
#endif