mn_buffer.hpp

Go to the documentation of this file.

 
#ifndef __MINILIB_BASIC_BUFFER_H__
#define __MINILIB_BASIC_BUFFER_H__
 
#include "mn_config.hpp"
 
#include <cassert>
 
#include "mn_allocator.hpp"
#include "mn_typetraits.hpp"
#include "mn_algorithm.hpp"
 
namespace mn {
 
    template <typename TVALUE, class TALLOCATOR = memory::default_allocator>
    class buffer : MN_ONCOPYABLE_CLASS {
    public:
        using self_type = buffer<TVALUE, TALLOCATOR>;
        using value_type = TVALUE;
        using allocator = TALLOCATOR;
        using pointer = value_type*;
        using reference = value_type&;
        using size_type = mn::size_t;
 
        using const_reference = const value_type&;
        using const_pointer = const value_type*;
 
        using iterator_category = random_access_iterator_tag ;
        using difference_type = ptrdiff_t;
        using iterator = pointer;
        using const_iterator = const value_type*;
 
        buffer(const size_type& size)
            : m_sSize(size), m_sUsed(size), m_pRawBuffer(0), m_bOwnMem(true), m_allocator()  {
            init_internal_buffer(size);
        }
 
        buffer(pointer buffer, size_type size)
            : m_sSize(size), m_sUsed(size), m_pRawBuffer(buffer), m_bOwnMem(false), m_allocator()  { }
 
 
        buffer(const_pointer buffer, size_type size)
            : m_sSize(size), m_sUsed(size), m_pRawBuffer(0), m_bOwnMem(true), m_allocator()  {
            init_internal_buffer(buffer);
        }
 
 
        buffer(const self_type& other)
            : m_sSize(other.m_sSize), m_sUsed(other.m_sUsed), m_pRawBuffer(0), m_bOwnMem(true), m_allocator() {
            init_internal_buffer(other.m_pRawBuffer);
        }
 
        ~buffer() {
            destroy_internal_buffer();
        }
 
        iterator begin()            { return m_pRawBuffer; }
 
        const_iterator begin() const { return m_pRawBuffer; }
 
        iterator end()              { return m_pRawBuffer; }
 
        const_iterator end() const  { return m_pRawBuffer; }
 
        void append(const_pointer pBuffer, std::size_t sBufferSize) {
            if (sBufferSize == 0) return;
            if(resize(m_sUsed + sBufferSize, true))
                memcpy(m_pRawBuffer + m_sUsed - sBufferSize, pBuffer, sBufferSize * sizeof(value_type));
        }
 
        void append(value_type value) {
            if(resize(m_sUsed + 1, true))
                m_pRawBuffer[m_sUsed - 1] = value;
        }
 
        void append(const self_type& refBuffer) {
            append(refBuffer.begin(), refBuffer.used());
        }
 
        bool resize(size_type newSize, bool bReserve = true) {
            if(!m_bOwnMem) return false;
            if(newSize > m_sSize) {
                pointer __pNewRawBuffer = m_allocator.alloc(newSize * sizeof(value_type));
                if(__pNewRawBuffer == 0) return false;
 
                if(bReserve) memcpy(__pNewRawBuffer, m_pRawBuffer, m_sUsed * sizeof(value_type));
 
                m_allocator.free(m_pRawBuffer);
                m_pRawBuffer = __pNewRawBuffer;
                m_sSize = newSize;
            }
            m_sUsed = newSize;
 
            return true;
        }
 
        bool change_size(size_type newSize, bool bReserve = true) {
            if(!m_bOwnMem) return false;
            if (newSize == m_sSize) return true;
 
            pointer __pNewRawBuffer = NULL;
            if(newSize > 0) {
                __pNewRawBuffer = m_allocator.alloc(newSize * sizeof(value_type));
                if(bReserve)  memcpy(__pNewRawBuffer, m_pRawBuffer,
                                     (m_sUsed < newSize ? m_sUsed : newSize) * sizeof(value_type));
            }
 
            m_allocator.free(m_pRawBuffer);
            m_pRawBuffer = __pNewRawBuffer;
            m_sSize = newSize;
 
            if (newSize < m_sUsed) m_sUsed = newSize;
 
        }
 
        void assign(const_pointer pBuffer, size_type size) {
            if (0 == size) return;
            if (size > m_sSize) resize(size, false);
 
            memcpy(m_pRawBuffer, pBuffer, size * sizeof(value_type));
            m_sUsed = size;
        }
 
        void clear() {
            memset(m_pRawBuffer, 0, m_sUsed * sizeof(value_type));
        }
        bool is_equel(const buffer& other) const {
            if(m_sSize != other.m_sSize) return false;
            if(m_sUsed != other.m_sUsed) return false;
 
            return (memcmp(m_pRawBuffer, other.m_pRawBuffer, m_sUsed * sizeof(value_type)) == 0);
        }
 
        constexpr bool is_empty() const noexcept            { return m_sUsed == 0; }
 
        constexpr bool is_full() const noexcept             { return m_sUsed == m_sSize; }
        constexpr size_type get_size() const noexcept       { return m_sSize; }
 
        constexpr size_type get_size_bytes() const noexcept { return m_sSize * sizeof(value_type); }
 
        constexpr size_type get_used() const noexcept       { return m_sUsed; }
 
        constexpr size_type get_used_bytes() const noexcept { return m_sUsed * sizeof(value_type); }
 
        bool operator == (const buffer& other) const {
            return is_equel(other);
        }
        bool operator != (const buffer& other) const {
            return !(is_equel(other));
        }
 
        reference operator [] (size_type index) {
            assert (index < m_sUsed);
            return m_pRawBuffer[index];
        }
 
        const_reference operator [] (size_type index) const {
            assert (index < m_sUsed);
            return m_pRawBuffer[index];
        }
    private:
        void init_internal_buffer() {
            if(m_sSize > 0)
                m_pRawBuffer = m_allocator.allocate(m_sSize, sizeof(value_type),
                                                    mn::aligned_as<value_type>::res );
        }
 
        void init_internal_buffer(const pointer buffer) {
            if(m_sSize > 0) {
                m_pRawBuffer = m_allocator.allocate(m_sSize, sizeof(value_type),
                                                    mn::aligned_as<value_type>::res);
 
                memcpy(m_pRawBuffer, buffer, m_sUsed * sizeof(value_type));
            }
        }
 
        void destroy_internal_buffer() {
            if(m_bOwnMem && (m_pRawBuffer != 0))
                m_allocator.deallocate(m_pRawBuffer, sizeof(value_type), mn::aligned_as<value_type>::res);
        }
    private:
        size_type m_sSize;
        size_type m_sUsed;
        pointer   m_pRawBuffer;
        bool      m_bOwnMem;
        allocator m_allocator;
    };
 
}
 
#endif // __MINILIB_BASIC_BUFFER_H__