Buffer.hh

Go to the documentation of this file.

#ifndef avro_Buffer_hh__
#define avro_Buffer_hh__

#include <sys/uio.h>
#include <boost/type_traits.hpp>
#include <vector>

#include "detail/BufferDetail.hh"
#include "detail/BufferDetailIterator.hh"

namespace avro {

class OutputBuffer;
class InputBuffer;


class OutputBuffer 
{

  public:

    typedef detail::size_type size_type;
    typedef detail::data_type data_type;

    typedef detail::OutputBufferIterator const_iterator;

    OutputBuffer(size_type reserveSize = 0) :
        pimpl_(new detail::BufferImpl) 
    { 
        if(reserveSize) { 
            reserve(reserveSize); 
        }
    }

    void reserve(size_type reserveSize) 
    {
        pimpl_->reserveFreeSpace(reserveSize);
    }

    size_type writeTo(const data_type *data, size_type size) {
        return pimpl_->writeTo(data, size);
    }

    template<typename T>
    void writeTo(T val) {
        pimpl_->writeTo(val, boost::is_fundamental<T>());
    }

    size_type wroteTo(size_type size) 
    {
        int wrote = 0;
        if(size) {
            if(size > freeSpace()) {
                throw std::length_error("Impossible to write more data than free space");
            }
            wrote = pimpl_->wroteTo(size);
        }
        return wrote;
    }

    bool empty() const {
        return  (pimpl_->size()==0);
    }

    size_type size() const {
        return  pimpl_->size();
    }

    size_type freeSpace() const {
        return  pimpl_->freeSpace();
    }

    template <class BufferType>
    void append(const BufferType &buf) {
        // don't append an empty buffer
        if(buf.size()) {
            pimpl_->append(*(buf.pimpl_.get()));
        }
    }

    const_iterator begin() const {
        return const_iterator(pimpl_->beginWrite());
    }

    const_iterator end() const {
        return const_iterator(pimpl_->endWrite());
    }

    void discardData()
    {
        pimpl_->discardData();
    }

    void discardData(size_t bytes)
    {
        if(bytes > 0) {
            if(bytes < pimpl_->size()) {
                pimpl_->discardData(bytes);
            }
            else if(bytes == pimpl_->size()) {
                pimpl_->discardData();
            }
            else {
                throw std::out_of_range("trying to discard more data than exists");
            }
        }
    }

    InputBuffer extractData(size_type bytes);

    InputBuffer extractData();

    OutputBuffer clone() const 
    {
        detail::BufferImpl::SharedPtr newImpl(new detail::BufferImpl(*pimpl_));
        return OutputBuffer(newImpl);
    }

    void appendForeignData(const data_type *data, size_type size, const detail::free_func &func) {
        pimpl_->appendForeignData(data, size, func);
    }

    int numChunks() const {
        return  pimpl_->numFreeChunks();
    }

    int numDataChunks() const {
        return  pimpl_->numDataChunks();
    }

  private:

    friend class InputBuffer;
    friend class BufferReader;

    explicit OutputBuffer(const detail::BufferImpl::SharedPtr &pimpl) :
        pimpl_(pimpl) 
    { }

    detail::BufferImpl::SharedPtr pimpl_; 
};

class InputBuffer 
{

  public:

    typedef detail::size_type size_type;
    typedef detail::data_type data_type;

    // needed for asio
    typedef detail::InputBufferIterator const_iterator;

    InputBuffer() :
        pimpl_(new detail::BufferImpl)
    { }

    InputBuffer(const OutputBuffer &src) :
        pimpl_(new detail::BufferImpl(*src.pimpl_))
    { }

    bool empty() const {
        return (pimpl_->size() == 0);
    }

    size_type size() const {
        return pimpl_->size();
    }

    const_iterator begin() const {
        return const_iterator(pimpl_->beginRead());
    }

    const_iterator end() const {
        return const_iterator(pimpl_->endRead());
    }

    int numChunks() const {
        return pimpl_->numDataChunks();
    }


  private:

    friend class OutputBuffer; // for append function
    friend class istreambuf;
    friend class BufferReader;

    explicit InputBuffer(const detail::BufferImpl::SharedPtr &pimpl) :
        pimpl_(pimpl) 
    { }

    class ShallowCopy {};

    InputBuffer(const OutputBuffer &src, const ShallowCopy &) : 
        pimpl_(src.pimpl_)
    { }

     InputBuffer(const InputBuffer &src, const ShallowCopy &) : 
        pimpl_(src.pimpl_)
    { }


    detail::BufferImpl::ConstSharedPtr pimpl_; 
};


/* 
 * Implementations of some OutputBuffer functions are inlined here
 * because InputBuffer definition was required before.
 */

inline InputBuffer OutputBuffer::extractData() 
{
    detail::BufferImpl::SharedPtr newImpl(new detail::BufferImpl);
    if(pimpl_->size()) {
        pimpl_->extractData(*newImpl);
    }
    return InputBuffer(newImpl);
}

inline InputBuffer OutputBuffer::extractData(size_type bytes)
{
    if(bytes > pimpl_->size()) {
        throw std::out_of_range("trying to extract more data than exists");
    }

    detail::BufferImpl::SharedPtr newImpl(new detail::BufferImpl);
    if(bytes > 0) {
        if(bytes < pimpl_->size()) {
            pimpl_->extractData(*newImpl, bytes);
        }
        else {
            pimpl_->extractData(*newImpl);
        }
    }

    return InputBuffer(newImpl);
}

template<class BufferType>
inline void toIovec(BufferType &buf, std::vector<struct iovec> &iov) 
{
    const int chunks = buf.numChunks();
    iov.resize(chunks);
    typename BufferType::const_iterator iter = buf.begin();
    for (int i = 0; i < chunks; ++i) {
        iov[i].iov_base = const_cast<typename BufferType::data_type *>(iter->data());
        iov[i].iov_len = iter->size();
        ++iter;
    }
}

} // namespace

#endif