BufferDetailIterator.hh

Go to the documentation of this file.

#ifndef avro_BufferDetailIterator_hh__
#define avro_BufferDetailIterator_hh__

#include "BufferDetail.hh"

namespace avro {

namespace detail {

struct InputIteratorHelper
{
    InputIteratorHelper() :
        iter_()
    {}

    InputIteratorHelper(const BufferImpl::ChunkList::const_iterator &iter) :
        iter_(iter)
    {}

    const data_type *data() const {
        return iter_->tellReadPos();
    }

    size_type size() const {
        return iter_->dataSize();
    }

#ifdef HAVE_BOOST_ASIO
    operator ConstAsioBuffer() const {
        return ConstAsioBuffer(data(), size());
    }
#endif

    BufferImpl::ChunkList::const_iterator iter_; 
};

struct OutputIteratorHelper
{
    OutputIteratorHelper() :
            iter_()
    {}

    OutputIteratorHelper(const BufferImpl::ChunkList::const_iterator &iter) :
            iter_(iter)
    {}

    data_type *data() const {
        return iter_->tellWritePos();
    }

    size_type size() const {
        return iter_->freeSize();
    }

#ifdef HAVE_BOOST_ASIO
    operator MutableAsioBuffer() const {
        return MutableAsioBuffer(data(), size());
    }
#endif

    BufferImpl::ChunkList::const_iterator iter_; 
};

template<typename Helper>
class BufferIterator 
{

  public:

    typedef BufferIterator<Helper> this_type;

    typedef std::forward_iterator_tag iterator_category; // this is a lie to appease asio
    typedef Helper value_type;
    typedef std::ptrdiff_t difference_type;
    typedef value_type* pointer;
    typedef value_type& reference;

    BufferIterator() :
        helper_()
    { }

    /* The default implementations are good here
    BufferIterator(const BufferIterator &src) :
        helper_(src.helper_)
    { }
    this_type& operator= (const this_type &rhs) {
        helper_ = rhs.helper_;
        return *this;
    }
    */

    explicit BufferIterator(BufferImpl::ChunkList::const_iterator iter) :
        helper_(iter)
    { }

    reference operator *() {
        return helper_;
    }

    const value_type &operator *() const {
        return helper_;
    }

    pointer operator->() {
        return &helper_;
    }

    const value_type *operator->() const {
        return &helper_;
    }
    
    this_type& operator++() 
    {
        ++helper_.iter_;
        return *this;
    }

    this_type operator++(int)
    {
        this_type ret = *this;
        ++helper_.iter_;
        return ret;
    }

    bool operator==(const this_type &rhs) const {
        return (helper_.iter_ == rhs.helper_.iter_);
    }

    bool operator!=(const this_type &rhs) const {
        return (helper_.iter_ != rhs.helper_.iter_);
    }

  private:

    Helper helper_;
};

typedef BufferIterator<InputIteratorHelper> InputBufferIterator;
typedef BufferIterator<OutputIteratorHelper> OutputBufferIterator;

} // detail namespace

} // namespace

#endif