/home/palakars/workspace-inprogress/code-in-progress/aitools3/aitools3-aq-invertedindex-cpp/src/core/ByteBuffer.cpp

Go to the documentation of this file.

#include "ByteBuffer.hpp"
#include <cstring> // std::memset, std::memcpy
#include <cstdlib> // std::malloc, std::realloc

namespace aitools {
namespace invertedindex {

ByteBuffer::ByteBuffer(size_t size) throw (std::bad_alloc)
:   data_(static_cast<char*>(std::malloc(size))),
    capacity_(size),
        size_(size)
{
        if (data_ == NULL)
        {
                throw std::bad_alloc();
        }
        std::memset(data_, 0, size_);
}

ByteBuffer::ByteBuffer(const ByteBuffer& buffer) throw (std::bad_alloc)
:   data_(static_cast<char*>(std::malloc(buffer.size_))),
    capacity_(buffer.size_),
        size_(buffer.size_)
{
        if (data_ == NULL)
        {
                throw std::bad_alloc();
        }
        std::memcpy(data_, buffer.data_, size_);
}

ByteBuffer::~ByteBuffer()
{
        free();
}

size_t
ByteBuffer::capacity() const
{
        return capacity_;
}

void
ByteBuffer::clear()
{
        size_ = 0;
}

char*
ByteBuffer::data()
{
        return data_;
}

const char*
ByteBuffer::data() const
{
        return data_;
}

bool
ByteBuffer::empty() const
{
        return size_ == 0;
}

void
ByteBuffer::free()
{
        if (data_ != NULL)
        {
                std::free(data_);
                capacity_ = 0;
                data_ = NULL;
                size_ = 0;
        }
}

ByteBuffer&
ByteBuffer::operator=(const ByteBuffer& buffer) throw (std::bad_alloc)
{
        resize(buffer.size_);
        std::memcpy(data_, buffer.data_, size_);
        return *this;
}

bool
ByteBuffer::operator==(const ByteBuffer& buffer) const
{
        if (size_ != buffer.size_) return false;
        return std::memcmp(data_, buffer.data_, size_) == 0;
}

bool
ByteBuffer::operator!=(const ByteBuffer& buffer) const
{
        return !(*this == buffer);
}

void
ByteBuffer::resize(size_t size) throw (std::bad_alloc)
{
        if (size > capacity_)
        {
                char* data(static_cast<char*>(std::realloc(data_, size)));
                if (size != 0 && data == NULL)
                {
                        throw std::bad_alloc();
                }
                capacity_ = size;
                data_ = data;
        }
        size_ = size;
}

size_t
ByteBuffer::size() const
{
        return size_;
}

} // namespace invertedindex
} // namespace aitools

namespace std {

        ostream&
        operator<<(ostream& os, const aitools::invertedindex::ByteBuffer& buffer)
        {
                if (os)
                {
                        os << "ByteBuffer [ size = " << buffer.size()
                       << ", capacity = " << buffer.capacity() << " ]";
                }
                return os;
        }
}

---