//

// buffered_stream_storage.hpp

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~

//

// Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com)

//

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//



#ifndef BOOST_ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP

#define BOOST_ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP



#if defined(_MSC_VER) && (_MSC_VER >= 1200)

# pragma once

#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)



#include <boost/asio/detail/push_options.hpp>



#include <boost/asio/detail/push_options.hpp>

#include <boost/config.hpp>

#include <cassert>

#include <cstddef>

#include <cstring>

#include <vector>

#include <boost/asio/detail/pop_options.hpp>



namespace boost {

namespace asio {

namespace detail {



class buffered_stream_storage

{

public:

  // The type of the bytes stored in the buffer.

  typedef unsigned char byte_type;



  // The type used for offsets into the buffer.

  typedef std::size_t size_type;



  // Constructor.

  explicit buffered_stream_storage(std::size_t capacity)

    : begin_offset_(0),

      end_offset_(0),

      buffer_(capacity)

  {

  }



  /// Clear the buffer.

  void clear()

  {

    begin_offset_ = 0;

    end_offset_ = 0;

  }



  // Return a pointer to the beginning of the unread data.

  byte_type* data()

  {

    return &buffer_[0] + begin_offset_;

  }



  // Return a pointer to the beginning of the unread data.

  const byte_type* data() const

  {

    return &buffer_[0] + begin_offset_;

  }



  // Is there no unread data in the buffer.

  bool empty() const

  {

    return begin_offset_ == end_offset_;

  }



  // Return the amount of unread data the is in the buffer.

  size_type size() const

  {

    return end_offset_ - begin_offset_;

  }



  // Resize the buffer to the specified length.

  void resize(size_type length)

  {

    assert(length <= capacity());

    if (begin_offset_ + length <= capacity())

    {

      end_offset_ = begin_offset_ + length;

    }

    else

    {

      using namespace std; // For memmove.

      memmove(&buffer_[0], &buffer_[0] + begin_offset_, size());

      end_offset_ = length;

      begin_offset_ = 0;

    }

  }



  // Return the maximum size for data in the buffer.

  size_type capacity() const

  {

    return buffer_.size();

  }



  // Consume multiple bytes from the beginning of the buffer.

  void consume(size_type count)

  {

    assert(begin_offset_ + count <= end_offset_);

    begin_offset_ += count;

    if (empty())

      clear();

  }



private:

  // The offset to the beginning of the unread data.

  size_type begin_offset_;



  // The offset to the end of the unread data.

  size_type end_offset_;

  

  // The data in the buffer.

  std::vector<byte_type> buffer_;

};



} // namespace detail

} // namespace asio

} // namespace boost



#include <boost/asio/detail/pop_options.hpp>



#endif // BOOST_ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP

