/usr/include/boost/iostreams/detail
Edit: /usr/include/boost/iostreams/detail/buffer.hpp (7488B)
// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
// (C) Copyright 2003-2007 Jonathan Turkanis
// 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.)
// See http://www.boost.org/libs/iostreams for documentation.
#ifndef BOOST_IOSTREAMS_DETAIL_BUFFERS_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_BUFFERS_HPP_INCLUDED
#if defined(_MSC_VER)
# pragma once
#endif
#include
// swap.
#include // allocator.
#include // member templates.
#include
#include // streamsize.
#include
#include // int_type_of.
#include
#include
#include
namespace boost { namespace iostreams { namespace detail {
//----------------Buffers-----------------------------------------------------//
//
// Template name: buffer
// Description: Character buffer.
// Template parameters:
// Ch - The character type.
// Alloc - The Allocator type.
//
template< typename Ch,
typename Alloc = std::allocator >
class basic_buffer {
private:
#ifndef BOOST_NO_STD_ALLOCATOR
#if defined(BOOST_NO_CXX11_ALLOCATOR)
typedef typename Alloc::template rebind::other allocator_type;
#else
typedef typename std::allocator_traits::template rebind_alloc allocator_type;
typedef std::allocator_traits allocator_traits;
#endif
#else
typedef std::allocator allocator_type;
#endif
static Ch* allocate(std::streamsize buffer_size);
public:
basic_buffer();
basic_buffer(std::streamsize buffer_size);
~basic_buffer();
void resize(std::streamsize buffer_size);
Ch* begin() const { return buf_; }
Ch* end() const { return buf_ + size_; }
Ch* data() const { return buf_; }
std::streamsize size() const { return size_; }
void swap(basic_buffer& rhs);
private:
// Disallow copying and assignment.
basic_buffer(const basic_buffer&);
basic_buffer& operator=(const basic_buffer&);
Ch* buf_;
std::streamsize size_;
};
template
void swap(basic_buffer& lhs, basic_buffer& rhs)
{ lhs.swap(rhs); }
//
// Template name: buffer
// Description: Character buffer with two pointers accessible via ptr() and
// eptr().
// Template parameters:
// Ch - A character type.
//
template< typename Ch,
typename Alloc = std::allocator >
class buffer : public basic_buffer {
private:
typedef basic_buffer base;
public:
typedef iostreams::char_traits traits_type;
using base::resize;
using base::data;
using base::size;
typedef Ch* const const_pointer;
buffer(std::streamsize buffer_size);
Ch* & ptr() { return ptr_; }
const_pointer& ptr() const { return ptr_; }
Ch* & eptr() { return eptr_; }
const_pointer& eptr() const { return eptr_; }
void set(std::streamsize ptr, std::streamsize end);
void swap(buffer& rhs);
// Returns an int_type as a status code.
template
typename int_type_of::type fill(Source& src)
{
using namespace std;
std::streamsize keep;
if ((keep = static_cast(eptr_ - ptr_)) > 0)
traits_type::move(
this->data(),
ptr_,
static_cast(keep)
);
set(0, keep);
std::streamsize result =
iostreams::read(src, this->data() + keep, this->size() - keep);
if (result != -1)
this->set(0, keep + result);
return result == -1 ?
traits_type::eof() :
result == 0 ?
traits_type::would_block() :
traits_type::good();
}
// Returns true if one or more characters were written.
template
bool flush(Sink& dest)
{
using namespace std;
std::streamsize amt = static_cast(eptr_ - ptr_);
std::streamsize result = iostreams::write_if(dest, ptr_, amt);
if (result < amt) {
traits_type::move( this->data(),
ptr_ + static_cast(result),
static_cast(amt - result) );
}
this->set(0, amt - result);
return result != 0;
}
private:
Ch *ptr_, *eptr_;
};
template
void swap(buffer& lhs, buffer& rhs)
{ lhs.swap(rhs); }
//--------------Implementation of basic_buffer--------------------------------//
template
basic_buffer::basic_buffer() : buf_(0), size_(0) { }
template
inline Ch* basic_buffer::allocate(std::streamsize buffer_size)
{
#if defined(BOOST_NO_CXX11_ALLOCATOR) || defined(BOOST_NO_STD_ALLOCATOR)
return static_cast(allocator_type().allocate(
static_cast(buffer_size), 0));
#else
allocator_type alloc;
return static_cast(allocator_traits::allocate(alloc,
static_cast(buffer_size)));
#endif
}
template
basic_buffer::basic_buffer(std::streamsize buffer_size)
: buf_(allocate(buffer_size)),
size_(buffer_size) // Cast for SunPro 5.3.
{ }
template
inline basic_buffer::~basic_buffer()
{
if (buf_) {
#if defined(BOOST_NO_CXX11_ALLOCATOR) || defined(BOOST_NO_STD_ALLOCATOR)
allocator_type().deallocate(buf_,
static_cast(size_));
#else
allocator_type alloc;
allocator_traits::deallocate(alloc, buf_,
static_cast(size_));
#endif
}
}
template
inline void basic_buffer::resize(std::streamsize buffer_size)
{
if (size_ != buffer_size) {
basic_buffer temp(buffer_size);
std::swap(size_, temp.size_);
std::swap(buf_, temp.buf_);
}
}
template
void basic_buffer::swap(basic_buffer& rhs)
{
std::swap(buf_, rhs.buf_);
std::swap(size_, rhs.size_);
}
//--------------Implementation of buffer--------------------------------------//
template
buffer::buffer(std::streamsize buffer_size)
: basic_buffer(buffer_size), ptr_(data()), eptr_(data() + buffer_size) { }
template
inline void buffer::set(std::streamsize ptr, std::streamsize end)
{
ptr_ = data() + ptr;
eptr_ = data() + end;
}
template
inline void buffer::swap(buffer& rhs)
{
base::swap(rhs);
std::swap(ptr_, rhs.ptr_);
std::swap(eptr_, rhs.eptr_);
}
//----------------------------------------------------------------------------//
} } } // End namespaces detail, iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_BUFFERS_HPP_INCLUDED