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

class BHeapMemory : public HeapMemory
{
    size_t buf_sz;

public:

    BHeapMemory(const BHeapMemory & mem)
    :HeapMemory(mem),buf_sz(mem.size())
    {
    }

    BHeapMemory(BHeapMemory && mem) noexcept
    :HeapMemory((HeapMemory &&)mem),buf_sz(mem.size())
    {
    }

    BHeapMemory()
    :HeapMemory(),buf_sz(0)
    {};

    virtual ~BHeapMemory() noexcept
    {
    };

    virtual bool allocate(size_t sz)
    {
        bool ret = HeapMemory::allocate(sz);

        if (ret == true)
            buf_sz = sz;

        return ret;
    }

    virtual bool resize(size_t sz)
    {
        bool ret = HeapMemory::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 HeapMemory::size();
    }

    BHeapMemory & operator=(const BHeapMemory & mem)
    {
        buf_sz = mem.buf_sz;
        static_cast<HeapMemory *>(this)->operator=(mem);

        return *this;
    }

    BHeapMemory & operator=(BHeapMemory && mem)
    {
        buf_sz = mem.buf_sz;
        static_cast<HeapMemory *>(this)->operator=(mem);

        return *this;
    }

    void destroy()
    {
        HeapMemory::destroy();
        buf_sz = 0;
    }

    void swap(BHeapMemory & mem)
    {
        HeapMemory::swap(mem);

        size_t buf_sz_t = mem.buf_sz;
        mem.buf_sz = buf_sz;
        buf_sz = buf_sz_t;
    }
};


#endif