anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-12-22 05:16:21 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

* Add the iostreams and range libs to our copy of boost

Browse Source 
* Make sure that no source files in boost are executable
	* Make sure that all boost files are marked with eol-style native
	* configure.ac: setup for new iostreams boost binary lib
	* config/common.am: add boost iostreams variable


git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@13705 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
Lars Gullik Bjønnes 2006-04-20 20:44:05 +00:00
parent 5ac63517c6
commit 0b6deecd95
124 changed files with 14131 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
boost/boost/detail/indirect_traits.hpp Executable file → Normal file
View File

0
boost/boost/detail/is_incrementable.hpp Executable file → Normal file
View File

0
boost/boost/indirect_reference.hpp Executable file → Normal file
View File

142
boost/boost/iostreams/categories.hpp Normal file
View File

@ -0,0 +1,142 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Contains category and mode tags for classifying filters, devices and
// standard stream and stream buffers types.
#ifndef BOOST_IOSTREAMS_CATEGORIES_HPP_INCLUDED
#define BOOST_IOSTREAMS_CATEGORIES_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
namespace boost { namespace iostreams {
//------------------Tags for dispatch according to i/o mode-------------------//
struct any_tag { };
namespace detail { struct two_sequence : virtual any_tag { }; }
namespace detail { struct random_access : virtual any_tag { }; }
namespace detail { struct one_head : virtual any_tag { }; }
namespace detail { struct two_head : virtual any_tag { }; }
struct input : virtual any_tag { };
struct output : virtual any_tag { };
struct bidirectional : virtual input, virtual output, detail::two_sequence { };
struct dual_use : virtual input, virtual output { }; // Pseudo-mode.
struct input_seekable : virtual input, virtual detail::random_access { };
struct output_seekable : virtual output, virtual detail::random_access { };
struct seekable
: virtual input_seekable,
virtual output_seekable,
detail::one_head
{ };
struct dual_seekable
: virtual input_seekable,
virtual output_seekable,
detail::two_head
{ };
struct bidirectional_seekable
: input_seekable, output_seekable,
bidirectional, detail::two_head
{ };
//------------------Tags for use as i/o categories----------------------------//
struct device_tag : virtual any_tag { };
struct filter_tag : virtual any_tag { };
//
// Tags for optional behavior.
//
struct peekable_tag : virtual any_tag { }; // Devices.
struct closable_tag : virtual any_tag { };
struct flushable_tag : virtual any_tag { };
struct localizable_tag : virtual any_tag { };
struct optimally_buffered_tag : virtual any_tag { };
struct direct_tag : virtual any_tag { }; // Devices.
struct multichar_tag : virtual any_tag { }; // Filters.
struct source_tag : device_tag, input { };
struct sink_tag : device_tag, output { };
struct bidirectional_device_tag : device_tag, bidirectional { };
struct seekable_device_tag : virtual device_tag, seekable { };
struct input_filter_tag : filter_tag, input { };
struct output_filter_tag : filter_tag, output { };
struct bidirectional_filter_tag : filter_tag, bidirectional { };
struct seekable_filter_tag : filter_tag, seekable { };
struct dual_use_filter_tag : filter_tag, dual_use { };
struct multichar_input_filter_tag
: multichar_tag,
input_filter_tag
{ };
struct multichar_output_filter_tag
: multichar_tag,
output_filter_tag
{ };
struct multichar_bidirectional_filter_tag
: multichar_tag,
bidirectional_filter_tag
{ };
struct multichar_seekable_filter_tag
: multichar_tag,
seekable_filter_tag
{ };
struct multichar_dual_use_filter_tag
: filter_tag,
dual_use
{ };
//
// Tags for standard streams and streambufs.
//
struct std_io_tag : virtual localizable_tag { };
struct istream_tag
: virtual input_seekable,
virtual device_tag,
virtual peekable_tag,
virtual std_io_tag
{ };
struct ostream_tag
: virtual output_seekable,
virtual device_tag,
virtual peekable_tag,
virtual std_io_tag
{ };
struct iostream_tag
: seekable_device_tag,
istream_tag,
ostream_tag
{ };
struct streambuf_tag
: seekable_device_tag,
peekable_tag,
std_io_tag
{ };
struct stringstream_tag
: dual_seekable,
device_tag,
std_io_tag
{ };
struct stringbuf_tag
: dual_seekable,
device_tag,
std_io_tag
{ };
namespace detail {
struct linked_tag : streambuf_tag { };
} // End namespace detail.
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_CATEGORIES_HPP_INCLUDED

582
boost/boost/iostreams/chain.hpp Normal file
View File

@ -0,0 +1,582 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_CHAIN_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_CHAIN_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <algorithm> // for_each.
#include <cassert>
#include <exception>
#include <functional> // unary_function.
#include <iterator> // advance.
#include <list>
#include <memory> // allocator, auto_ptr.
#include <typeinfo>
#include <stdexcept> // logic_error, out_of_range.
#include <boost/checked_delete.hpp>
#include <boost/config.hpp> // BOOST_MSVC, template friends,
#include <boost/detail/workaround.hpp> // BOOST_NESTED_TEMPLATE
#include <boost/iostreams/constants.hpp>
#include <boost/iostreams/detail/access_control.hpp>
#include <boost/iostreams/detail/char_traits.hpp>
#include <boost/iostreams/detail/push.hpp>
#include <boost/iostreams/detail/streambuf.hpp> // pubsync.
#include <boost/iostreams/detail/wrap_unwrap.hpp>
#include <boost/iostreams/device/null.hpp>
#include <boost/iostreams/positioning.hpp>
#include <boost/iostreams/traits.hpp> // is_filter.
#include <boost/iostreams/stream_buffer.hpp>
#include <boost/next_prior.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
# include <boost/mpl/int.hpp>
#endif
// Sometimes type_info objects must be compared by name. Borrowed from
// Boost.Python and Boost.Function.
#if (defined(__GNUC__) && __GNUC__ >= 3) || \
defined(_AIX) || \
(defined(__sgi) && defined(__host_mips)) || \
(defined(linux) && defined(__INTEL_COMPILER) && defined(__ICC)) \
/**/
# include <cstring>
# define BOOST_IOSTREAMS_COMPARE_TYPE_ID(X,Y) \
(std::strcmp((X).name(),(Y).name()) == 0)
#else
# define BOOST_IOSTREAMS_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
#endif
// Deprecated
#define BOOST_IOSTREAMS_COMPONENT_TYPE(chain, index) \
chain.component_type( index ) \
/**/
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
# define BOOST_IOSTREAMS_COMPONENT(chain, index, target) \
chain.component< target >( index ) \
/**/
#else
# define BOOST_IOSTREAMS_COMPONENT(chain, index, target) \
chain.component( index, ::boost::type< target >() ) \
/**/
#endif
namespace boost { namespace iostreams {
//--------------Definition of chain and wchain--------------------------------//
namespace detail {
template<typename Chain> class chain_client;
//
// Concept name: Chain.
// Description: Represents a chain of stream buffers which provides access
// to the first buffer in the chain and send notifications when the
// streambufs are added to or removed from chain.
// Refines: Closable device with mode equal to typename Chain::mode.
// Models: chain, converting_chain.
// Example:
//
// class chain {
// public:
// typedef xxx chain_type;
// typedef xxx client_type;
// typedef xxx mode;
// bool is_complete() const; // Ready for i/o.
// template<typename T>
// void push( const T& t, // Adds a stream buffer to
// streamsize, // chain, based on t, with
// streamsize ); // given buffer and putback
// // buffer sizes. Pass -1 to
// // request default size.
// protected:
// void register_client(client_type* client); // Associate client.
// void notify(); // Notify client.
// };
//
//
// Description: Represents a chain of filters with an optional device at the
// end.
// Template parameters:
// Self - A class deriving from the current instantiation of this template.
// This is an example of the Curiously Recurring Template Pattern.
// Ch - The character type.
// Tr - The character traits type.
// Alloc - The allocator type.
// Mode - A mode tag.
//
template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
class chain_base {
public:
typedef Ch char_type;
BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)
typedef Alloc allocator_type;
typedef Mode mode;
struct category
: Mode,
device_tag
{ };
typedef chain_client<Self> client_type;
friend class chain_client<Self>;
private:
typedef linked_streambuf<Ch> streambuf_type;
typedef std::list<streambuf_type*> list_type;
typedef chain_base<Self, Ch, Tr, Alloc, Mode> my_type;
protected:
chain_base() : pimpl_(new chain_impl) { }
chain_base(const chain_base& rhs): pimpl_(rhs.pimpl_) { }
public:
//----------Buffer sizing-------------------------------------------------//
// Sets the size of the buffer created for the devices to be added to this
// chain. Does not affect the size of the buffer for devices already
// added.
void set_device_buffer_size(int n) { pimpl_->device_buffer_size_ = n; }
// Sets the size of the buffer created for the filters to be added
// to this chain. Does not affect the size of the buffer for filters already
// added.
void set_filter_buffer_size(int n) { pimpl_->filter_buffer_size_ = n; }
// Sets the size of the putback buffer for filters and devices to be added
// to this chain. Does not affect the size of the buffer for filters or
// devices already added.
void set_pback_size(int n) { pimpl_->pback_size_ = n; }
//----------Device interface----------------------------------------------//
std::streamsize read(char_type* s, std::streamsize n);
std::streamsize write(const char_type* s, std::streamsize n);
std::streampos seek(stream_offset off, BOOST_IOS::seekdir way);
//----------Additional i/o functions--------------------------------------//
// Returns true if this chain is non-empty and its final link
// is a source or sink, i.e., if it is ready to perform i/o.
bool is_complete() const;
bool auto_close() const;
void set_auto_close(bool close);
bool sync() { return front().BOOST_IOSTREAMS_PUBSYNC() != -1; }
bool strict_sync();
//----------Container-like interface--------------------------------------//
typedef typename list_type::size_type size_type;
streambuf_type& front() { return *list().front(); }
BOOST_IOSTREAMS_DEFINE_PUSH(push, mode, char_type, push_impl)
void pop();
bool empty() const { return list().empty(); }
size_type size() const { return list().size(); }
void reset();
//----------Direct component access---------------------------------------//
const std::type_info& component_type(int n) const
{
if (static_cast<size_type>(n) >= size())
throw std::out_of_range("bad chain offset");
return (*boost::next(list().begin(), n))->component_type();
}
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
// Deprecated.
template<int N>
const std::type_info& component_type() const { return component_type(N); }
template<typename T>
T* component(int n) const { return component(n, boost::type<T>()); }
// Deprecated.
template<int N, typename T>
T* component() const { return component<T>(N); }
#endif
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
private:
#endif
template<typename T>
T* component(int n, boost::type<T>) const
{
if (static_cast<size_type>(n) >= size())
throw std::out_of_range("bad chain offset");
streambuf_type* link = *boost::next(list().begin(), n);
if (BOOST_IOSTREAMS_COMPARE_TYPE_ID(link->component_type(), typeid(T)))
return static_cast<T*>(link->component_impl());
else
return 0;
}
private:
template<typename T>
void push_impl(const T& t, int buffer_size = -1, int pback_size = -1)
{
typedef typename iostreams::category_of<T>::type category;
typedef typename unwrap_ios<T>::type policy_type;
typedef stream_buffer<
policy_type,
BOOST_IOSTREAMS_CHAR_TRAITS(char_type),
Alloc, Mode
> facade_type;
BOOST_STATIC_ASSERT((is_convertible<category, Mode>::value));
if (is_complete())
throw std::logic_error("chain complete");
streambuf_type* prev = !empty() ? list().back() : 0;
buffer_size =
buffer_size != -1 ?
buffer_size :
iostreams::optimal_buffer_size(t);
pback_size =
pback_size != -1 ?
pback_size :
pimpl_->pback_size_;
std::auto_ptr<facade_type>
buf(new facade_type(t, buffer_size, pback_size));
list().push_back(buf.get());
buf.release();
if (is_device<policy_type>::value)
pimpl_->flags_ |= f_complete | f_open;
if (prev) prev->set_next(list().back());
notify();
}
list_type& list() { return pimpl_->links_; }
const list_type& list() const { return pimpl_->links_; }
void register_client(client_type* client) { pimpl_->client_ = client; }
void notify() { if (pimpl_->client_) pimpl_->client_->notify(); }
//----------Nested classes------------------------------------------------//
static void close(streambuf_type* b, BOOST_IOS::openmode m)
{
if (m & BOOST_IOS::out)
b->BOOST_IOSTREAMS_PUBSYNC();
b->close(m);
}
static void set_next(streambuf_type* b, streambuf_type* next)
{ b->set_next(next); }
static void set_auto_close(streambuf_type* b, bool close)
{ b->set_auto_close(close); }
struct closer : public std::unary_function<streambuf_type*, void> {
closer(BOOST_IOS::openmode m) : mode_(m) { }
void operator() (streambuf_type* b)
{
close(b, mode_);
}
BOOST_IOS::openmode mode_;
};
friend struct closer;
enum flags {
f_complete = 1,
f_open = 2,
f_auto_close = 4
};
struct chain_impl {
chain_impl()
: client_(0), device_buffer_size_(default_device_buffer_size),
filter_buffer_size_(default_filter_buffer_size),
pback_size_(default_pback_buffer_size),
flags_(f_auto_close)
{ }
~chain_impl() { try { close(); reset(); } catch (std::exception&) { } }
void close()
{
if ((flags_ & f_open) != 0) {
stream_buffer< basic_null_device<Ch, Mode> > null;
if ((flags_ & f_complete) == 0) {
null.open(basic_null_device<Ch, Mode>());
set_next(links_.back(), &null);
}
links_.front()->BOOST_IOSTREAMS_PUBSYNC();
if (is_convertible<Mode, input>::value)
std::for_each( links_.rbegin(), links_.rend(),
closer(BOOST_IOS::in) );
if (is_convertible<Mode, output>::value)
std::for_each( links_.begin(), links_.end(),
closer(BOOST_IOS::out) );
flags_ &= ~f_open;
}
}
void reset()
{
typedef typename list_type::iterator iterator;
for ( iterator first = links_.begin(),
last = links_.end();
first != last;
++first )
{
if ( (flags_ & f_complete) == 0 ||
(flags_ & f_auto_close) == 0 )
{
set_auto_close(*first, false);
}
streambuf_type* buf = 0;
std::swap(buf, *first);
delete buf;
}
links_.clear();
flags_ &= ~f_complete;
flags_ &= ~f_open;
}
list_type links_;
client_type* client_;
int device_buffer_size_,
filter_buffer_size_,
pback_size_;
int flags_;
};
friend struct chain_impl;
//----------Member data---------------------------------------------------//
private:
shared_ptr<chain_impl> pimpl_;
};
} // End namespace detail.
//
// Macro: BOOST_IOSTREAMS_DECL_CHAIN(name, category)
// Description: Defines a template derived from chain_base appropriate for a
// particular i/o category. The template has the following parameters:
// Ch - The character type.
// Tr - The character traits type.
// Alloc - The allocator type.
// Macro parameters:
// name_ - The name of the template to be defined.
// category_ - The i/o category of the template to be defined.
//
#define BOOST_IOSTREAMS_DECL_CHAIN(name_, default_char_) \
template< typename Mode, typename Ch = default_char_, \
typename Tr = BOOST_IOSTREAMS_CHAR_TRAITS(Ch), \
typename Alloc = std::allocator<Ch> > \
class name_ : public boost::iostreams::detail::chain_base< \
name_<Mode, Ch, Tr, Alloc>, \
Ch, Tr, Alloc, Mode \
> \
{ \
public: \
struct category : device_tag, Mode { }; \
typedef Mode mode; \
private: \
typedef boost::iostreams::detail::chain_base< \
name_<Mode, Ch, Tr, Alloc>, \
Ch, Tr, Alloc, Mode \
> base_type; \
public: \
typedef Ch char_type; \
typedef Tr traits_type; \
typedef typename traits_type::int_type int_type; \
typedef typename traits_type::off_type off_type; \
name_() { } \
name_(const name_& rhs) { *this = rhs; } \
name_& operator=(const name_& rhs) \
{ base_type::operator=(rhs); return *this; } \
}; \
/**/
BOOST_IOSTREAMS_DECL_CHAIN(chain, char)
BOOST_IOSTREAMS_DECL_CHAIN(wchain, wchar_t)
#undef BOOST_IOSTREAMS_DECL_CHAIN
//--------------Definition of chain_client------------------------------------//
namespace detail {
//
// Template name: chain_client
// Description: Class whose instances provide access to an underlying chain
// using an interface similar to the chains.
// Subclasses: the various stream and stream buffer templates.
//
template<typename Chain>
class chain_client {
public:
typedef Chain chain_type;
typedef typename chain_type::char_type char_type;
typedef typename chain_type::traits_type traits_type;
typedef typename chain_type::size_type size_type;
typedef typename chain_type::mode mode;
chain_client(chain_type* chn = 0) : chain_(chn ) { }
chain_client(chain_client* client) : chain_(client->chain_) { }
virtual ~chain_client() { }
const std::type_info& component_type(int n) const
{ return chain_->component_type(n); }
//#if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
// // Deprecated.
// template<int N>
// const std::type_info& component_type() const
// { return chain_->component_type(N); }
//
// template<typename T>
// T* component(int n) const // Tru64 needs boost::type.
// { return chain_->component(n, boost::type<T>()); }
//
// // Deprecated.
// template<int N, typename T>
// T* component() const // Tru64 needs boost::type.
// { return chain_->component(N, boost::type<T>()); }
//#else
// template<typename T>
// T* component(int n, boost::type<T> t) const
// { return chain_->component(n, t); }
//#endif
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
// Deprecated.
template<int N>
const std::type_info& component_type() const
{ return chain_->BOOST_NESTED_TEMPLATE component_type<N>(); }
template<typename T>
T* component(int n) const
{ return chain_->BOOST_NESTED_TEMPLATE component<T>(n); }
// Deprecated.
template<int N, typename T>
T* component() const
{ return chain_->BOOST_NESTED_TEMPLATE component<N, T>(); }
#else
template<typename T>
T* component(int n, boost::type<T> t) const
{ return chain_->component(n, t); }
#endif
bool is_complete() const { return chain_->is_complete(); }
bool auto_close() const { return chain_->auto_close(); }
void set_auto_close(bool close) { chain_->set_auto_close(close); }
bool strict_sync() { return chain_->strict_sync(); }
void set_device_buffer_size(std::streamsize n)
{ chain_->set_device_buffer_size(n); }
void set_filter_buffer_size(std::streamsize n)
{ chain_->set_filter_buffer_size(n); }
void set_pback_size(std::streamsize n) { chain_->set_pback_size(n); }
BOOST_IOSTREAMS_DEFINE_PUSH(push, mode, char_type, push_impl)
void pop() { chain_->pop(); }
bool empty() const { return chain_->empty(); }
size_type size() { return chain_->size(); }
void reset() { chain_->reset(); }
// Returns a copy of the underlying chain.
chain_type filters() { return *chain_; }
chain_type filters() const { return *chain_; }
protected:
template<typename T>
void push_impl(const T& t BOOST_IOSTREAMS_PUSH_PARAMS())
{ chain_->push(t BOOST_IOSTREAMS_PUSH_ARGS()); }
chain_type& ref() { return *chain_; }
void set_chain(chain_type* c)
{ chain_ = c; chain_->register_client(this); }
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && \
(!BOOST_WORKAROUND(__BORLANDC__, < 0x600))
template<typename S, typename C, typename T, typename A, typename M>
friend class chain_base;
#else
public:
#endif
virtual void notify() { }
private:
chain_type* chain_;
};
//--------------Implementation of chain_base----------------------------------//
template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
inline std::streamsize chain_base<Self, Ch, Tr, Alloc, Mode>::read
(char_type* s, std::streamsize n)
{ return iostreams::read(*list().front(), s, n); }
template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
inline std::streamsize chain_base<Self, Ch, Tr, Alloc, Mode>::write
(const char_type* s, std::streamsize n)
{ return iostreams::write(*list().front(), s, n); }
template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
inline std::streampos chain_base<Self, Ch, Tr, Alloc, Mode>::seek
(stream_offset off, BOOST_IOS::seekdir way)
{ return iostreams::seek(*list().front(), off, way); }
template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
void chain_base<Self, Ch, Tr, Alloc, Mode>::reset()
{
using namespace std;
pimpl_->close();
pimpl_->reset();
}
template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
bool chain_base<Self, Ch, Tr, Alloc, Mode>::is_complete() const
{
return (pimpl_->flags_ & f_complete) != 0;
}
template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
bool chain_base<Self, Ch, Tr, Alloc, Mode>::auto_close() const
{
return (pimpl_->flags_ & f_auto_close) != 0;
}
template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
void chain_base<Self, Ch, Tr, Alloc, Mode>::set_auto_close(bool close)
{
pimpl_->flags_ =
(pimpl_->flags_ & ~f_auto_close) |
(close ? f_auto_close : 0);
}
template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
bool chain_base<Self, Ch, Tr, Alloc, Mode>::strict_sync()
{
typedef typename list_type::iterator iterator;
bool result = true;
for ( iterator first = list().begin(),
last = list().end();
first != last;
++first )
{
bool s = (*first)->strict_sync();
result = result && s;
}
return result;
}
template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
void chain_base<Self, Ch, Tr, Alloc, Mode>::pop()
{
assert(!empty());
if (auto_close())
pimpl_->close();
streambuf_type* buf = 0;
std::swap(buf, list().back());
buf->set_auto_close(false);
buf->set_next(0);
delete buf;
list().pop_back();
pimpl_->flags_ &= ~f_complete;
if (auto_close() || list().empty())
pimpl_->flags_ &= ~f_open;
}
} // End namespace detail.
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CHAIN_HPP_INCLUDED

70
boost/boost/iostreams/char_traits.hpp Normal file
View File

@ -0,0 +1,70 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_CHAR_TRAITS_HPP_INCLUDED
#define BOOST_IOSTREAMS_CHAR_TRAITS_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp>
#include <cstddef>
#include <cstdio> // EOF.
#include <string> // std::char_traits.
#include <boost/iostreams/detail/char_traits.hpp>
#include <boost/iostreams/detail/config/wide_streams.hpp>
#ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS
# include <cwchar>
#endif
#ifdef BOOST_NO_STDC_NAMESPACE
namespace std { using ::wint_t; }
#endif
namespace boost { namespace iostreams {
// Dinkumware that comes with QNX Momentics 6.3.0, 4.0.2, incorrectly defines the
// EOF and WEOF macros to not std:: qualify the wint_t type.
// Fix by placing the def in this scope.
#if defined(__QNX__) && defined(BOOST_DINKUMWARE_STDLIB)
using ::std::wint_t;
#endif
const int WOULD_BLOCK = (int) (EOF - 1);
#ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS
const std::wint_t WWOULD_BLOCK = (std::wint_t) (WEOF - 1);
#endif
template<typename Ch>
struct char_traits;
template<>
struct char_traits<char> : BOOST_IOSTREAMS_CHAR_TRAITS(char) {
static char newline() { return '\n'; }
static int good() { return '\n'; }
static int would_block() { return WOULD_BLOCK; }
static bool is_good(int c) { return c != EOF && c != WOULD_BLOCK; }
static bool is_eof(int c) { return c == EOF; }
static bool would_block(int c) { return c == WOULD_BLOCK; }
};
#ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS
template<>
struct char_traits<wchar_t> : std::char_traits<wchar_t> {
static wchar_t newline() { return L'\n'; }
static std::wint_t good() { return L'\n'; }
static std::wint_t would_block() { return WWOULD_BLOCK; }
static bool is_good(std::wint_t c) { return c != WEOF && c != WWOULD_BLOCK; }
static bool is_eof(std::wint_t c) { return c == WEOF; }
static bool would_block(std::wint_t c) { return c == WWOULD_BLOCK; }
};
#endif
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_CHAR_TRAITS_HPP_INCLUDED

150
boost/boost/iostreams/checked_operations.hpp Normal file
View File

@ -0,0 +1,150 @@
// (C) Copyright Jonathan Turkanis 2005.
// 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.
// Contains implementations of get, read, put, write and seek which
// check a device's mode at runtime instead of compile time.
#ifndef BOOST_IOSTREAMS_DETAIL_CHECKED_OPERATIONS_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_CHECKED_OPERATIONS_HPP_INCLUDED
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/detail/dispatch.hpp>
#include <boost/iostreams/detail/error.hpp>
#include <boost/iostreams/get.hpp>
#include <boost/iostreams/put.hpp>
#include <boost/iostreams/read.hpp>
#include <boost/iostreams/seek.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/iostreams/write.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC.
namespace boost { namespace iostreams {
namespace detail {
template<typename T>
struct read_write_if_impl;
template<typename T>
struct seek_if_impl;
} // End namespace detail.
template<typename T>
typename int_type_of<T>::type get_if(T& t)
{
typedef typename detail::dispatch<T, input, output>::type tag;
return detail::read_write_if_impl<tag>::get(t);
}
template<typename T>
inline std::streamsize
read_if(T& t, typename char_type_of<T>::type* s, std::streamsize n)
{
typedef typename detail::dispatch<T, input, output>::type tag;
return detail::read_write_if_impl<tag>::read(t, s, n);
}
template<typename T>
bool put_if(T& t, typename char_type_of<T>::type c)
{
typedef typename detail::dispatch<T, output, input>::type tag;
return detail::read_write_if_impl<tag>::put(t, c);
}
template<typename T>
inline std::streamsize write_if
(T& t, const typename char_type_of<T>::type* s, std::streamsize n)
{
typedef typename detail::dispatch<T, output, input>::type tag;
return detail::read_write_if_impl<tag>::write(t, s, n);
}
template<typename T>
inline std::streampos
seek_if( T& t, stream_offset off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out )
{
using namespace detail;
typedef typename dispatch<T, random_access, any_tag>::type tag;
return seek_if_impl<tag>::seek(t, off, way, which);
}
namespace detail {
//------------------Specializations of read_write_if_impl---------------------//
template<>
struct read_write_if_impl<input> {
template<typename T>
static typename int_type_of<T>::type get(T& t)
{ return iostreams::get(t); }
template<typename T>
static std::streamsize
read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
{ return iostreams::read(t, s, n); }
template<typename T>
static bool put(T&, typename char_type_of<T>::type)
{ throw cant_write(); }
template<typename T>
static std::streamsize
write(T&, const typename char_type_of<T>::type*, std::streamsize)
{ throw cant_write(); }
};
template<>
struct read_write_if_impl<output> {
template<typename T>
static typename int_type_of<T>::type get(T&)
{ throw cant_read(); }
template<typename T>
static std::streamsize
read(T&, typename char_type_of<T>::type*, std::streamsize)
{ throw cant_read(); }
template<typename T>
static bool put(T& t, typename char_type_of<T>::type c)
{ return iostreams::put(t, c); }
template<typename T>
static std::streamsize
write( T& t, const typename char_type_of<T>::type* s,
std::streamsize n )
{ return iostreams::write(t, s, n); }
};
//------------------Specializations of seek_if_impl---------------------------//
template<>
struct seek_if_impl<random_access> {
template<typename T>
static std::streampos
seek( T& t, stream_offset off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which )
{ return iostreams::seek(t, off, way, which); }
};
template<>
struct seek_if_impl<any_tag> {
template<typename T>
static std::streampos
seek(T&, stream_offset, BOOST_IOS::seekdir, BOOST_IOS::openmode)
{ throw cant_seek(); }
};
} // End namespace detail.
} } // End namespaces iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CHECKED_OPERATIONS_HPP_INCLUDED

145
boost/boost/iostreams/close.hpp Normal file
View File

@ -0,0 +1,145 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_CLOSE_HPP_INCLUDED
#define BOOST_IOSTREAMS_CLOSE_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // DEDUCED_TYPENAME, MSVC.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/flush.hpp>
#include <boost/iostreams/detail/adapter/non_blocking_adapter.hpp>
#include <boost/iostreams/detail/wrap_unwrap.hpp>
#include <boost/iostreams/operations_fwd.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_convertible.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) //-----------------------------------//
# include <boost/iostreams/detail/vc6/close.hpp>
#else // #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) //--------------------------//
namespace boost { namespace iostreams {
namespace detail {
template<typename T>
struct close_impl;
} // End namespace detail.
template<typename T>
void close(T& t, BOOST_IOS::openmode which)
{ detail::close_impl<T>::close(detail::unwrap(t), which); }
template<typename T, typename Sink>
void close(T& t, Sink& snk, BOOST_IOS::openmode which)
{ detail::close_impl<T>::close(detail::unwrap(t), snk, which); }
namespace detail {
//------------------Definition of close_impl----------------------------------//
template<typename T>
struct close_tag {
typedef typename category_of<T>::type category;
typedef typename
mpl::eval_if<
is_convertible<category, closable_tag>,
mpl::if_<
mpl::or_<
is_convertible<category, two_sequence>,
is_convertible<category, dual_use>
>,
two_sequence,
closable_tag
>,
mpl::identity<any_tag>
>::type type;
};
template<typename T>
struct close_impl
: mpl::if_<
is_custom<T>,
operations<T>,
close_impl<BOOST_DEDUCED_TYPENAME close_tag<T>::type>
>::type
{ };
template<>
struct close_impl<any_tag> {
template<typename T>
static void close(T& t, BOOST_IOS::openmode which)
{
if ((which & BOOST_IOS::out) != 0)
iostreams::flush(t);
}
template<typename T, typename Sink>
static void close(T& t, Sink& snk, BOOST_IOS::openmode which)
{
if ((which & BOOST_IOS::out) != 0) {
non_blocking_adapter<Sink> nb(snk);
iostreams::flush(t, nb);
}
}
};
#include <boost/iostreams/detail/config/disable_warnings.hpp> // Borland.
template<>
struct close_impl<closable_tag> {
template<typename T>
static void close(T& t, BOOST_IOS::openmode which)
{
typedef typename category_of<T>::type category;
const bool in = is_convertible<category, input>::value &&
!is_convertible<category, output>::value;
if (in == ((which & BOOST_IOS::in) != 0))
t.close();
}
template<typename T, typename Sink>
static void close(T& t, Sink& snk, BOOST_IOS::openmode which)
{
typedef typename category_of<T>::type category;
const bool in = is_convertible<category, input>::value &&
!is_convertible<category, output>::value;
if (in == ((which & BOOST_IOS::in) != 0)) {
non_blocking_adapter<Sink> nb(snk);
t.close(nb);
}
}
};
template<>
struct close_impl<two_sequence> {
template<typename T>
static void close(T& t, BOOST_IOS::openmode which) { t.close(which); }
template<typename T, typename Sink>
static void close(T& t, Sink& snk, BOOST_IOS::openmode which)
{
non_blocking_adapter<Sink> nb(snk);
t.close(nb, which);
}
};
} // End namespace detail.
} } // End namespaces iostreams, boost.
#endif // #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) //-------------------------//
#include <boost/iostreams/detail/config/enable_warnings.hpp>
#endif // #ifndef BOOST_IOSTREAMS_CLOSE_HPP_INCLUDED

128
boost/boost/iostreams/concepts.hpp Normal file
View File

@ -0,0 +1,128 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_CONCEPTS_HPP_INCLUDED
#define BOOST_IOSTREAMS_CONCEPTS_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // BOOST_MSVC
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/detail/default_arg.hpp>
#include <boost/iostreams/detail/ios.hpp> // openmode.
#include <boost/iostreams/positioning.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_convertible.hpp>
namespace boost { namespace iostreams {
//--------------Definitions of helper templates for device concepts-----------//
template<typename Mode, typename Ch = BOOST_IOSTREAMS_DEFAULT_ARG(char)>
struct device {
typedef Ch char_type;
struct category
: Mode,
device_tag,
closable_tag,
localizable_tag
{ };
void close()
{
using namespace detail;
BOOST_STATIC_ASSERT((!is_convertible<Mode, two_sequence>::value));
}
void close(BOOST_IOS::openmode)
{
using namespace detail;
BOOST_STATIC_ASSERT((is_convertible<Mode, two_sequence>::value));
}
template<typename Locale>
void imbue(const Locale&) { }
};
template<typename Mode, typename Ch = BOOST_IOSTREAMS_DEFAULT_ARG(wchar_t)>
struct wdevice : device<Mode, Ch> { };
typedef device<input> source;
typedef wdevice<input> wsource;
typedef device<output> sink;
typedef wdevice<output> wsink;
//--------------Definitions of helper templates for simple filter concepts----//
template<typename Mode, typename Ch = BOOST_IOSTREAMS_DEFAULT_ARG(char)>
struct filter {
typedef Ch char_type;
struct category
: Mode,
filter_tag,
closable_tag,
localizable_tag
{ };
template<typename Device>
void close(Device&)
{
using namespace detail;
BOOST_STATIC_ASSERT((!is_convertible<Mode, two_sequence>::value));
BOOST_STATIC_ASSERT((!is_convertible<Mode, dual_use>::value));
}
template<typename Device>
void close(Device&, BOOST_IOS::openmode)
{
using namespace detail;
BOOST_STATIC_ASSERT(
(is_convertible<Mode, two_sequence>::value) ||
(is_convertible<Mode, dual_use>::value)
);
}
template<typename Locale>
void imbue(const Locale&) { }
};
template<typename Mode, typename Ch = BOOST_IOSTREAMS_DEFAULT_ARG(wchar_t)>
struct wfilter : filter<Mode, Ch> { };
typedef filter<input> input_filter;
typedef wfilter<input> input_wfilter;
typedef filter<output> output_filter;
typedef wfilter<output> output_wfilter;
typedef filter<seekable> seekable_filter;
typedef wfilter<seekable> seekable_wfilter;
typedef filter<dual_use> dual_use_filter;
typedef wfilter<dual_use> dual_use_wfilter;
//------Definitions of helper templates for multi-character filter cncepts----//
template<typename Mode, typename Ch = char>
struct multichar_filter : filter<Mode, Ch> {
struct category : filter<Mode, Ch>::category, multichar_tag { };
};
template<typename Mode, typename Ch = wchar_t>
struct multichar_wfilter : multichar_filter<Mode, Ch> { };
typedef multichar_filter<input> multichar_input_filter;
typedef multichar_filter<input> multichar_input_wfilter;
typedef multichar_filter<output> multichar_output_filter;
typedef multichar_filter<output> multichar_output_wfilter;
typedef multichar_filter<dual_use> multichar_dual_use_filter;
typedef multichar_filter<dual_use> multichar_dual_use_wfilter;
//----------------------------------------------------------------------------//
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_CONCEPTS_HPP_INCLUDED

41
boost/boost/iostreams/constants.hpp Normal file
View File

@ -0,0 +1,41 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Contains constants used by library.
#ifndef BOOST_IOSTREAMS_CONSTANTS_HPP_INCLUDED
#define BOOST_IOSTREAMS_CONSTANTS_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#ifndef BOOST_IOSTREAMS_DEFAULT_DEVICE_BUFFER_SIZE
# define BOOST_IOSTREAMS_DEFAULT_DEVICE_BUFFER_SIZE 4096
#endif
#ifndef BOOST_IOSTREAMS_DEFAULT_FILTER_BUFFER_SIZE
# define BOOST_IOSTREAMS_DEFAULT_FILTER_BUFFER_SIZE 128
#endif
#ifndef BOOST_IOSTREAMS_DEFAULT_PBACK_BUFFER_SIZE
# define BOOST_IOSTREAMS_DEFAULT_PBACK_BUFFER_SIZE 4
#endif
#include <boost/iostreams/detail/ios.hpp> // streamsize.
namespace boost { namespace iostreams {
const std::streamsize default_device_buffer_size =
BOOST_IOSTREAMS_DEFAULT_DEVICE_BUFFER_SIZE;
const std::streamsize default_filter_buffer_size =
BOOST_IOSTREAMS_DEFAULT_FILTER_BUFFER_SIZE;
const std::streamsize default_pback_buffer_size =
BOOST_IOSTREAMS_DEFAULT_PBACK_BUFFER_SIZE;
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_CONSTANTS_HPP_INCLUDED

86
boost/boost/iostreams/detail/access_control.hpp Normal file
View File

@ -0,0 +1,86 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Contains the definition of the class template access_control, which
// allows the type of inheritance from a provided base class to be specified
// using a template parameter.
#ifndef BOOST_IOSTREAMS_ACCESS_CONTROL_HPP_INCLUDED
#define BOOST_IOSTREAMS_ACCESS_CONTROL_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/iostreams/detail/select.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/type_traits/is_same.hpp>
namespace boost { namespace iostreams {
struct protected_ { }; // Represents protected inheritance.
struct public_ { }; // Represents public inheritance.
namespace detail {
// Implements protected inheritance.
template<typename U>
struct prot_ : protected U
{
prot_() { }
template<typename V> prot_(V v) : U(v) { }
};
// Implements public inheritance.
template<typename U> struct pub_ : public U {
pub_() { }
template<typename V> pub_(V v) : U(v) { }
};
//
// Used to deduce the base type for the template access_control.
//
template<typename T, typename Access>
struct access_control_base {
typedef int bad_access_specifier;
typedef typename
iostreams::select< // Disambiguation for Tru64
::boost::is_same<
Access, protected_
>, prot_<T>,
::boost::is_same<
Access, public_
>, pub_<T>,
else_, bad_access_specifier
>::type type;
};
} // End namespace detail.
//
// Template name: access_control.
// Description: Allows the type of inheritance from a provided base class
// to be specified using an int template parameter.
// Template parameters:
// Base - The class from which to inherit (indirectly.)
// Access - The type of access desired. Must be one of the
// values access_base::prot or access_base::pub.
//
template< typename T, typename Access,
typename Base = // VC6 workaraound (Compiler Error C2516)
typename detail::access_control_base<T, Access>::type >
struct access_control : public Base {
access_control() { }
template<typename U> explicit access_control(U u) : Base(u) { }
};
//----------------------------------------------------------------------------//
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_ACCESS_CONTROL_HPP_INCLUDED

276
boost/boost/iostreams/detail/adapter/concept_adapter.hpp Normal file
View File

@ -0,0 +1,276 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_CONCEPT_ADAPTER_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_CONCEPT_ADAPTER_HPP_INCLUDED
#include <boost/config.hpp> // SFINAE.
#include <boost/iostreams/concepts.hpp>
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/detail/adapter/non_blocking_adapter.hpp>
#include <boost/iostreams/detail/call_traits.hpp>
#include <boost/iostreams/detail/char_traits.hpp>
#include <boost/iostreams/detail/dispatch.hpp>
#include <boost/iostreams/detail/error.hpp>
#include <boost/iostreams/detail/streambuf.hpp> // pubsync.
#include <boost/iostreams/device/null.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/iostreams/operations.hpp>
#include <boost/mpl/if.hpp>
#include <boost/static_assert.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC.
namespace boost { namespace iostreams { namespace detail {
template<typename Category> struct device_wrapper_impl;
template<typename Category> struct flt_wrapper_impl;
template<typename T>
class concept_adapter {
private:
typedef typename detail::value_type<T>::type value_type;
typedef typename dispatch<T, input, output>::type input_tag;
typedef typename dispatch<T, output, input>::type output_tag;
typedef typename
mpl::if_<
is_device<T>,
device_wrapper_impl<input_tag>,
flt_wrapper_impl<input_tag>
>::type input_impl;
typedef typename
mpl::if_<
is_device<T>,
device_wrapper_impl<output_tag>,
flt_wrapper_impl<output_tag>
>::type output_impl;
typedef typename
mpl::if_<
is_device<T>,
device_wrapper_impl<any_tag>,
flt_wrapper_impl<any_tag>
>::type any_impl;
public:
typedef typename char_type_of<T>::type char_type;
typedef typename category_of<T>::type category;
explicit concept_adapter(const reference_wrapper<T>& ref) : t_(ref.get())
{ BOOST_STATIC_ASSERT(is_std_io<T>::value); }
explicit concept_adapter(const T& t) : t_(t)
{ BOOST_STATIC_ASSERT(!is_std_io<T>::value); }
T& operator*() { return t_; }
T* operator->() { return &t_; }
std::streamsize read(char_type* s, std::streamsize n)
{ return this->read(s, n, (basic_null_source<char_type>*) 0); }
template<typename Source>
std::streamsize read(char_type* s, std::streamsize n, Source* src)
{ return input_impl::read(t_, src, s, n); }
std::streamsize write(const char_type* s, std::streamsize n)
{ return this->write(s, n, (basic_null_sink<char_type>*) 0); }
template<typename Sink>
std::streamsize write(const char_type* s, std::streamsize n, Sink* snk)
{ return output_impl::write(t_, snk, s, n); }
std::streampos seek( stream_offset off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which )
{
return this->seek( off, way, which,
(basic_null_device<char_type, seekable>*) 0);
}
template<typename Device>
std::streampos seek( stream_offset off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which, Device* dev )
{ return any_impl::seek(t_, dev, off, way, which); }
void close(BOOST_IOS::openmode which)
{ this->close(which, (basic_null_device<char_type, seekable>*) 0); }
template<typename Device>
void close(BOOST_IOS::openmode which, Device* dev)
{ any_impl::close(t_, dev, which); }
bool flush( BOOST_IOSTREAMS_BASIC_STREAMBUF(char_type,
BOOST_IOSTREAMS_CHAR_TRAITS(char_type))* sb )
{
bool result = any_impl::flush(t_, sb);
if (sb && sb->BOOST_IOSTREAMS_PUBSYNC() == -1)
result = false;
return result;
}
template<typename Locale> // Avoid dependency on <locale>
void imbue(const Locale& loc) { iostreams::imbue(t_, loc); }
std::streamsize optimal_buffer_size() const
{ return iostreams::optimal_buffer_size(t_); }
public:
value_type t_;
};
//------------------Specializations of device_wrapper_impl--------------------//
template<>
struct device_wrapper_impl<any_tag> {
template<typename Device, typename Dummy>
static std::streampos
seek( Device& dev, Dummy*, stream_offset off,
BOOST_IOS::seekdir way, BOOST_IOS::openmode which )
{
typedef typename category_of<Device>::type category;
return seek(dev, off, way, which, category());
}
template<typename Device>
static std::streampos
seek( Device&, stream_offset, BOOST_IOS::seekdir,
BOOST_IOS::openmode, any_tag )
{
throw cant_seek();
}
template<typename Device>
static std::streampos
seek( Device& dev, stream_offset off,
BOOST_IOS::seekdir way, BOOST_IOS::openmode which,
random_access )
{
return iostreams::seek(dev, off, way, which);
}
template<typename Device, typename Dummy>
static void close(Device& dev, Dummy*, BOOST_IOS::openmode which)
{ iostreams::close(dev, which); }
template<typename Device, typename Dummy>
static bool flush(Device& dev, Dummy*)
{ return iostreams::flush(dev); }
};
template<>
struct device_wrapper_impl<input> : device_wrapper_impl<any_tag> {
template<typename Device, typename Dummy>
static std::streamsize
read( Device& dev, Dummy*, typename char_type_of<Device>::type* s,
std::streamsize n )
{ return iostreams::read(dev, s, n); }
template<typename Device, typename Dummy>
static std::streamsize
write( Device&, Dummy*, const typename char_type_of<Device>::type*,
std::streamsize )
{ throw cant_write(); }
};
template<>
struct device_wrapper_impl<output> {
template<typename Device, typename Dummy>
static std::streamsize
read(Device&, Dummy*, typename char_type_of<Device>::type*, std::streamsize)
{ throw cant_read(); }
template<typename Device, typename Dummy>
static std::streamsize
write( Device& dev, Dummy*, const typename char_type_of<Device>::type* s,
std::streamsize n )
{ return iostreams::write(dev, s, n); }
};
//------------------Specializations of flt_wrapper_impl--------------------//
template<>
struct flt_wrapper_impl<any_tag> {
template<typename Filter, typename Device>
static std::streampos
seek( Filter& f, Device* dev, stream_offset off,
BOOST_IOS::seekdir way, BOOST_IOS::openmode which )
{
typedef typename category_of<Filter>::type category;
return seek(f, dev, off, way, which, category());
}
template<typename Filter, typename Device>
static std::streampos
seek( Filter&, Device*, stream_offset,
BOOST_IOS::seekdir, BOOST_IOS::openmode, any_tag )
{ throw cant_seek(); }
template<typename Filter, typename Device>
static std::streampos
seek( Filter& f, Device* dev, stream_offset off,
BOOST_IOS::seekdir way, BOOST_IOS::openmode which,
random_access tag )
{
typedef typename category_of<Filter>::type category;
return seek(f, dev, off, way, which, tag, category());
}
template<typename Filter, typename Device>
static std::streampos
seek( Filter& f, Device* dev, stream_offset off,
BOOST_IOS::seekdir way, BOOST_IOS::openmode which,
random_access, any_tag )
{ return f.seek(*dev, off, way); }
template<typename Filter, typename Device>
static std::streampos
seek( Filter& f, Device* dev, stream_offset off,
BOOST_IOS::seekdir way, BOOST_IOS::openmode which,
random_access, two_sequence )
{ return f.seek(*dev, off, way, which); }
template<typename Filter, typename Device>
static void close(Filter& f, Device* dev, BOOST_IOS::openmode which)
{ iostreams::close(f, *dev, which); }
template<typename Filter, typename Device>
static bool flush(Filter& f, Device* dev)
{ return iostreams::flush(f, *dev); }
};
template<>
struct flt_wrapper_impl<input> {
template<typename Filter, typename Source>
static std::streamsize
read( Filter& f, Source* src, typename char_type_of<Filter>::type* s,
std::streamsize n )
{ return iostreams::read(f, *src, s, n); }
template<typename Filter, typename Sink>
static std::streamsize
write( Filter&, Sink*, const typename char_type_of<Filter>::type*,
std::streamsize )
{ throw cant_write(); }
};
template<>
struct flt_wrapper_impl<output> {
template<typename Filter, typename Source>
static std::streamsize
read(Filter&, Source*, typename char_type_of<Filter>::type*,std::streamsize)
{ throw cant_read(); }
template<typename Filter, typename Sink>
static std::streamsize
write( Filter& f, Sink* snk, const typename char_type_of<Filter>::type* s,
std::streamsize n )
{ return iostreams::write(f, *snk, s, n); }
};
//----------------------------------------------------------------------------//
} } } // End namespaces detail, iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONCEPT_ADAPTER_HPP_INCLUDED

117
boost/boost/iostreams/detail/adapter/mode_adapter.hpp Normal file
View File

@ -0,0 +1,117 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_MODE_ADAPTER_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_MODE_ADAPTER_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
// Contains the definition of the class template mode_adapter, which allows
// a filter or device to function as if it has a different i/o mode than that
// deduced by the metafunction mode_of.
#include <boost/config.hpp> // BOOST_MSVC.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/detail/ios.hpp> // openmode, seekdir, int types.
#include <boost/iostreams/traits.hpp>
#include <boost/iostreams/operations.hpp>
#include <boost/mpl/if.hpp>
namespace boost { namespace iostreams { namespace detail {
template<typename Mode, typename T>
class mode_adapter {
private:
struct empty_base { };
public:
typedef typename wrapped_type<T>::type policy_type;
typedef typename char_type_of<T>::type char_type;
struct category
: Mode,
device_tag,
mpl::if_<is_filter<T>, filter_tag, device_tag>,
mpl::if_<is_filter<T>, multichar_tag, empty_base>,
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
closable_tag, // VC6 can't see member close()!
#endif
localizable_tag
{ };
explicit mode_adapter(const policy_type& t) : t_(t) { }
// Device member functions.
std::streamsize read(char_type* s, std::streamsize n);
std::streamsize write(const char_type* s, std::streamsize n);
std::streampos seek( stream_offset off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which =
BOOST_IOS::in | BOOST_IOS::out );
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
void close(BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out);
#endif
// Filter member functions.
template<typename Source>
std::streamsize read(Source& src, char_type* s, std::streamsize n)
{ return iostreams::read(t_, src, s, n); }
template<typename Sink>
std::streamsize write(Sink& snk, const char_type* s, std::streamsize n)
{ return iostreams::write(t_, snk, s, n); }
template<typename Device>
std::streampos seek(Device& dev, stream_offset off, BOOST_IOS::seekdir way)
{ return iostreams::seek(t_, dev, off, way); }
template<typename Device>
std::streampos seek( Device& dev, stream_offset off,
BOOST_IOS::seekdir way, BOOST_IOS::openmode which )
{ return iostreams::seek(t_, dev, off, way, which); }
template<typename Device>
void close(Device& dev)
{ iostreams::close(t_, dev); }
template<typename Device>
void close(Device& dev, BOOST_IOS::openmode which)
{ iostreams::close(t_, dev, which); }
template<typename Locale>
void imbue(const Locale& loc)
{ iostreams::imbue(t_, loc); }
private:
policy_type t_;
};
//------------------Implementation of mode_adapter----------------------------//
template<typename Mode, typename T>
std::streamsize mode_adapter<Mode, T>::read
(char_type* s, std::streamsize n)
{ return boost::iostreams::read(t_, s, n); }
template<typename Mode, typename T>
std::streamsize mode_adapter<Mode, T>::write
(const char_type* s, std::streamsize n)
{ return boost::iostreams::write(t_, s, n); }
template<typename Mode, typename T>
std::streampos mode_adapter<Mode, T>::seek
(stream_offset off, BOOST_IOS::seekdir way, BOOST_IOS::openmode which)
{ return boost::iostreams::seek(t_, off, way, which); }
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
template<typename Mode, typename T>
void mode_adapter<Mode, T>::close(BOOST_IOS::openmode which)
{ iostreams::close(t_, which); }
#endif
} } } // End namespaces detail, iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_MODE_ADAPTER_HPP_INCLUDED //-----//

57
boost/boost/iostreams/detail/adapter/non_blocking_adapter.hpp Normal file
View File

@ -0,0 +1,57 @@
// (C) Copyright Jonathan Turkanis 2005.
// 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_NON_BLOCKING_ADAPTER_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_NON_BLOCKING_ADAPTER_HPP_INCLUDED
#include <boost/iostreams/detail/ios.hpp> // streamsize, seekdir, openmode.
#include <boost/iostreams/read.hpp>
#include <boost/iostreams/seek.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/iostreams/write.hpp>
namespace boost { namespace iostreams {
template<typename Device>
class non_blocking_adapter {
public:
typedef typename char_type_of<Device>::type char_type;
struct category
: mode_of<Device>::type, device_tag
{ };
explicit non_blocking_adapter(Device& dev) : device_(dev) { }
std::streamsize read(char_type* s, std::streamsize n)
{
std::streamsize result = 0;
while (result < n) {
std::streamsize amt = iostreams::read(device_, s, n);
if (amt == -1)
break;
result += amt;
}
return result != 0 ? result : -1;
}
std::streamsize write(const char_type* s, std::streamsize n)
{
std::streamsize result = 0;
while (result < n) {
std::streamsize amt =
iostreams::write(device_, s + result, n - result);
result += amt;
}
return result;
}
std::streampos seek( stream_offset off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which =
BOOST_IOS::in | BOOST_IOS::out )
{ return iostreams::seek(device_, off, way, which); }
public:
Device& device_;
};
} } // End namespace iostreams.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_NON_BLOCKING_ADAPTER_HPP_INCLUDED

40
boost/boost/iostreams/detail/adapter/output_iterator_adapter.hpp Normal file
View File

@ -0,0 +1,40 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_OUTPUT_ITERATOR_ADAPTER_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_OUTPUT_ITERATOR_ADAPTER_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <algorithm> // copy.
#include <iosfwd> // streamsize.
#include <boost/iostreams/categories.hpp> // tags.
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_convertible.hpp>
namespace boost { namespace iostreams { namespace detail {
template<typename Mode, typename Ch, typename OutIt>
class output_iterator_adapter {
public:
BOOST_STATIC_ASSERT((is_convertible<Mode, output>::value));
typedef Ch char_type;
typedef sink_tag category;
explicit output_iterator_adapter(OutIt out) : out_(out) { }
std::streamsize write(const char_type* s, std::streamsize n)
{
std::copy(s, s + n, out_);
return n;
}
private:
OutIt out_;
};
} } } // End namespaces detail, iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_OUTPUT_ITERATOR_ADAPTER_HPP_INCLUDED //-----//

182
boost/boost/iostreams/detail/adapter/range_adapter.hpp Normal file
View File

@ -0,0 +1,182 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_RANGE_ADAPTER_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_RANGE_ADAPTER_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <algorithm> // min.
#include <cassert>
#include <cstddef> // ptrdiff_t.
#include <iosfwd> // streamsize, streamoff.
#include <boost/detail/iterator.hpp> // boost::iterator_traits.
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/detail/error.hpp>
#include <boost/iostreams/positioning.hpp>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/utility/enable_if.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC.
namespace boost { namespace iostreams { namespace detail {
// Used for simulated tag dispatch.
template<typename Traversal> struct range_adapter_impl;
//
// Template name: range_adapter
// Description: Device based on an instance of boost::iterator_range.
// Template paramters:
// Mode - A mode tag.
// Range - An instance of iterator_range.
//
template<typename Mode, typename Range>
class range_adapter {
private:
typedef typename Range::iterator iterator;
typedef boost::detail::iterator_traits<iterator> iter_traits;
typedef typename iter_traits::iterator_category iter_cat;
public:
typedef typename Range::value_type char_type;
struct category : Mode, device_tag { };
typedef typename
mpl::if_<
is_convertible<
iter_cat,
std::random_access_iterator_tag
>,
std::random_access_iterator_tag,
std::forward_iterator_tag
>::type tag;
typedef range_adapter_impl<tag> impl;
explicit range_adapter(const Range& rng);
range_adapter(iterator first, iterator last);
std::streamsize read(char_type* s, std::streamsize n);
std::streamsize write(const char_type* s, std::streamsize n);
std::streampos seek(stream_offset off, BOOST_IOS::seekdir way);
private:
iterator first_, cur_, last_;
};
//------------------Implementation of range_adapter---------------------------//
template<typename Mode, typename Range>
range_adapter<Mode, Range>::range_adapter(const Range& rng)
: first_(rng.begin()), cur_(rng.begin()), last_(rng.end()) { }
template<typename Mode, typename Range>
range_adapter<Mode, Range>::range_adapter(iterator first, iterator last)
: first_(first), cur_(first), last_(last) { }
template<typename Mode, typename Range>
inline std::streamsize range_adapter<Mode, Range>::read
(char_type* s, std::streamsize n)
{ return impl::read(cur_, last_, s, n); }
template<typename Mode, typename Range>
inline std::streamsize range_adapter<Mode, Range>::write
(const char_type* s, std::streamsize n)
{ return impl::write(cur_, last_, s, n); }
template<typename Mode, typename Range>
std::streampos range_adapter<Mode, Range>::seek
(stream_offset off, BOOST_IOS::seekdir way)
{
impl::seek(first_, cur_, last_, off, way);
return offset_to_position(cur_ - first_);
}
//------------------Implementation of range_adapter_impl----------------------//
template<>
struct range_adapter_impl<std::forward_iterator_tag> {
template<typename Iter, typename Ch>
static std::streamsize read
(Iter& cur, Iter& last, Ch* s,std::streamsize n)
{
std::streamsize rem = n; // No. of chars remaining.
while (cur != last && rem-- > 0) *s++ = *cur++;
return n - rem != 0 ? n - rem : -1;
}
template<typename Iter, typename Ch>
static std::streamsize write
(Iter& cur, Iter& last, const Ch* s, std::streamsize n)
{
while (cur != last && n-- > 0) *cur++ = *s++;
if (cur == last && n > 0)
throw write_area_exhausted();
return n;
}
};
template<>
struct range_adapter_impl<std::random_access_iterator_tag> {
template<typename Iter, typename Ch>
static std::streamsize read
(Iter& cur, Iter& last, Ch* s,std::streamsize n)
{
std::streamsize result =
(std::min)(static_cast<std::streamsize>(last - cur), n);
if (result)
std::copy(cur, cur + result, s);
cur += result;
return result != 0 ? result : -1;
}
template<typename Iter, typename Ch>
static std::streamsize write
(Iter& cur, Iter& last, const Ch* s, std::streamsize n)
{
std::streamsize count =
(std::min)(static_cast<std::streamsize>(last - cur), n);
std::copy(s, s + count, cur);
cur += count;
if (count < n)
throw write_area_exhausted();
return n;
}
template<typename Iter>
static void seek
( Iter& first, Iter& cur, Iter& last, stream_offset off,
BOOST_IOS::seekdir way )
{
using namespace std;
switch (way) {
case BOOST_IOS::beg:
if (off > last - first || off < 0) bad_seek();
cur = first + off;
break;
case BOOST_IOS::cur:
{
std::ptrdiff_t newoff = cur - first + off;
if (newoff > last - first || newoff < 0) bad_seek();
cur += off;
break;
}
case BOOST_IOS::end:
if (last - first + off < 0 || off > 0) bad_seek();
cur = last + off;
break;
default:
assert(0);
}
}
};
} } } // End namespaces detail, iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_RANGE_ADAPTER_HPP_INCLUDED //---------------//

48
boost/boost/iostreams/detail/bool_trait_def.hpp Normal file
View File

@ -0,0 +1,48 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_BOOL_TRAIT_DEF_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_BOOL_TRAIT_DEF_HPP_INCLUDED
#include <boost/config.hpp> // BOOST_STATIC_CONSTANT.
#include <boost/iostreams/detail/template_params.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/type_traits/detail/yes_no_type.hpp>
//
// Macro name: BOOST_IOSTREAMS_BOOL_TRAIT_DEF
// Description: Used to generate the traits classes is_istream, is_ostream,
// etc.
//
#if BOOST_WORKAROUND(__BORLANDC__, <= 0x564)
# define BOOST_IOSTREAMS_TRAIT_NAMESPACE(trait)
#else
# define BOOST_IOSTREAMS_TRAIT_NAMESPACE(trait) BOOST_PP_CAT(trait, _impl_)::
#endif
#define BOOST_IOSTREAMS_BOOL_TRAIT_DEF(trait, type, arity) \
namespace BOOST_PP_CAT(trait, _impl_) { \
BOOST_IOSTREAMS_TEMPLATE_PARAMS(arity, T) \
type_traits::yes_type helper \
(const volatile type BOOST_IOSTREAMS_TEMPLATE_ARGS(arity, T)*); \
type_traits::no_type helper(...); \
template<typename T> \
struct impl { \
BOOST_STATIC_CONSTANT(bool, value = \
(sizeof(BOOST_IOSTREAMS_TRAIT_NAMESPACE(trait) \
helper(static_cast<T*>(0))) == \
sizeof(type_traits::yes_type))); \
}; \
} \
template<typename T> \
struct trait \
: mpl::bool_<BOOST_PP_CAT(trait, _impl_)::impl<T>::value> \
{ BOOST_MPL_AUX_LAMBDA_SUPPORT(1, trait, (T)) }; \
/**/
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_BOOL_TRAIT_DEF_HPP_INCLUDED

199
boost/boost/iostreams/detail/buffer.hpp Normal file
View File

@ -0,0 +1,199 @@
// (C) Copyright Jonathan Turkanis 2003-5.
// 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) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <algorithm> // swap.
#include <memory> // allocator.
#include <boost/config.hpp> // member templates.
#include <boost/iostreams/char_traits.hpp>
#include <boost/iostreams/detail/ios.hpp> // streamsize.
#include <boost/iostreams/read.hpp>
#include <boost/iostreams/traits.hpp> // int_type_of.
#include <boost/iostreams/checked_operations.hpp>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_same.hpp>
namespace boost { namespace iostreams { namespace detail {
//----------------Buffers-----------------------------------------------------//
//
// Template name: buffer
// Description: Character buffer.
// Template paramters:
// Ch - The character type.
// Alloc - The Allocator type.
//
template< typename Ch,
typename Alloc = std::allocator<Ch> >
class basic_buffer {
private:
#ifndef BOOST_NO_STD_ALLOCATOR
typedef typename Alloc::template rebind<Ch>::other allocator_type;
#else
typedef std::allocator<Ch> allocator_type;
#endif
public:
basic_buffer();
basic_buffer(int buffer_size);
~basic_buffer();
void resize(int 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<typename Ch, typename Alloc>
void swap(basic_buffer<Ch, Alloc>& lhs, basic_buffer<Ch, Alloc>& rhs)
{ lhs.swap(rhs); }
//
// Template name: buffer
// Description: Character buffer with two pointers accessible via ptr() and
// eptr().
// Template paramters:
// Ch - A character type.
//
template< typename Ch,
typename Alloc = std::allocator<Ch> >
class buffer : public basic_buffer<Ch, Alloc> {
private:
typedef basic_buffer<Ch, Alloc> base;
public:
typedef iostreams::char_traits<Ch> traits_type;
using base::resize;
using base::data;
using base::size;
typedef Ch* const const_pointer;
buffer(int 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 Source>
typename int_type_of<Source>::type fill(Source& src)
{
using namespace std;
streamsize keep;
if ((keep = static_cast<streamsize>(eptr_ - ptr_)) > 0)
traits_type::move(this->data(), ptr_, keep);
set(0, keep);
streamsize result =
iostreams::read(src, this->data() + keep, this->size() - keep);
if (result != -1)
this->set(0, keep + result);
//return result == this->size() - keep ?
// traits_type::good() :
// keep == -1 ?
// traits_type::eof() :
// traits_type::would_block();
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<typename Sink>
bool flush(Sink& dest)
{
using namespace std;
streamsize amt = static_cast<std::streamsize>(eptr_ - ptr_);
streamsize result = iostreams::write_if(dest, ptr_, amt);
if (result < amt) {
traits_type::move( this->data(),
ptr_ + result,
amt - result );
}
this->set(0, amt - result);
return result != 0;
}
private:
Ch *ptr_, *eptr_;
};
template<typename Ch, typename Alloc>
void swap(buffer<Ch, Alloc>& lhs, buffer<Ch, Alloc>& rhs)
{ lhs.swap(rhs); }
//--------------Implementation of basic_buffer--------------------------------//
template<typename Ch, typename Alloc>
basic_buffer<Ch, Alloc>::basic_buffer() : buf_(0), size_(0) { }
template<typename Ch, typename Alloc>
basic_buffer<Ch, Alloc>::basic_buffer(int buffer_size)
: buf_(static_cast<Ch*>(allocator_type().allocate(buffer_size, 0))),
size_(buffer_size) // Cast for SunPro 5.3.
{ }
template<typename Ch, typename Alloc>
inline basic_buffer<Ch, Alloc>::~basic_buffer()
{ if (buf_) allocator_type().deallocate(buf_, size_); }
template<typename Ch, typename Alloc>
inline void basic_buffer<Ch, Alloc>::resize(int buffer_size)
{
if (size_ != buffer_size) {
basic_buffer<Ch, Alloc> temp(buffer_size);
std::swap(size_, temp.size_);
std::swap(buf_, temp.buf_);
}
}
template<typename Ch, typename Alloc>
void basic_buffer<Ch, Alloc>::swap(basic_buffer& rhs)
{
std::swap(buf_, rhs.buf_);
std::swap(size_, rhs.size_);
}
//--------------Implementation of buffer--------------------------------------//
template<typename Ch, typename Alloc>
buffer<Ch, Alloc>::buffer(int buffer_size)
: basic_buffer<Ch, Alloc>(buffer_size) { }
template<typename Ch, typename Alloc>
inline void buffer<Ch, Alloc>::set(std::streamsize ptr, std::streamsize end)
{
ptr_ = data() + ptr;
eptr_ = data() + end;
}
template<typename Ch, typename Alloc>
inline void buffer<Ch, Alloc>::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

31
boost/boost/iostreams/detail/call_traits.hpp Normal file
View File

@ -0,0 +1,31 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_VALUE_TYPE_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_VALUE_TYPE_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/iostreams/traits.hpp>
#include <boost/mpl/if.hpp>
namespace boost { namespace iostreams { namespace detail {
template<typename T>
struct param_type {
typedef typename mpl::if_<is_std_io<T>, T&, const T&>::type type;
};
template<typename T>
struct value_type {
typedef typename mpl::if_<is_std_io<T>, T&, T>::type type;
};
} } } // End namespaces detail, iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_VALUE_TYPE_HPP_INCLUDED //-----------//

62
boost/boost/iostreams/detail/char_traits.hpp Normal file
View File

@ -0,0 +1,62 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.)
// Provides std::char_traits for libraries without templated streams. Should not
// be confused with <boost/iostreams/char_traits.hpp>, which defines the
// template boost::iostreams::char_traits.
// See http://www.boost.org/libs/iostreams for documentation.
#ifndef BOOST_IOSTREAMS_DETAIL_CHAR_TRAITS_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_CHAR_TRAITS_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <iosfwd>
#include <boost/iostreams/detail/config/wide_streams.hpp>
#ifdef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
# include <boost/config.hpp> // Make sure size_t is in std.
# include <cstddef>
# include <cstring>
# include <cstdio>
#endif
#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //--------------------------------//
# define BOOST_IOSTREAMS_CHAR_TRAITS(ch) std::char_traits< ch >
#else
# define BOOST_IOSTREAMS_CHAR_TRAITS(ch) boost::iostreams::detail::char_traits
namespace boost { namespace iostreams { namespace detail {
struct char_traits {
typedef char char_type;
typedef int int_type;
typedef std::streampos pos_type;
typedef std::streamoff off_type;
// Note: this may not be not conforming, since it treats chars as unsigned,
// but is only used to test for equality.
static int compare(const char* lhs, const char* rhs, std::size_t n)
{ return std::strncmp(lhs, rhs, n); }
static char* copy(char *dest, const char *src, std::size_t n)
{ return static_cast<char*>(std::memcpy(dest, src, n)); }
static char* move(char *dest, const char *src, std::size_t n)
{ return static_cast<char*>(std::memmove(dest, src, n)); }
static const char* find(const char* s, std::size_t n, const char& c)
{ return (const char*) (const void*) std::memchr(s, c, n); }
static char to_char_type(const int& c) { return c; }
static int to_int_type(const char& c) { return c; }
static bool eq_int_type(const int& lhs, const int& rhs)
{ return lhs == rhs; }
static int eof() { return EOF; }
static int not_eof(const int& c) { return c != EOF ? c : '\n'; }
};
} } } // End namespaces detail, iostreams, boost.
#endif // #ifdef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-----------------------//
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CHAR_TRAITS_HPP_INCLUDED

122
boost/boost/iostreams/detail/closer.hpp Normal file
View File

@ -0,0 +1,122 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_CLOSER_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_CLOSER_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <exception> // exception.
#include <boost/iostreams/detail/ios.hpp> // openmode.
#include <boost/iostreams/operations.hpp> // close
#include <boost/iostreams/traits.hpp> // is_device.
#include <boost/mpl/if.hpp>
namespace boost { namespace iostreams { namespace detail {
template<typename T>
struct closer {
closer(T& t) : t_(&t) { }
~closer() { try { t_->close(); } catch (std::exception&) { } }
T* t_;
};
template<typename Device>
struct external_device_closer {
external_device_closer(Device& dev, BOOST_IOS::openmode which)
: device_(&dev), which_(which),
dummy_(true), nothrow_(dummy_)
{ }
external_device_closer(Device& dev, BOOST_IOS::openmode which, bool& nothrow)
: device_(&dev), which_(which),
dummy_(true), nothrow_(nothrow)
{ }
~external_device_closer()
{
try {
boost::iostreams::close(*device_, which_);
} catch (...) {
if (!nothrow_) {
nothrow_ = true;
throw;
}
}
}
Device* device_;
BOOST_IOS::openmode which_;
bool dummy_;
bool& nothrow_;
};
template<typename Filter, typename Device>
struct external_filter_closer {
external_filter_closer(Filter& flt, Device& dev, BOOST_IOS::openmode which)
: filter_(flt), device_(dev), which_(which),
dummy_(true), nothrow_(dummy_)
{ }
external_filter_closer( Filter& flt, Device& dev,
BOOST_IOS::openmode which, bool& nothrow )
: filter_(flt), device_(dev), which_(which),
dummy_(true), nothrow_(nothrow)
{ }
~external_filter_closer()
{
try {
boost::iostreams::close(filter_, device_, which_);
} catch (...) {
if (!nothrow_) {
nothrow_ = true;
throw;
}
}
}
Filter& filter_;
Device& device_;
BOOST_IOS::openmode which_;
bool dummy_;
bool& nothrow_;
};
template<typename FilterOrDevice, typename DeviceOrDummy = int>
struct external_closer_traits {
typedef typename
mpl::if_<
is_device<FilterOrDevice>,
external_device_closer<FilterOrDevice>,
external_filter_closer<FilterOrDevice, DeviceOrDummy>
>::type type;
};
template<typename FilterOrDevice, typename DeviceOrDummy = int>
struct external_closer
: external_closer_traits<FilterOrDevice, DeviceOrDummy>::type
{
typedef typename
external_closer_traits<
FilterOrDevice, DeviceOrDummy
>::type base_type;
external_closer(FilterOrDevice& dev, BOOST_IOS::openmode which)
: base_type(dev, which)
{ BOOST_STATIC_ASSERT(is_device<FilterOrDevice>::value); };
external_closer( FilterOrDevice& dev, BOOST_IOS::openmode which,
bool& nothrow )
: base_type(dev, which, nothrow)
{ BOOST_STATIC_ASSERT(is_device<FilterOrDevice>::value); };
external_closer( FilterOrDevice& flt, DeviceOrDummy& dev,
BOOST_IOS::openmode which )
: base_type(flt, dev, which)
{ BOOST_STATIC_ASSERT(is_filter<FilterOrDevice>::value); };
external_closer( FilterOrDevice& flt, DeviceOrDummy& dev,
BOOST_IOS::openmode which, bool& nothrow )
: base_type(flt, dev, which, nothrow)
{ BOOST_STATIC_ASSERT(is_filter<FilterOrDevice>::value); };
};
} } } // End namespaces detail, iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CLOSER_HPP_INCLUDED

48
boost/boost/iostreams/detail/config/auto_link.hpp Normal file
View File

@ -0,0 +1,48 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Adapted from <boost/config/auto_link.hpp> and from
// http://www.boost.org/more/separate_compilation.html, by John Maddock.
#ifndef BOOST_IOSTREAMS_DETAIL_AUTO_LINK_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_AUTO_LINK_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#if defined(BOOST_EXTERNAL_LIB_NAME)
# if defined(BOOST_MSVC) \
|| defined(__BORLANDC__) \
|| (defined(__MWERKS__) && defined(_WIN32) && (__MWERKS__ >= 0x3000)) \
|| (defined(__ICL) && defined(_MSC_EXTENSIONS) && (_MSC_VER >= 1200)) \
/**/
# pragma comment(lib, BOOST_EXTERNAL_LIB_NAME)
# endif
# undef BOOST_EXTERNAL_LIB_NAME
#endif
//------------------Enable automatic library variant selection----------------//
#if !defined(BOOST_IOSTREAMS_SOURCE) && \
!defined(BOOST_ALL_NO_LIB) && \
!defined(BOOST_IOSTREAMS_NO_LIB) \
/**/
// Set the name of our library, this will get undef'ed by auto_link.hpp
// once it's done with it.
# define BOOST_LIB_NAME boost_iostreams
// If we're importing code from a dll, then tell auto_link.hpp about it.
# if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_IOSTREAMS_DYN_LINK)
# define BOOST_DYN_LINK
# endif
// And include the header that does the work.
# include <boost/config/auto_link.hpp>
#endif // auto-linking disabled
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_AUTO_LINK_HPP_INCLUDED

47
boost/boost/iostreams/detail/config/bzip2.hpp Normal file
View File

@ -0,0 +1,47 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Adapted from <boost/config/auto_link.hpp> and from
// http://www.boost.org/more/separate_compilation.html, by John Maddock.
#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_BZIP2_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_CONFIG_BZIP2_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#if defined(BOOST_BZIP2_BINARY)
# if defined(BOOST_MSVC) || \
defined(__BORLANDC__) || \
(defined(__MWERKS__) && defined(_WIN32) && (__MWERKS__ >= 0x3000)) || \
(defined(__ICL) && defined(_MSC_EXTENSIONS) && (_MSC_VER >= 1200)) \
/**/
// Specify the name of the .lib file.
# pragma comment(lib, BOOST_STRINGIZE(BOOST_BZIP2_BINARY))
# endif
#else
# if !defined(BOOST_IOSTREAMS_SOURCE) && \
!defined(BOOST_ALL_NO_LIB) && \
!defined(BOOST_IOSTREAMS_NO_LIB) \
/**/
// Set the name of our library, this will get undef'ed by auto_link.hpp
// once it's done with it.
# define BOOST_LIB_NAME boost_bzip2
// If we're importing code from a dll, then tell auto_link.hpp about it.
# if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_IOSTREAMS_DYN_LINK)
# define BOOST_DYN_LINK
# endif
// And include the header that does the work.
# include <boost/config/auto_link.hpp>
# endif
#endif
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_BZIP2_HPP_INCLUDED

76
boost/boost/iostreams/detail/config/codecvt.hpp Normal file
View File

@ -0,0 +1,76 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_CONFIG_CODECVT_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_CONFIG_CODECVT_HPP_INCLUDED
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/detail/config/wide_streams.hpp>
#include <cstddef>
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
//------------------Support for codecvt with user-defined state types---------//
#if defined(__MSL_CPP__) || defined(__LIBCOMO__) || \
BOOST_WORKAROUND(_STLPORT_VERSION, <= 0x450) \
/**/
# define BOOST_IOSTREAMS_NO_PRIMARY_CODECVT_DEFINITION
#endif
#if defined(__GLIBCPP__) || defined(__GLIBCXX__) || \
BOOST_WORKAROUND(_STLPORT_VERSION, > 0x450) \
/**/
# define BOOST_IOSTREAMS_EMPTY_PRIMARY_CODECVT_DEFINITION
#endif
//------------------Check for codecvt ctor taking a reference count-----------//
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205)) || \
BOOST_WORKAROUND(_STLPORT_VERSION, < 0x461) \
/**/
# define BOOST_IOSTREAMS_NO_CODECVT_CTOR_FROM_SIZE_T
#endif
//------------------Normalize codecvt::length---------------------------------//
#if !defined(__MSL_CPP__) && !defined(__LIBCOMO__)
# define BOOST_IOSTREAMS_CODECVT_CV_QUALIFIER const
#else
# define BOOST_IOSTREAMS_CODECVT_CV_QUALIFIER
#endif
//------------------Check for codecvt::max_length-----------------------------//
#if BOOST_WORKAROUND(_STLPORT_VERSION, < 0x461)
# define BOOST_IOSTREAMS_NO_CODECVT_MAX_LENGTH
#endif
//------------------Put mbstate_t and codecvt in std--------------------------//
#ifndef BOOST_IOSTREAMS_NO_LOCALE
# include <locale>
#endif
// From Robert Ramey's version of utf8_codecvt_facet.
namespace std {
#if defined(__LIBCOMO__)
using ::mbstate_t;
#elif defined(BOOST_DINKUMWARE_STDLIB)
using ::mbstate_t;
#elif defined(__SGI_STL_PORT)
#elif defined(BOOST_NO_STDC_NAMESPACE)
using ::codecvt;
using ::mbstate_t;
#endif
} // End namespace std.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_CODECVT_HPP_INCLUDED

21
boost/boost/iostreams/detail/config/disable_warnings.hpp Normal file
View File

@ -0,0 +1,21 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
#include <boost/config.hpp> // BOOST_MSVC.
#include <boost/detail/workaround.hpp> // BOOST_WORKAROUND.
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable:4224) // Parameter previously defined as type.
# pragma warning(disable:4244) // Conversion: possible loss of data.
#else
# if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
# pragma warn -8008 // Condition always true/false.
# pragma warn -8071 // Conversion may lose significant digits.
# pragma warn -8080 // identifier declared but never used.
# endif
#endif

36
boost/boost/iostreams/detail/config/dyn_link.hpp Normal file
View File

@ -0,0 +1,36 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Adapted from http://www.boost.org/more/separate_compilation.html, by
// John Maddock.
#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_DYN_LINK_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_CONFIG_DYN_LINK_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
//------------------Enable dynamic linking on windows-------------------------//
#ifdef BOOST_HAS_DECLSPEC
# if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_IOSTREAMS_DYN_LINK)
# ifdef BOOST_IOSTREAMS_SOURCE
# define BOOST_IOSTREAMS_DECL __declspec(dllexport)
# else
# define BOOST_IOSTREAMS_DECL __declspec(dllimport)
# endif
# endif
#endif
#ifndef BOOST_IOSTREAMS_DECL
# define BOOST_IOSTREAMS_DECL
#endif
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_DYN_LINK_HPP_INCLUDED

15
boost/boost/iostreams/detail/config/enable_warnings.hpp Normal file
View File

@ -0,0 +1,15 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
#if defined(BOOST_MSVC)
# pragma warning(pop)
#else
# if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
# pragma warn .8008 // Condition always true/false.
# pragma warn .8071 // Conversion may lose significant digits.
# pragma warn .8080 // identifier declared but never used.
# endif
#endif

23
boost/boost/iostreams/detail/config/gcc.hpp Normal file
View File

@ -0,0 +1,23 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Adapted from <boost/config/auto_link.hpp> and from
// http://www.boost.org/more/separate_compilation.html, by John Maddock.
#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_GCC_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_CONFIG_GCC_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // BOOST_INTEL.
#if defined(__GNUC__) && !defined(BOOST_INTEL)
# define BOOST_IOSTREAMS_GCC (__GNUC__ * 100 + __GNUC_MINOR__)
#endif
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_GCC_HPP_INCLUDED

14
boost/boost/iostreams/detail/config/limits.hpp Normal file
View File

@ -0,0 +1,14 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_CONFIG_LIMITS_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_CONFIG_LIMITS_HPP_INCLUDED
#ifndef BOOST_IOSTREAMS_MAX_FORWARDING_ARITY
# define BOOST_IOSTREAMS_MAX_FORWARDING_ARITY 3
#endif
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_LIMITS_HPP_INCLUDED

31
boost/boost/iostreams/detail/config/overload_resolution.hpp Normal file
View File

@ -0,0 +1,31 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Adapted from <boost/config/auto_link.hpp> and from
// http://www.boost.org/more/separate_compilation.html, by John Maddock.
#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_BROKEN_OVERLOAD_RESOLUTION_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_CONFIG_BROKEN_OVERLOAD_RESOLUTION_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // BOOST_MSVC.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/detail/config/gcc.hpp>
#if !defined(BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION)
# if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) || \
BOOST_WORKAROUND(__BORLANDC__, < 0x600) || \
BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || \
BOOST_WORKAROUND(BOOST_IOSTREAMS_GCC, <= 295) \
/**/
# define BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION
# endif
#endif
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_BROKEN_OVERLOAD_RESOLUTION_HPP_INCLUDED

54
boost/boost/iostreams/detail/config/wide_streams.hpp Normal file
View File

@ -0,0 +1,54 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Adapted from http://www.boost.org/more/separate_compilation.html, by
// John Maddock.
#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_WIDE_STREAMS_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_CONFIG_WIDE_STREAMS_HPP_INCLUDED
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <cstddef>
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
//------------------Templated stream support----------------------------------//
// From boost/dynamic_bitset.hpp; thanks to Matthias Troyer for cray patch.
#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
# if defined(__STL_CONFIG_H) && \
!defined (__STL_USE_NEW_IOSTREAMS) && !defined(__crayx1) \
/**/
# define BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
# endif
#endif // #ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
//------------------Wide stream support---------------------------------------//
#ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS
# if defined(BOOST_IOSTREAMS_NO_STREAM_TEMPLATES) || \
defined (BOOST_NO_STD_WSTREAMBUF) && \
( !defined(__MSL_CPP__) || defined(_MSL_NO_WCHART_CPP_SUPPORT) ) \
/**/
# define BOOST_IOSTREAMS_NO_WIDE_STREAMS
# endif
#endif // #ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS
//------------------Locale support--------------------------------------------//
#ifndef BOOST_IOSTREAMS_NO_LOCALE
# if defined(BOOST_NO_STD_LOCALE) || \
defined(__CYGWIN__) && \
( !defined(__MSL_CPP__) || defined(_MSL_NO_WCHART_CPP_SUPPORT) ) \
/**/
# define BOOST_IOSTREAMS_NO_LOCALE
# endif
#endif // #ifndef BOOST_IOSTREAMS_NO_LOCALE
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_WIDE_STREAMS_HPP_INCLUDED

49
boost/boost/iostreams/detail/config/zlib.hpp Normal file
View File

@ -0,0 +1,49 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Adapted from <boost/config/auto_link.hpp> and from
// http://www.boost.org/more/separate_compilation.html, by John Maddock.
#ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_ZLIB_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_CONFIG_ZLIB_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // BOOST_STRINGIZE.
#if defined(BOOST_ZLIB_BINARY)
# if defined(BOOST_MSVC) || \
defined(__BORLANDC__) || \
(defined(__MWERKS__) && defined(_WIN32) && (__MWERKS__ >= 0x3000)) || \
(defined(__ICL) && defined(_MSC_EXTENSIONS) && (_MSC_VER >= 1200)) \
/**/
// Specify the name of the .lib file.
# pragma comment(lib, BOOST_STRINGIZE(BOOST_ZLIB_BINARY))
# endif
#else
# if !defined(BOOST_IOSTREAMS_SOURCE) && \
!defined(BOOST_ALL_NO_LIB) && \
!defined(BOOST_IOSTREAMS_NO_LIB) \
/**/
// Set the name of our library, this will get undef'ed by auto_link.hpp
// once it's done with it.
# define BOOST_LIB_NAME boost_zlib
// If we're importing code from a dll, then tell auto_link.hpp about it.
# if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_IOSTREAMS_DYN_LINK)
# define BOOST_DYN_LINK
# endif
// And include the header that does the work.
# include <boost/config/auto_link.hpp>
# endif
#endif
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CONFIG_ZLIB_HPP_INCLUDED

24
boost/boost/iostreams/detail/default_arg.hpp Normal file
View File

@ -0,0 +1,24 @@
// (C) Copyright Jonathan Turkanis 2005.
// 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_DEFAULT_ARG_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_DEFAULT_ARG_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
# include <boost/mpl/identity.hpp>
# define BOOST_IOSTREAMS_DEFAULT_ARG(arg) mpl::identity< arg >::type
#else
# define BOOST_IOSTREAMS_DEFAULT_ARG(arg) arg
#endif
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_DEFAULT_ARG_HPP_INCLUDED

40
boost/boost/iostreams/detail/dispatch.hpp Normal file
View File

@ -0,0 +1,40 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_DISPATCH_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_DISPATCH_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // BOOST_DEDUCED_TYPENAME.
#include <boost/iostreams/detail/select.hpp>
#include <boost/iostreams/traits.hpp> // category_of.
#include <boost/mpl/void.hpp>
#include <boost/type_traits/is_convertible.hpp>
namespace boost { namespace iostreams {namespace detail {
template< typename T, typename Tag1, typename Tag2,
typename Tag3 = mpl::void_, typename Tag4 = mpl::void_,
typename Tag5 = mpl::void_, typename Tag6 = mpl::void_,
typename Category =
BOOST_DEDUCED_TYPENAME category_of<T>::type >
struct dispatch
: iostreams::select< // Disambiguation for Tru64.
is_convertible<Category, Tag1>, Tag1,
is_convertible<Category, Tag2>, Tag2,
is_convertible<Category, Tag3>, Tag3,
is_convertible<Category, Tag4>, Tag4,
is_convertible<Category, Tag5>, Tag5,
is_convertible<Category, Tag6>, Tag6
>
{ };
} } } // End namespaces detail, iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_DISPATCH_HPP_INCLUDED

113
boost/boost/iostreams/detail/double_object.hpp Normal file
View File

@ -0,0 +1,113 @@
// (C) Copyright Jonathan Turkanis 2004
// 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.
// Contains the definition of the class template
// boost::iostreams::detail::double_object, which is similar to compressed pair
// except that both members of the pair have the same type, and
// compression occurs only if requested using a boolean template
// parameter.
#ifndef BOOST_IOSTREAMS_DETAIL_DOUBLE_OBJECT_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_DOUBLE_OBJECT_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <algorithm> // swap.
#include <boost/detail/workaround.hpp>
#include <boost/mpl/if.hpp>
#if BOOST_WORKAROUND(__MWERKS__, > 0x3003)
# include <msl_utility>
#else
# include <boost/call_traits.hpp>
#endif
namespace boost { namespace iostreams { namespace detail {
template<typename T>
class single_object_holder {
public:
#if BOOST_WORKAROUND(__MWERKS__, > 0x3003)
typedef Metrowerks::call_traits<T> traits_type;
#else
typedef boost::call_traits<T> traits_type;
#endif
typedef typename traits_type::param_type param_type;
typedef typename traits_type::reference reference;
typedef typename traits_type::const_reference const_reference;
single_object_holder() { }
single_object_holder(param_type t) : first_(t) { }
reference first() { return first_; }
const_reference first() const { return first_; }
reference second() { return first_; }
const_reference second() const { return first_; }
void swap(single_object_holder& o)
{ std::swap(first_, o.first_); }
private:
T first_;
};
template<typename T>
struct double_object_holder {
public:
#if BOOST_WORKAROUND(__MWERKS__, > 0x3003)
typedef Metrowerks::call_traits<T> traits_type;
#else
typedef boost::call_traits<T> traits_type;
#endif
typedef typename traits_type::param_type param_type;
typedef typename traits_type::reference reference;
typedef typename traits_type::const_reference const_reference;
double_object_holder() { }
double_object_holder(param_type t1, param_type t2)
: first_(t1), second_(t2) { }
reference first() { return first_; }
const_reference first() const { return first_; }
reference second() { return second_; }
const_reference second() const { return second_; }
void swap(double_object_holder& d)
{
std::swap(first_, d.first_);
std::swap(second_, d.second_);
}
private:
T first_, second_;
};
template<typename T, typename IsDouble>
class double_object
: public mpl::if_<
IsDouble,
double_object_holder<T>,
single_object_holder<T>
>::type
{
private:
typedef typename
mpl::if_<
IsDouble,
double_object_holder<T>,
single_object_holder<T>
>::type base_type;
public:
#if BOOST_WORKAROUND(__MWERKS__, > 0x3003)
typedef Metrowerks::call_traits<T> traits_type;
#else
typedef boost::call_traits<T> traits_type;
#endif
typedef typename traits_type::param_type param_type;
typedef typename traits_type::reference reference;
typedef typename traits_type::const_reference const_reference;
double_object() : base_type() {}
double_object(param_type t1, param_type t2)
: base_type(t1, t2) { }
bool is_double() const { return IsDouble::value; }
};
} } } // End namespaces detail, iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_DOUBLE_OBJECT_HPP_INCLUDED

30
boost/boost/iostreams/detail/enable_if_stream.hpp Normal file
View File

@ -0,0 +1,30 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_ENABLE_IF_STREAM_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_ENABLE_IF_STREAM_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // BOOST_NO_SFINAE.
#include <boost/utility/enable_if.hpp>
#include <boost/iostreams/traits_fwd.hpp> // is_std_io.
#ifndef BOOST_NO_SFINAE
# define BOOST_IOSTREAMS_ENABLE_IF_STREAM(T) \
, typename boost::enable_if< boost::iostreams::is_std_io<T> >::type* = 0 \
/**/
# define BOOST_IOSTREAMS_DISABLE_IF_STREAM(T) \
, typename boost::disable_if< boost::iostreams::is_std_io<T> >::type* = 0 \
/**/
#else
# define BOOST_IOSTREAMS_ENABLE_IF_STREAM(T)
# define BOOST_IOSTREAMS_DISABLE_IF_STREAM(T)
#endif
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_ENABLE_IF_STREAM_HPP_INCLUDED

44
boost/boost/iostreams/detail/error.hpp Normal file
View File

@ -0,0 +1,44 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_ERROR_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_ERROR_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/iostreams/detail/ios.hpp> // failure.
namespace boost { namespace iostreams { namespace detail {
inline BOOST_IOSTREAMS_FAILURE cant_read()
{ return BOOST_IOSTREAMS_FAILURE("no read access"); }
inline BOOST_IOSTREAMS_FAILURE cant_write()
{ return BOOST_IOSTREAMS_FAILURE("no write access"); }
inline BOOST_IOSTREAMS_FAILURE cant_seek()
{ return BOOST_IOSTREAMS_FAILURE("no random access"); }
inline BOOST_IOSTREAMS_FAILURE bad_read()
{ return BOOST_IOSTREAMS_FAILURE("bad read"); }
inline BOOST_IOSTREAMS_FAILURE bad_putback()
{ return BOOST_IOSTREAMS_FAILURE("putback buffer full"); }
inline BOOST_IOSTREAMS_FAILURE bad_write()
{ return BOOST_IOSTREAMS_FAILURE("bad write"); }
inline BOOST_IOSTREAMS_FAILURE write_area_exhausted()
{ return BOOST_IOSTREAMS_FAILURE("write area exhausted"); }
inline BOOST_IOSTREAMS_FAILURE bad_seek()
{ return BOOST_IOSTREAMS_FAILURE("bad seek"); }
} } } // End namespaces detail, iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_ERROR_HPP_INCLUDED

101
boost/boost/iostreams/detail/forward.hpp Normal file
View File

@ -0,0 +1,101 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_FORWARD_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_FORWARD_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // BOOST_MSVC
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/detail/config/limits.hpp>
#include <boost/iostreams/detail/push_params.hpp>
#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
//------Macros for defining forwarding constructors and open overloads--------//
//
// Macro: BOOST_IOSTREAMS_DEFINE_FORWARDING_FUNCTIONS(mode, name, helper).
// Description: Defines constructors and overloads of 'open' which construct
// a device using the given argument list and pass it to 'open_impl'.
// Assumes that 'policy_type' is an alias for the device type.
// Not supported on Intel 7.1 and VC6.5.
//
#define BOOST_IOSTREAMS_FORWARD(class, impl, policy, params, args) \
class(const policy& t params()) \
{ this->impl(::boost::iostreams::detail::wrap(t) args()); } \
class(policy& t params()) \
{ this->impl(::boost::iostreams::detail::wrap(t) args()); } \
class(const ::boost::reference_wrapper<policy>& ref params()) \
{ this->impl(ref args()); } \
void open(const policy& t params()) \
{ this->impl(::boost::iostreams::detail::wrap(t) args()); } \
void open(policy& t params()) \
{ this->impl(::boost::iostreams::detail::wrap(t) args()); } \
void open(const ::boost::reference_wrapper<policy>& ref params()) \
{ this->impl(ref args()); } \
BOOST_PP_REPEAT_FROM_TO( \
1, BOOST_PP_INC(BOOST_IOSTREAMS_MAX_FORWARDING_ARITY), \
BOOST_IOSTREAMS_FORWARDING_CTOR, (class, impl, policy) \
) \
BOOST_PP_REPEAT_FROM_TO( \
1, BOOST_PP_INC(BOOST_IOSTREAMS_MAX_FORWARDING_ARITY), \
BOOST_IOSTREAMS_FORWARDING_FN, (class, impl, policy) \
) \
/**/
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
# define BOOST_IOSTREAMS_FORWARDING_CTOR_I(z, n, tuple) \
template< typename U100 BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \
BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_DEC(n), typename U) > \
BOOST_PP_TUPLE_ELEM(3, 0, tuple) \
( U100& u100 BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \
BOOST_PP_ENUM_BINARY_PARAMS_Z(z, BOOST_PP_DEC(n), const U, &u)) \
{ this->BOOST_PP_TUPLE_ELEM(3, 1, tuple) \
( BOOST_PP_TUPLE_ELEM(3, 2, tuple) \
( u100 BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \
BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_DEC(n), u)) ); } \
/**/
# define BOOST_IOSTREAMS_FORWARDING_FN_I(z, n, tuple) \
template< typename U100 BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \
BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_DEC(n), typename U) > \
void open \
( U100& u100 BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \
BOOST_PP_ENUM_BINARY_PARAMS_Z(z, BOOST_PP_DEC(n), const U, &u)) \
{ this->BOOST_PP_TUPLE_ELEM(3, 1, tuple) \
( u100 BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \
BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_DEC(n), u) ); } \
/**/
#else
# define BOOST_IOSTREAMS_FORWARDING_CTOR_I(z, n, tuple)
# define BOOST_IOSTREAMS_FORWARDING_FN_I(z, n, tuple)
#endif
#define BOOST_IOSTREAMS_FORWARDING_CTOR(z, n, tuple) \
template<BOOST_PP_ENUM_PARAMS_Z(z, n, typename U)> \
BOOST_PP_TUPLE_ELEM(3, 0, tuple) \
(BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, const U, &u)) \
{ this->BOOST_PP_TUPLE_ELEM(3, 1, tuple) \
( BOOST_PP_TUPLE_ELEM(3, 2, tuple) \
(BOOST_PP_ENUM_PARAMS_Z(z, n, u)) ); } \
BOOST_IOSTREAMS_FORWARDING_CTOR_I(z, n, tuple) \
/**/
#define BOOST_IOSTREAMS_FORWARDING_FN(z, n, tuple) \
template<BOOST_PP_ENUM_PARAMS_Z(z, n, typename U)> \
void open(BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, const U, &u)) \
{ this->BOOST_PP_TUPLE_ELEM(3, 1, tuple) \
( BOOST_PP_TUPLE_ELEM(3, 2, tuple) \
(BOOST_PP_ENUM_PARAMS_Z(z, n, u)) ); } \
BOOST_IOSTREAMS_FORWARDING_FN_I(z, n, tuple) \
/**/
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_FORWARD_HPP_INCLUDED

32
boost/boost/iostreams/detail/fstream.hpp Normal file
View File

@ -0,0 +1,32 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_FSTREAM_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_FSTREAM_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/iostreams/detail/config/wide_streams.hpp>
#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
# include <fstream>
#else
# include <fstream.h>
#endif
#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
# define BOOST_IOSTREAMS_BASIC_IFSTREAM(Ch, Tr) std::basic_ifstream<Ch, Tr>
# define BOOST_IOSTREAMS_BASIC_OFSTREAM(Ch, Tr) std::basic_ofstream<Ch, Tr>
# define BOOST_IOSTREAMS_BASIC_FSTREAM(Ch, Tr) std::basic_fstream<Ch, Tr>
# define BOOST_IOSTREAMS_BASIC_FILEBUF(Ch) std::basic_filebuf<Ch>
#else
# define BOOST_IOSTREAMS_BASIC_IFSTREAM(Ch, Tr) std::ifstream
# define BOOST_IOSTREAMS_BASIC_OFSTREAM(Ch, Tr) std::ofstream
# define BOOST_IOSTREAMS_BASIC_FILEBUF(Ch) std::filebuf
#endif
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_FSTREAM_HPP_INCLUDED

65
boost/boost/iostreams/detail/ios.hpp Normal file
View File

@ -0,0 +1,65 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_IOS_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_IOS_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // BOOST_MSVC.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/detail/config/wide_streams.hpp>
#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
# if !BOOST_WORKAROUND(__MWERKS__, <= 0x3003)
# include <ios>
# else
# include <istream>
# include <ostream>
# endif
#else
# include <exception>
# include <iosfwd>
#endif
namespace boost { namespace iostreams { namespace detail {
#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //--------------------------------//
# define BOOST_IOSTREAMS_BASIC_IOS(ch, tr) std::basic_ios< ch, tr >
# if !BOOST_WORKAROUND(__MWERKS__, <= 0x3003) && \
!BOOST_WORKAROUND(__BORLANDC__, < 0x600) && \
!BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
/**/
#define BOOST_IOS std::ios
#define BOOST_IOSTREAMS_FAILURE std::ios::failure
# else
#define BOOST_IOS std::ios_base
#define BOOST_IOSTREAMS_FAILURE std::ios_base::failure
# endif
#else // #ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-----------------------//
#define BOOST_IOS std::ios
#define BOOST_IOSTREAMS_BASIC_IOS(ch, tr) std::ios
#define BOOST_IOSTREAMS_FAILURE boost::iostreams::detail::failure
class failure : std::exception {
public:
explicit failure(const std::string& what_arg) : what_(what_arg) { }
const char* what() const { return what_.c_str(); }
private:
std::string what_;
};
#endif // #ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //----------------------//
} } } // End namespace failure, iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_IOS_HPP_INCLUDED

33
boost/boost/iostreams/detail/iostream.hpp Normal file
View File

@ -0,0 +1,33 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_IOSTREAM_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_IOSTREAM_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/iostreams/detail/config/wide_streams.hpp>
#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
# include <istream>
# include <ostream>
#else
# include <iostream.h>
#endif
#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
# define BOOST_IOSTREAMS_BASIC_ISTREAM(ch, tr) std::basic_istream< ch, tr >
# define BOOST_IOSTREAMS_BASIC_OSTREAM(ch, tr) std::basic_ostream< ch, tr >
# define BOOST_IOSTREAMS_BASIC_IOSTREAM(ch, tr) std::basic_iostream< ch, tr >
#else
# define BOOST_IOSTREAMS_BASIC_STREAMBUF(ch, tr) std::streambuf
# define BOOST_IOSTREAMS_BASIC_ISTREAM(ch, tr) std::istream
# define BOOST_IOSTREAMS_BASIC_OSTREAM(ch, tr) std::ostream
# define BOOST_IOSTREAMS_BASIC_IOSTREAM(ch, tr) std::iostream
#endif
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_IOSTREAM_HPP_INCLUDED

84
boost/boost/iostreams/detail/is_dereferenceable.hpp Normal file
View File

@ -0,0 +1,84 @@
// (C) Copyright David Abrahams 2004.
// (C) Copyright Jonathan Turkanis 2005.
// 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_IS_DEREFERENCEABLE_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_IS_DEREFERENCEABLE_HPP_INCLUDED
# include <boost/type_traits/detail/bool_trait_def.hpp>
# include <boost/type_traits/detail/template_arity_spec.hpp>
# include <boost/type_traits/remove_cv.hpp>
# include <boost/mpl/aux_/lambda_support.hpp>
# include <boost/mpl/bool.hpp>
# include <boost/detail/workaround.hpp>
namespace boost { namespace iostreams { namespace detail {
// is_dereferenceable<T> metafunction
//
// Requires: Given x of type T&, if the expression *x is well-formed
// it must have complete type; otherwise, it must neither be ambiguous
// nor violate access.
// This namespace ensures that ADL doesn't mess things up.
namespace is_dereferenceable_
{
// a type returned from operator* when no increment is found in the
// type's own namespace
struct tag {};
// any soaks up implicit conversions and makes the following
// operator* less-preferred than any other such operator that
// might be found via ADL.
struct any { template <class T> any(T const&); };
// This is a last-resort operator* for when none other is found
tag operator*(any const&);
# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \
|| BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
# define BOOST_comma(a,b) (a)
# else
// In case an operator++ is found that returns void, we'll use ++x,0
tag operator,(tag,int);
# define BOOST_comma(a,b) (a,b)
# endif
// two check overloads help us identify which operator++ was picked
char (& check(tag) )[2];
template <class T>
char check(T const&);
template <class T>
struct impl
{
static typename boost::remove_cv<T>::type& x;
BOOST_STATIC_CONSTANT(
bool
, value = sizeof(is_dereferenceable_::check(BOOST_comma(*x,0))) == 1
);
};
}
# undef BOOST_comma
template<typename T>
struct is_dereferenceable
BOOST_TT_AUX_BOOL_C_BASE(is_dereferenceable_::impl<T>::value)
{
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(is_dereferenceable_::impl<T>::value)
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_dereferenceable,(T))
};
} }
BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::boost::iostreams::detail::is_dereferenceable)
} // End namespaces detail, iostreams, boost.
#endif // BOOST_IOSTREAMS_DETAIL_IS_DEREFERENCEABLE_HPP_INCLUDED

26
boost/boost/iostreams/detail/is_iterator_range.hpp Normal file
View File

@ -0,0 +1,26 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_IS_ITERATOR_RANGE_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_IS_ITERATOR_RANGE_HPP_INCLUDED
#include <boost/iostreams/detail/bool_trait_def.hpp>
namespace boost {
// We avoid dependence on Boost.Range by using a forward declaration.
template<typename Iterator>
class iterator_range;
namespace iostreams {
BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_iterator_range, boost::iterator_range, 1)
} // End namespace iostreams.
} // End namespace boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_IS_ITERATOR_RANGE_HPP_INCLUDED

113
boost/boost/iostreams/detail/optional.hpp Normal file
View File

@ -0,0 +1,113 @@
// (C) Copyright Jonathan Turkanis 2005.
// 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.
// Recent changes to Boost.Optional involving assigment broke Boost.Iostreams,
// in a way which could be remedied only by relying on the deprecated reset
// functions; with VC6, even reset didn't work. Until this problem is
// understood, Iostreams will use a private version of optional with a smart
// pointer interface.
#ifndef BOOST_IOSTREAMS_DETAIL_OPTIONAL_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_OPTIONAL_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <cassert>
#include <boost/mpl/int.hpp>
#include <boost/type_traits/aligned_storage.hpp>
#include <boost/type_traits/alignment_of.hpp>
namespace boost { namespace iostreams { namespace detail {
// Taken from <boost/optional.hpp>.
template<class T>
class aligned_storage
{
// Borland ICEs if unnamed unions are used for this!
union dummy_u
{
char data[ sizeof(T) ];
BOOST_DEDUCED_TYPENAME type_with_alignment<
::boost::alignment_of<T>::value >::type aligner_;
} dummy_ ;
public:
void const* address() const { return &dummy_.data[0]; }
void * address() { return &dummy_.data[0]; }
};
template<typename T>
class optional {
public:
typedef T element_type;
optional() : initialized_(false) { }
optional(const T& t) : initialized_(false) { reset(t); }
~optional() { reset(); }
T& operator*()
{
assert(initialized_);
return *static_cast<T*>(address());
}
const T& operator*() const
{
assert(initialized_);
return *static_cast<const T*>(address());
}
T* operator->()
{
assert(initialized_);
return static_cast<T*>(address());
}
const T* operator->() const
{
assert(initialized_);
return static_cast<const T*>(address());
}
T* get()
{
assert(initialized_);
return static_cast<T*>(address());
}
const T* get() const
{
assert(initialized_);
return static_cast<const T*>(address());
}
void reset()
{
if (initialized_) {
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) || \
BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) \
/**/
T* t = static_cast<T*>(address());
t->~T();
#else
static_cast<T*>(address())->T::~T();
#endif
initialized_ = false;
}
}
void reset(const T& t)
{
reset();
new (address()) T(t);
initialized_ = true;
}
private:
optional(const optional&);
optional& operator=(const optional&);
void* address() { return &storage_; }
const void* address() const { return &storage_; }
aligned_storage<T> storage_;
bool initialized_;
};
} } } // End namespaces detail, iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_OPTIONAL_HPP_INCLUDED

153
boost/boost/iostreams/detail/push.hpp Normal file
View File

@ -0,0 +1,153 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_PUSH_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_PUSH_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // BOOST_MSVC.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/detail/adapter/range_adapter.hpp>
#include <boost/iostreams/detail/config/wide_streams.hpp>
#include <boost/iostreams/detail/enable_if_stream.hpp>
#include <boost/iostreams/pipeline.hpp>
#include <boost/iostreams/detail/push_params.hpp>
#include <boost/iostreams/detail/resolve.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/control/iif.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_convertible.hpp>
//
// Macro: BOOST_IOSTREAMS_DEFINE_PUSH_CONSTRUCTOR(mode, name, helper).
// Description: Defines overloads with name 'name' which forward to a function
// 'helper' which takes a filter or devide by const reference.
//
#define BOOST_IOSTREAMS_DEFINE_PUSH_CONSTRUCTOR(name, mode, ch, helper) \
BOOST_IOSTREAMS_DEFINE_PUSH_IMPL(name, mode, ch, helper, 0, ?) \
/**/
//
// Macro: BOOST_IOSTREAMS_DEFINE_PUSH_CONSTRUCTOR(mode, name, helper).
// Description: Defines constructors which forward to a function
// 'helper' which takes a filter or device by const reference.
//
#define BOOST_IOSTREAMS_DEFINE_PUSH(name, mode, ch, helper) \
BOOST_IOSTREAMS_DEFINE_PUSH_IMPL(name, mode, ch, helper, 1, void) \
/**/
//--------------------Definition of BOOST_IOSTREAMS_DEFINE_PUSH_IMPL----------//
#define BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, arg, helper, has_return) \
this->helper( ::boost::iostreams::detail::resolve<mode, ch>(arg) \
BOOST_IOSTREAMS_PUSH_ARGS() ); \
/**/
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) && \
!BOOST_WORKAROUND(__BORLANDC__, < 0x600) \
/**/
# ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
# define BOOST_IOSTREAMS_DEFINE_PUSH_IMPL(name, mode, ch, helper, has_return, result) \
template<typename CharType, typename TraitsType> \
BOOST_PP_IIF(has_return, result, explicit) \
name(::std::basic_streambuf<CharType, TraitsType>& sb BOOST_IOSTREAMS_PUSH_PARAMS()) \
{ BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, sb, helper, has_return); } \
template<typename CharType, typename TraitsType> \
BOOST_PP_IIF(has_return, result, explicit) \
name(::std::basic_istream<CharType, TraitsType>& is BOOST_IOSTREAMS_PUSH_PARAMS()) \
{ BOOST_STATIC_ASSERT((!is_convertible<mode, output>::value)); \
BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, is, helper, has_return); } \
template<typename CharType, typename TraitsType> \
BOOST_PP_IIF(has_return, result, explicit) \
name(::std::basic_ostream<CharType, TraitsType>& os BOOST_IOSTREAMS_PUSH_PARAMS()) \
{ BOOST_STATIC_ASSERT((!is_convertible<mode, input>::value)); \
BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, os, helper, has_return); } \
template<typename CharType, typename TraitsType> \
BOOST_PP_IIF(has_return, result, explicit) \
name(::std::basic_iostream<CharType, TraitsType>& io BOOST_IOSTREAMS_PUSH_PARAMS()) \
{ BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, io, helper, has_return); } \
template<typename Iter> \
BOOST_PP_IIF(has_return, result, explicit) \
name(const iterator_range<Iter>& rng BOOST_IOSTREAMS_PUSH_PARAMS()) \
{ BOOST_PP_EXPR_IF(has_return, return) \
this->helper( ::boost::iostreams::detail::range_adapter< \
mode, iterator_range<Iter> \
>(rng) \
BOOST_IOSTREAMS_PUSH_ARGS() ); } \
template<typename Pipeline, typename Concept> \
BOOST_PP_IIF(has_return, result, explicit) \
name(const ::boost::iostreams::pipeline<Pipeline, Concept>& p) \
{ p.push(*this); } \
template<typename T> \
BOOST_PP_IIF(has_return, result, explicit) \
name(const T& t BOOST_IOSTREAMS_PUSH_PARAMS() BOOST_IOSTREAMS_DISABLE_IF_STREAM(T)) \
{ this->helper( ::boost::iostreams::detail::resolve<mode, ch>(t) \
BOOST_IOSTREAMS_PUSH_ARGS() ); } \
/**/
# else // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
# define BOOST_IOSTREAMS_DEFINE_PUSH_IMPL(name, mode, ch, helper, has_return, result) \
BOOST_PP_IF(has_return, result, explicit) \
name(::std::streambuf& sb BOOST_IOSTREAMS_PUSH_PARAMS()) \
{ BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, sb, helper, has_return); } \
BOOST_PP_IF(has_return, result, explicit) \
name(::std::istream& is BOOST_IOSTREAMS_PUSH_PARAMS()) \
{ BOOST_STATIC_ASSERT((!is_convertible<mode, output>::value)); \
BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, is, helper, has_return); } \
BOOST_PP_IF(has_return, result, explicit) \
name(::std::ostream& os BOOST_IOSTREAMS_PUSH_PARAMS()) \
{ BOOST_STATIC_ASSERT((!is_convertible<mode, input>::value)); \
BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, os, helper, has_return); } \
BOOST_PP_IF(has_return, result, explicit) \
name(::std::iostream& io BOOST_IOSTREAMS_PUSH_PARAMS()) \
{ BOOST_IOSTREAMS_ADAPT_STREAM(mode, ch, io, helper, has_return); } \
template<typename Iter> \
BOOST_PP_IF(has_return, result, explicit) \
name(const iterator_range<Iter>& rng BOOST_IOSTREAMS_PUSH_PARAMS()) \
{ BOOST_PP_EXPR_IF(has_return, return) \
this->helper( ::boost::iostreams::detail::range_adapter< \
mode, iterator_range<Iter> \
>(rng) \
BOOST_IOSTREAMS_PUSH_ARGS() ); } \
template<typename Pipeline, typename Concept> \
BOOST_PP_IF(has_return, result, explicit) \
name(const ::boost::iostreams::pipeline<Pipeline, Concept>& p) \
{ p.push(*this); } \
template<typename T> \
BOOST_PP_EXPR_IF(has_return, result) \
name(const T& t BOOST_IOSTREAMS_PUSH_PARAMS() BOOST_IOSTREAMS_DISABLE_IF_STREAM(T)) \
{ this->helper( ::boost::iostreams::detail::resolve<mode, ch>(t) \
BOOST_IOSTREAMS_PUSH_ARGS() ); } \
/**/
# endif // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
#else // #if VC6, VC7.0, Borland 5.x
# define BOOST_IOSTREAMS_DEFINE_PUSH_IMPL(name, mode, ch, helper, has_return, result) \
template<typename T> \
void BOOST_PP_CAT(name, _msvc_impl) \
( ::boost::mpl::true_, const T& t BOOST_IOSTREAMS_PUSH_PARAMS() ) \
{ t.push(*this); } \
template<typename T> \
void BOOST_PP_CAT(name, _msvc_impl) \
( ::boost::mpl::false_, const T& t BOOST_IOSTREAMS_PUSH_PARAMS() ) \
{ this->helper( ::boost::iostreams::detail::resolve<mode, ch>(t) \
BOOST_IOSTREAMS_PUSH_ARGS() ); } \
template<typename T> \
BOOST_PP_IF(has_return, result, explicit) \
name(const T& t BOOST_IOSTREAMS_PUSH_PARAMS()) \
{ \
this->BOOST_PP_CAT(name, _msvc_impl) \
( ::boost::iostreams::detail::is_pipeline<T>(), \
t BOOST_IOSTREAMS_PUSH_ARGS() ); \
} \
/**/
#endif // #if VC6, VC7.0, Borland 5.x
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_PUSH_HPP_INCLUDED

20
boost/boost/iostreams/detail/push_params.hpp Normal file
View File

@ -0,0 +1,20 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_PUSH_PARAMS_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_PUSH_PARAMS_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#define BOOST_IOSTREAMS_PUSH_PARAMS() \
, int buffer_size = -1 , int pback_size = -1 \
/**/
#define BOOST_IOSTREAMS_PUSH_ARGS() , buffer_size, pback_size
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_PUSH_PARAMS_HPP_INCLUDED

229
boost/boost/iostreams/detail/resolve.hpp Normal file
View File

@ -0,0 +1,229 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_RESOLVE_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_RESOLVE_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // partial spec, put size_t in std.
#include <cstddef> // std::size_t.
#include <boost/detail/is_incrementable.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/detail/adapter/mode_adapter.hpp>
#include <boost/iostreams/detail/adapter/output_iterator_adapter.hpp>
#include <boost/iostreams/detail/adapter/range_adapter.hpp>
#include <boost/iostreams/detail/config/gcc.hpp>
#include <boost/iostreams/detail/config/overload_resolution.hpp>
#include <boost/iostreams/detail/config/wide_streams.hpp>
#include <boost/iostreams/detail/enable_if_stream.hpp>
#include <boost/iostreams/detail/is_dereferenceable.hpp>
#include <boost/iostreams/detail/is_iterator_range.hpp>
#include <boost/iostreams/detail/select.hpp>
#include <boost/iostreams/detail/wrap_unwrap.hpp>
#include <boost/iostreams/device/array.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/bool.hpp> // true_.
#include <boost/mpl/if.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/type_traits/is_array.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp> // VC7.1 C4224.
namespace boost { namespace iostreams { namespace detail {
//------------------Definition of resolve-------------------------------------//
#ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //-------------------------//
template<typename Mode, typename Ch, typename T>
struct resolve_traits {
typedef typename
mpl::if_<
boost::detail::is_incrementable<T>,
output_iterator_adapter<Mode, Ch, T>,
const T&
>::type type;
};
# ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-------------------------------//
template<typename Mode, typename Ch, typename T>
typename resolve_traits<Mode, Ch, T>::type
resolve( const T& t
BOOST_IOSTREAMS_DISABLE_IF_STREAM(T)
// I suspect that the compilers which require this workaround may
// be correct, but I'm not sure why :(
#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, BOOST_TESTED_AT(810)) ||\
BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205)) || \
BOOST_WORKAROUND(BOOST_IOSTREAMS_GCC, BOOST_TESTED_AT(400)) \
/**/
, typename disable_if< is_iterator_range<T> >::type* = 0
#endif
)
{
typedef typename resolve_traits<Mode, Ch, T>::type return_type;
return return_type(t);
}
template<typename Mode, typename Ch, typename Tr>
mode_adapter< Mode, std::basic_streambuf<Ch, Tr> >
resolve(std::basic_streambuf<Ch, Tr>& sb)
{ return mode_adapter< Mode, std::basic_streambuf<Ch, Tr> >(wrap(sb)); }
template<typename Mode, typename Ch, typename Tr>
mode_adapter< Mode, std::basic_istream<Ch, Tr> >
resolve(std::basic_istream<Ch, Tr>& is)
{ return mode_adapter< Mode, std::basic_istream<Ch, Tr> >(wrap(is)); }
template<typename Mode, typename Ch, typename Tr>
mode_adapter< Mode, std::basic_ostream<Ch, Tr> >
resolve(std::basic_ostream<Ch, Tr>& os)
{ return mode_adapter< Mode, std::basic_ostream<Ch, Tr> >(wrap(os)); }
template<typename Mode, typename Ch, typename Tr>
mode_adapter< Mode, std::basic_iostream<Ch, Tr> >
resolve(std::basic_iostream<Ch, Tr>& io)
{ return mode_adapter< Mode, std::basic_iostream<Ch, Tr> >(wrap(io)); }
template<typename Mode, typename Ch, std::size_t N>
array_adapter<Mode, Ch> resolve(Ch (&array)[N])
{ return array_adapter<Mode, Ch>(array); }
template<typename Mode, typename Ch, typename Iter>
range_adapter< Mode, boost::iterator_range<Iter> >
resolve(const boost::iterator_range<Iter>& rng)
{ return range_adapter< Mode, boost::iterator_range<Iter> >(rng); }
# else // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //---------------------//
template<typename Mode, typename Ch, typename T>
typename resolve_traits<Mode, Ch, T>::type
resolve( const T& t
BOOST_IOSTREAMS_DISABLE_IF_STREAM(T)
#if defined(__GNUC__)
, typename disable_if< is_iterator_range<T> >::type* = 0
#endif
)
{
typedef typename resolve_traits<Mode, Ch, T>::type return_type;
return return_type(t);
}
template<typename Mode, typename Ch>
mode_adapter<Mode, std::streambuf>
resolve(std::streambuf& sb)
{ return mode_adapter<Mode, std::streambuf>(wrap(sb)); }
template<typename Mode, typename Ch>
mode_adapter<Mode, std::istream>
resolve(std::istream& is)
{ return mode_adapter<Mode, std::istream>(wrap(is)); }
template<typename Mode, typename Ch>
mode_adapter<Mode, std::ostream>
resolve(std::ostream& os)
{ return mode_adapter<Mode, std::ostream>(wrap(os)); }
template<typename Mode, typename Ch>
mode_adapter<Mode, std::iostream>
resolve(std::iostream& io)
{ return mode_adapter<Mode, std::iostream>(wrap(io)); }
template<typename Mode, typename Ch, std::size_t N>
array_adapter<Mode, Ch> resolve(Ch (&array)[N])
{ return array_adapter<Mode, Ch>(array); }
template<typename Mode, typename Ch, typename Iter>
range_adapter< Mode, boost::iterator_range<Iter> >
resolve(const boost::iterator_range<Iter>& rng)
{ return range_adapter< Mode, boost::iterator_range<Iter> >(rng); }
# endif // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //--------------------//
#else // #ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //----------------//
template<typename Mode, typename Ch, typename T>
struct resolve_traits {
// Note: test for is_iterator_range must come before test for output
// iterator.
typedef typename
iostreams::select< // Disambiguation for Tru64.
is_std_io<T>,
mode_adapter<Mode, T>,
is_iterator_range<T>,
range_adapter<Mode, T>,
is_dereferenceable<T>,
output_iterator_adapter<Mode, Ch, T>,
is_array<T>,
array_adapter<Mode, T>,
else_,
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
const T&
#else
T
#endif
>::type type;
};
template<typename Mode, typename Ch, typename T>
typename resolve_traits<Mode, Ch, T>::type
resolve(const T& t, mpl::true_)
{ // Bad overload resolution.
typedef typename resolve_traits<Mode, Ch, T>::type return_type;
return return_type(wrap(const_cast<T&>(t)));
}
template<typename Mode, typename Ch, typename T>
typename resolve_traits<Mode, Ch, T>::type
resolve(const T& t, mpl::false_)
{
typedef typename resolve_traits<Mode, Ch, T>::type return_type;
return return_type(t);
}
template<typename Mode, typename Ch, typename T>
typename resolve_traits<Mode, Ch, T>::type
resolve(const T& t BOOST_IOSTREAMS_DISABLE_IF_STREAM(T))
{ return resolve<Mode, Ch>(t, is_std_io<T>()); }
# if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && \
!BOOST_WORKAROUND(BOOST_MSVC, <= 1300) && \
!defined(__GNUC__) // ---------------------------------------------------//
template<typename Mode, typename Ch, typename T>
typename resolve_traits<Mode, Ch, T>::type
resolve(T& t, mpl::true_)
{
typedef typename resolve_traits<Mode, Ch, T>::type return_type;
return return_type(wrap(t));
}
template<typename Mode, typename Ch, typename T>
typename resolve_traits<Mode, Ch, T>::type
resolve(T& t, mpl::false_)
{
typedef typename resolve_traits<Mode, Ch, T>::type return_type;
return return_type(t);
}
template<typename Mode, typename Ch, typename T>
typename resolve_traits<Mode, Ch, T>::type
resolve(T& t BOOST_IOSTREAMS_ENABLE_IF_STREAM(T))
{ return resolve<Mode, Ch>(t, is_std_io<T>()); }
# endif // Borland 5.x, VC6-7.0 or GCC 2.9x //--------------------------------//
#endif // #ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //---------------//
} } } // End namespaces detail, iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp> // VC7.1 4224.
#endif // BOOST_IOSTREAMS_DETAIL_RESOLVE_HPP_INCLUDED

79
boost/boost/iostreams/detail/select.hpp Normal file
View File

@ -0,0 +1,79 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Contains the metafunction select, which mimics the effect of a chain of
// nested mpl if_'s.
//
// -----------------------------------------------------------------------------
//
// Usage:
//
// typedef typename select<
// case1, type1,
// case2, type2,
// ...
// true_, typen
// >::type selection;
//
// Here case1, case2, ... are models of MPL::IntegralConstant with value type
// bool, and n <= 10.
#ifndef BOOST_IOSTREAMS_SELECT_HPP_INCLUDED
#define BOOST_IOSTREAMS_SELECT_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/void.hpp>
namespace boost { namespace iostreams {
typedef mpl::true_ else_;
template< typename Case1 = mpl::true_,
typename Type1 = mpl::void_,
typename Case2 = mpl::true_,
typename Type2 = mpl::void_,
typename Case3 = mpl::true_,
typename Type3 = mpl::void_,
typename Case4 = mpl::true_,
typename Type4 = mpl::void_,
typename Case5 = mpl::true_,
typename Type5 = mpl::void_,
typename Case6 = mpl::true_,
typename Type6 = mpl::void_,
typename Case7 = mpl::true_,
typename Type7 = mpl::void_,
typename Case8 = mpl::true_,
typename Type8 = mpl::void_,
typename Case9 = mpl::true_,
typename Type9 = mpl::void_,
typename Case10 = mpl::true_,
typename Type10 = mpl::void_ >
struct select {
typedef typename
mpl::eval_if<
Case1, mpl::identity<Type1>, mpl::eval_if<
Case2, mpl::identity<Type2>, mpl::eval_if<
Case3, mpl::identity<Type3>, mpl::eval_if<
Case4, mpl::identity<Type4>, mpl::eval_if<
Case5, mpl::identity<Type5>, mpl::eval_if<
Case6, mpl::identity<Type6>, mpl::eval_if<
Case7, mpl::identity<Type7>, mpl::eval_if<
Case8, mpl::identity<Type8>, mpl::eval_if<
Case9, mpl::identity<Type9>, mpl::if_<
Case10, Type10, mpl::void_ > > > > > > > > >
>::type type;
};
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_SELECT_HPP_INCLUDED

159
boost/boost/iostreams/detail/select_by_size.hpp Normal file
View File

@ -0,0 +1,159 @@
// (C) Copyright Jonathan Turkanis 2004.
// 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.
//
// Intended as an alternative to type_traits::yes_type and type_traits::no_type.
// Provides an arbitrary number of types (case_<0>, case_<1>, ...) for
// determining the results of overload resultion using 'sizeof', plus a uniform
// means of using the result. yes_type and no_type are typedefs for case_<1>
// and case_<0>. A single case with negative argument, case_<-1>, is also
// provided, for convenience.
//
// This header may be included any number of times, with
// BOOST_SELECT_BY_SIZE_MAX_CASE defined to be the largest N such that case_<N>
// is needed for a particular application. It defaults to 20.
//
// This header depends only on Boost.Config and Boost.Preprocessor. Dependence
// on Type Traits or MPL was intentionally avoided, to leave open the
// possibility that select_by_size could be used by these libraries.
//
// Example usage:
//
// #define BOOST_SELECT_BY_SIZE_MAX_CASE 7 // (Needed when default was 2)
// #include <boost/utility/select_by_size.hpp>
//
// using namespace boost::utility;
//
// case_<0> helper(bool);
// case_<1> helper(int);
// case_<2> helper(unsigned);
// case_<3> helper(long);
// case_<4> helper(unsigned long);
// case_<5> helper(float);
// case_<6> helper(double);
// case_<7> helper(const char*);
//
// struct test {
// static const int value =
// select_by_size< sizeof(helper(9876UL)) >::value;
// BOOST_STATIC_ASSERT(value == 4);
// };
//
// For compilers with integral constant expression problems, e.g. Borland 5.x,
// one can also write
//
// struct test {
// BOOST_SELECT_BY_SIZE(int, value, helper(9876UL));
// };
//
// to define a static integral constant 'value' equal to
//
// select_by_size< sizeof(helper(9876UL)) >::value.
//
// Include guards surround all contents of this header except for explicit
// specializations of select_by_size for case_<N> with N > 2.
#ifndef BOOST_IOSTREAMS_DETAIL_SELECT_BY_SIZE_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_SELECT_BY_SIZE_HPP_INCLUDED
// The lowest N for which select_by_size< sizeof(case_<N>) > has not been
// specialized.
#define SELECT_BY_SIZE_MAX_SPECIALIZED 20
#include <boost/config.hpp> // BOOST_STATIC_CONSTANT.
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/iteration/local.hpp>
/* Alternative implementation using max_align.
#include <boost/type_traits/alignment_of.hpp>
#include <boost/type_traits/type_with_alignment.hpp>
namespace boost { namespace utility {
template<int N>
struct case_ { char c[(N + 1) * alignment_of<detail::max_align>::value]; };
template<unsigned Size>
struct select_by_size {
BOOST_STATIC_CONSTANT(int, value =
(Size / alignment_of<detail::max_align>::value - 1));
};
} } // End namespaces utility, boost.
*/ // End alternate implementation.
namespace boost { namespace iostreams { namespace detail {
//--------------Definition of case_-------------------------------------------//
template<int N> struct case_ { char c1; case_<N - 1> c2; };
template<> struct case_<-1> { char c; };
typedef case_<true> yes_type;
typedef case_<false> no_type;
//--------------Declaration of select_by_size---------------------------------//
template<unsigned Size> struct select_by_size;
} } } // End namespaces detail, iostreams, boost.
//--------------Definition of SELECT_BY_SIZE_SPEC-----------------------------//
// Sepecializes select_by_size for sizeof(case<n-1>). The decrement is used
// here because the preprocessor library doesn't handle negative integers.
#define SELECT_BY_SIZE_SPEC(n) \
namespace boost { namespace iostreams { namespace detail { \
static const int BOOST_PP_CAT(sizeof_case_, n) = sizeof(case_<n - 1>); \
template<> \
struct select_by_size< BOOST_PP_CAT(sizeof_case_, n) > { \
struct type { BOOST_STATIC_CONSTANT(int, value = n - 1); }; \
BOOST_STATIC_CONSTANT(int, value = type::value); \
}; \
} } } \
/**/
//--------------Default specializations of select_by_size---------------------//
#define BOOST_PP_LOCAL_MACRO(n) SELECT_BY_SIZE_SPEC(n)
#define BOOST_PP_LOCAL_LIMITS (0, 20)
#include BOOST_PP_LOCAL_ITERATE()
#undef BOOST_PP_LOCAL_MACRO
//--------------Definition of SELECT_BY_SIZE----------------------------------//
#define BOOST_SELECT_BY_SIZE(type_, name, expr) \
BOOST_STATIC_CONSTANT( \
unsigned, \
BOOST_PP_CAT(boost_select_by_size_temp_, name) = sizeof(expr) \
); \
BOOST_STATIC_CONSTANT( \
type_, \
name = \
( ::boost::iostreams::detail::select_by_size< \
BOOST_PP_CAT(boost_select_by_size_temp_, name) \
>::value ) \
) \
/**/
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_SELECT_BY_SIZE_HPP_INCLUDED
//----------Specializations of SELECT_BY_SIZE (outside main inclued guards)---//
#if BOOST_SELECT_BY_SIZE_MAX_CASE > SELECT_BY_SIZE_MAX_SPECIALIZED
#define BOOST_PP_LOCAL_MACRO(n) SELECT_BY_SIZE_SPEC(n)
#define BOOST_PP_LOCAL_LIMITS \
(SELECT_BY_SIZE_MAX_SPECIALIZED, BOOST_SELECT_BY_SIZE_MAX_CASE) \
/**/
#include BOOST_PP_LOCAL_ITERATE()
#undef BOOST_PP_LOCAL_MACRO
#undef SELECT_BY_SIZE_MAX_SPECIALIZED
#define SELECT_BY_SIZE_MAX_SPECIALIZED BOOST_SELECT_BY_SIZE_MAX_CASE
#endif

33
boost/boost/iostreams/detail/streambuf.hpp Normal file
View File

@ -0,0 +1,33 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_STREAMBUF_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_STREAMBUF_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/iostreams/detail/config/wide_streams.hpp>
#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
# include <streambuf>
#else
# include <streambuf.h>
#endif
#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
# define BOOST_IOSTREAMS_BASIC_STREAMBUF(ch, tr) std::basic_streambuf< ch, tr >
# define BOOST_IOSTREAMS_PUBSYNC pubsync
# define BOOST_IOSTREAMS_PUBSEEKOFF pubseekoff
# define BOOST_IOSTREAMS_PUBSEEKPOS pubseekpos
#else
# define BOOST_IOSTREAMS_BASIC_STREAMBUF(ch, tr) std::streambuf
# define BOOST_IOSTREAMS_PUBSYNC sync
# define BOOST_IOSTREAMS_PUBSEEKOFF seekoff
# define BOOST_IOSTREAMS_PUBSEEKPOS seekpos
#endif
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_STREAMBUF_HPP_INCLUDED

115
boost/boost/iostreams/detail/streambuf/chainbuf.hpp Normal file
View File

@ -0,0 +1,115 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_CHAINBUF_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_CHAINBUF_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // BOOST_MSVC, template friends.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/chain.hpp>
#include <boost/iostreams/detail/access_control.hpp>
#include <boost/iostreams/detail/config/wide_streams.hpp>
#include <boost/iostreams/detail/streambuf.hpp>
#include <boost/iostreams/detail/streambuf/linked_streambuf.hpp>
#include <boost/iostreams/detail/translate_int_type.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/noncopyable.hpp>
namespace boost { namespace iostreams { namespace detail {
//--------------Definition of chainbuf----------------------------------------//
//
// Template name: chainbuf.
// Description: Stream buffer which operates by delegating to the first
// linked_streambuf in a chain.
// Template paramters:
// Chain - The chain type.
//
template<typename Chain, typename Mode, typename Access>
class chainbuf
: public BOOST_IOSTREAMS_BASIC_STREAMBUF(
typename Chain::char_type,
typename Chain::traits_type
),
public access_control<typename Chain::client_type, Access>,
private noncopyable
{
private:
typedef access_control<chain_client<Chain>, Access> client_type;
public:
typedef typename Chain::char_type char_type;
BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(typename Chain::traits_type)
protected:
typedef linked_streambuf<char_type, traits_type> delegate_type;
chainbuf() { client_type::set_chain(&chain_); }
int_type underflow()
{ sentry t(this); return translate(delegate().underflow()); }
int_type pbackfail(int_type c)
{ sentry t(this); return translate(delegate().pbackfail(c)); }
std::streamsize xsgetn(char_type* s, std::streamsize n)
{ sentry t(this); return delegate().xsgetn(s, n); }
int_type overflow(int_type c)
{ sentry t(this); return translate(delegate().overflow(c)); }
std::streamsize xsputn(const char_type* s, std::streamsize n)
{ sentry t(this); return delegate().xsputn(s, n); }
int sync() { sentry t(this); return delegate().sync(); }
pos_type seekoff( off_type off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which =
BOOST_IOS::in | BOOST_IOS::out )
{ sentry t(this); return delegate().seekoff(off, way, which); }
pos_type seekpos( pos_type sp,
BOOST_IOS::openmode which =
BOOST_IOS::in | BOOST_IOS::out )
{ sentry t(this); return delegate().seekpos(sp, which); }
protected:
typedef BOOST_IOSTREAMS_BASIC_STREAMBUF(
typename Chain::char_type,
typename Chain::traits_type
) base_type;
//#if !BOOST_WORKAROUND(__GNUC__, == 2)
// BOOST_IOSTREAMS_USING_PROTECTED_STREAMBUF_MEMBERS(base_type)
//#endif
private:
// Translate from std int_type to chain's int_type.
typedef BOOST_IOSTREAMS_CHAR_TRAITS(char_type) std_traits;
typedef typename Chain::traits_type chain_traits;
static typename chain_traits::int_type
translate(typename std_traits::int_type c)
{ return translate_int_type<std_traits, chain_traits>(c); }
delegate_type& delegate()
{ return static_cast<delegate_type&>(chain_.front()); }
void get_pointers()
{
this->setg(delegate().eback(), delegate().gptr(), delegate().egptr());
this->setp(delegate().pbase(), delegate().epptr());
this->pbump((int) (delegate().pptr() - delegate().pbase()));
}
void set_pointers()
{
delegate().setg(this->eback(), this->gptr(), this->egptr());
delegate().setp(this->pbase(), this->epptr());
delegate().pbump((int) (this->pptr() - this->pbase()));
}
struct sentry {
sentry(chainbuf<Chain, Mode, Access>* buf) : buf_(buf)
{ buf_->set_pointers(); }
~sentry() { buf_->get_pointers(); }
chainbuf<Chain, Mode, Access>* buf_;
};
friend struct sentry;
Chain chain_;
};
} } } // End namespaces detail, iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_CHAINBUF_HPP_INCLUDED

305
boost/boost/iostreams/detail/streambuf/direct_streambuf.hpp Normal file
View File

@ -0,0 +1,305 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_DIRECT_STREAMBUF_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_DIRECT_STREAMBUF_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <cassert>
#include <cstddef>
#include <typeinfo>
#include <utility> // pair.
#include <boost/config.hpp> // BOOST_DEDUCED_TYPENAME.
#include <boost/iostreams/detail/char_traits.hpp>
#include <boost/iostreams/detail/config/wide_streams.hpp>
#include <boost/iostreams/detail/ios.hpp>
#include <boost/iostreams/detail/optional.hpp>
#include <boost/iostreams/detail/streambuf.hpp>
#include <boost/iostreams/detail/streambuf/linked_streambuf.hpp>
#include <boost/iostreams/detail/error.hpp>
#include <boost/iostreams/operations.hpp>
#include <boost/iostreams/positioning.hpp>
#include <boost/iostreams/traits.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC.
namespace boost { namespace iostreams {
namespace detail {
template< typename T,
typename Tr =
BOOST_IOSTREAMS_CHAR_TRAITS(
BOOST_DEDUCED_TYPENAME char_type_of<T>::type
) >
class direct_streambuf
: public linked_streambuf<BOOST_DEDUCED_TYPENAME char_type_of<T>::type, Tr>
{
public:
typedef typename char_type_of<T>::type char_type;
BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)
private:
typedef linked_streambuf<char_type, traits_type> base_type;
typedef typename category_of<T>::type category;
typedef BOOST_IOSTREAMS_BASIC_STREAMBUF(
char_type, traits_type
) streambuf_type;
public: // stream needs access.
void open(const T& t, int buffer_size, int pback_size);
bool is_open() const;
void close();
bool auto_close() const { return auto_close_; }
void set_auto_close(bool close) { auto_close_ = close; }
bool strict_sync() { return true; }
// Declared in linked_streambuf.
T* component() { return storage_.get(); }
protected:
#if !BOOST_WORKAROUND(__GNUC__, == 2)
BOOST_IOSTREAMS_USING_PROTECTED_STREAMBUF_MEMBERS(base_type)
#endif
direct_streambuf();
//--------------Virtual functions-----------------------------------------//
// Declared in linked_streambuf.
void close(BOOST_IOS::openmode m);
const std::type_info& component_type() const { return typeid(T); }
void* component_impl() { return component(); }
#ifdef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
public:
#endif
// Declared in basic_streambuf.
int_type underflow();
int_type pbackfail(int_type c);
int_type overflow(int_type c);
pos_type seekoff( off_type off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which );
pos_type seekpos(pos_type sp, BOOST_IOS::openmode which);
private:
pos_type seek_impl( stream_offset off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which );
void init_input(any_tag) { }
void init_input(input);
void init_output(any_tag) { }
void init_output(output);
void init_get_area();
void init_put_area();
bool one_head() const;
bool two_head() const;
optional<T> storage_;
char_type *ibeg_, *iend_, *obeg_, *oend_;
bool auto_close_;
};
//------------------Implementation of direct_streambuf------------------------//
template<typename T, typename Tr>
direct_streambuf<T, Tr>::direct_streambuf()
: ibeg_(0), iend_(0), obeg_(0), oend_(0), auto_close_(true)
{ this->set_true_eof(true); }
template<typename T, typename Tr>
void direct_streambuf<T, Tr>::open(const T& t, int, int)
{
storage_.reset(t);
init_input(category());
init_output(category());
setg(0, 0, 0);
setp(0, 0);
}
template<typename T, typename Tr>
bool direct_streambuf<T, Tr>::is_open() const
{ return ibeg_ != 0 && !obeg_ != 0; }
template<typename T, typename Tr>
void direct_streambuf<T, Tr>::close()
{
using namespace std;
try { close(BOOST_IOS::in); } catch (std::exception&) { }
try { close(BOOST_IOS::out); } catch (std::exception&) { }
storage_.reset();
}
template<typename T, typename Tr>
typename direct_streambuf<T, Tr>::int_type
direct_streambuf<T, Tr>::underflow()
{
if (!ibeg_)
throw cant_read();
if (!gptr())
init_get_area();
return gptr() != iend_ ?
traits_type::to_int_type(*gptr()) :
traits_type::eof();
}
template<typename T, typename Tr>
typename direct_streambuf<T, Tr>::int_type
direct_streambuf<T, Tr>::pbackfail(int_type c)
{
using namespace std;
if (!ibeg_)
throw cant_read();
if (gptr() != 0 && gptr() != ibeg_) {
gbump(-1);
if (!traits_type::eq_int_type(c, traits_type::eof()))
*gptr() = traits_type::to_char_type(c);
return traits_type::not_eof(c);
}
throw bad_putback();
}
template<typename T, typename Tr>
typename direct_streambuf<T, Tr>::int_type
direct_streambuf<T, Tr>::overflow(int_type c)
{
using namespace std;
if (!obeg_) throw BOOST_IOSTREAMS_FAILURE("no write access");
if (!pptr()) init_put_area();
if (!traits_type::eq_int_type(c, traits_type::eof())) {
if (pptr() == oend_)
throw BOOST_IOSTREAMS_FAILURE("write area exhausted");
*pptr() = traits_type::to_char_type(c);
pbump(1);
return c;
}
return traits_type::not_eof(c);
}
template<typename T, typename Tr>
inline typename direct_streambuf<T, Tr>::pos_type
direct_streambuf<T, Tr>::seekoff
(off_type off, BOOST_IOS::seekdir way, BOOST_IOS::openmode which)
{ return seek_impl(off, way, which); }
template<typename T, typename Tr>
inline typename direct_streambuf<T, Tr>::pos_type
direct_streambuf<T, Tr>::seekpos
(pos_type sp, BOOST_IOS::openmode)
{
return seek_impl( position_to_offset(sp), BOOST_IOS::beg,
BOOST_IOS::in | BOOST_IOS::out );
}
template<typename T, typename Tr>
void direct_streambuf<T, Tr>::close(BOOST_IOS::openmode which)
{
if (which == BOOST_IOS::in && ibeg_ != 0) {
setg(0, 0, 0);
ibeg_ = iend_ = 0;
}
if (which == BOOST_IOS::out && obeg_ != 0) {
sync();
setp(0, 0);
obeg_ = oend_ = 0;
}
boost::iostreams::close(*storage_, which);
}
template<typename T, typename Tr>
typename direct_streambuf<T, Tr>::pos_type direct_streambuf<T, Tr>::seek_impl
(stream_offset off, BOOST_IOS::seekdir way, BOOST_IOS::openmode which)
{
using namespace std;
BOOST_IOS::openmode both = BOOST_IOS::in | BOOST_IOS::out;
if (two_head() && (which & both) == both)
throw bad_seek();
stream_offset result = -1;
bool one = one_head();
if (one && (pptr() != 0 || gptr()== 0))
init_get_area(); // Switch to input mode, for code reuse.
if (one || (which & BOOST_IOS::in) != 0 && ibeg_ != 0) {
if (!gptr()) setg(ibeg_, ibeg_, iend_);
ptrdiff_t next = 0;
switch (way) {
case BOOST_IOS::beg: next = off; break;
case BOOST_IOS::cur: next = (gptr() - ibeg_) + off; break;
case BOOST_IOS::end: next = (iend_ - ibeg_) + off; break;
default: assert(0);
}
if (next < 0 || next > (iend_ - ibeg_))
throw bad_seek();
setg(ibeg_, ibeg_ + next, iend_);
result = next;
}
if (!one && (which & BOOST_IOS::out) != 0 && obeg_ != 0) {
if (!pptr()) setp(obeg_, oend_);
ptrdiff_t next = 0;
switch (way) {
case BOOST_IOS::beg: next = off; break;
case BOOST_IOS::cur: next = (pptr() - obeg_) + off; break;
case BOOST_IOS::end: next = (oend_ - obeg_) + off; break;
default: assert(0);
}
if (next < 0 || next > (oend_ - obeg_))
throw bad_seek();
pbump(static_cast<int>(next - (pptr() - obeg_)));
result = next;
}
return offset_to_position(result);
}
template<typename T, typename Tr>
void direct_streambuf<T, Tr>::init_input(input)
{
std::pair<char_type*, char_type*> p = input_sequence(*storage_);
ibeg_ = p.first;
iend_ = p.second;
}
template<typename T, typename Tr>
void direct_streambuf<T, Tr>::init_output(output)
{
std::pair<char_type*, char_type*> p = output_sequence(*storage_);
obeg_ = p.first;
oend_ = p.second;
}
template<typename T, typename Tr>
void direct_streambuf<T, Tr>::init_get_area()
{
setg(ibeg_, ibeg_, iend_);
if (one_head() && pptr()) {
gbump(static_cast<int>(pptr() - obeg_));
setp(0, 0);
}
}
template<typename T, typename Tr>
void direct_streambuf<T, Tr>::init_put_area()
{
setp(obeg_, oend_);
if (one_head() && gptr()) {
pbump(static_cast<int>(gptr() - ibeg_));
setg(0, 0, 0);
}
}
template<typename T, typename Tr>
inline bool direct_streambuf<T, Tr>::one_head() const
{ return ibeg_ && obeg_ && ibeg_ == obeg_; }
template<typename T, typename Tr>
inline bool direct_streambuf<T, Tr>::two_head() const
{ return ibeg_ && obeg_ && ibeg_ != obeg_; }
//----------------------------------------------------------------------------//
} // End namespace detail.
} } // End namespaces iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_DIRECT_STREAMBUF_HPP_INCLUDED

423
boost/boost/iostreams/detail/streambuf/indirect_streambuf.hpp Normal file
View File

@ -0,0 +1,423 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// This material is heavily indebted to the discussion and code samples in
// A. Langer and K. Kreft, "Standard C++ IOStreams and Locales",
// Addison-Wesley, 2000, pp. 228-43.
#ifndef BOOST_IOSTREAMS_DETAIL_INDIRECT_STREAMBUF_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_INDIRECT_STREAMBUF_HPP_INCLUDED
#include <algorithm> // min, max.
#include <cassert>
#include <exception>
#include <typeinfo>
#include <boost/config.hpp> // Member template friends.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/constants.hpp>
#include <boost/iostreams/detail/adapter/concept_adapter.hpp>
#include <boost/iostreams/detail/buffer.hpp>
#include <boost/iostreams/detail/config/wide_streams.hpp>
#include <boost/iostreams/detail/double_object.hpp>
#include <boost/iostreams/detail/ios.hpp>
#include <boost/iostreams/detail/optional.hpp>
#include <boost/iostreams/detail/push.hpp>
#include <boost/iostreams/detail/streambuf/linked_streambuf.hpp>
#include <boost/iostreams/operations.hpp>
#include <boost/iostreams/positioning.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/iostreams/operations.hpp>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_convertible.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC, BCC 5.x
namespace boost { namespace iostreams { namespace detail {
//
// Description: The implementation of basic_streambuf used by chains.
//
template<typename T, typename Tr, typename Alloc, typename Mode>
class indirect_streambuf
: public linked_streambuf<BOOST_DEDUCED_TYPENAME char_type_of<T>::type, Tr>
{
public:
typedef typename char_type_of<T>::type char_type;
BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)
private:
typedef typename category_of<T>::type category;
typedef concept_adapter<T> wrapper;
typedef detail::basic_buffer<char_type, Alloc> buffer_type;
typedef indirect_streambuf<T, Tr, Alloc, Mode> my_type;
typedef detail::linked_streambuf<char_type, traits_type> base_type;
typedef linked_streambuf<char_type, Tr> streambuf_type;
public:
indirect_streambuf();
void open(const T& t BOOST_IOSTREAMS_PUSH_PARAMS());
bool is_open() const;
void close();
bool auto_close() const;
void set_auto_close(bool close);
bool strict_sync();
// Declared in linked_streambuf.
T* component() { return &*obj(); }
protected:
#if !BOOST_WORKAROUND(__GNUC__, == 2)
BOOST_IOSTREAMS_USING_PROTECTED_STREAMBUF_MEMBERS(base_type)
#endif
//----------virtual functions---------------------------------------------//
#ifndef BOOST_IOSTREAMS_NO_LOCALE
void imbue(const std::locale& loc);
#endif
#ifdef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
public:
#endif
int_type underflow();
int_type pbackfail(int_type c);
int_type overflow(int_type c);
int sync();
pos_type seekoff( off_type off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which );
pos_type seekpos(pos_type sp, BOOST_IOS::openmode which);
// Declared in linked_streambuf.
void set_next(streambuf_type* next);
void close(BOOST_IOS::openmode m);
const std::type_info& component_type() const { return typeid(T); }
void* component_impl() { return component(); }
private:
//----------Accessor functions--------------------------------------------//
wrapper& obj() { return *storage_; }
streambuf_type* next() const { return next_; }
buffer_type& in() { return buffer_.first(); }
buffer_type& out() { return buffer_.second(); }
bool can_read() const { return is_convertible<Mode, input>::value; }
bool can_write() const { return is_convertible<Mode, output>::value; }
bool output_buffered() const { return (flags_ & f_output_buffered) != 0; }
bool shared_buffer() const { return is_convertible<Mode, seekable>::value; }
void set_flags(int f) { flags_ = f; }
//----------State changing functions--------------------------------------//
virtual void init_get_area();
virtual void init_put_area();
//----------Utility function----------------------------------------------//
pos_type seek_impl( stream_offset off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which );
void sync_impl();
void close_impl(BOOST_IOS::openmode);
enum flag_type {
f_open = 1,
f_input_closed = f_open << 1,
f_output_closed = f_input_closed << 1,
f_output_buffered = f_output_closed << 1,
f_auto_close = f_output_buffered << 1
};
optional<wrapper> storage_;
streambuf_type* next_;
double_object<
buffer_type,
is_convertible<
Mode,
two_sequence
>
> buffer_;
std::streamsize pback_size_;
int flags_;
};
//--------------Implementation of indirect_streambuf--------------------------//
template<typename T, typename Tr, typename Alloc, typename Mode>
indirect_streambuf<T, Tr, Alloc, Mode>::indirect_streambuf()
: next_(0), pback_size_(0), flags_(f_auto_close) { }
//--------------Implementation of open, is_open and close---------------------//
template<typename T, typename Tr, typename Alloc, typename Mode>
void indirect_streambuf<T, Tr, Alloc, Mode>::open
(const T& t, int buffer_size, int pback_size)
{
using namespace std;
// Normalize buffer sizes.
buffer_size =
(buffer_size != -1) ?
buffer_size :
iostreams::optimal_buffer_size(t);
pback_size =
(pback_size != -1) ?
pback_size :
default_pback_buffer_size;
// Construct input buffer.
if (can_read()) {
pback_size_ = (std::max)(2, pback_size); // STLPort needs 2.
streamsize size =
pback_size_ +
( buffer_size ? buffer_size: 1 );
in().resize(size);
if (!shared_buffer())
init_get_area();
}
// Construct output buffer.
if (can_write() && !shared_buffer()) {
if (buffer_size != 0)
out().resize(buffer_size);
init_put_area();
}
storage_.reset(wrapper(t));
flags_ |= f_open;
if (can_write() && buffer_size > 1)
flags_ |= f_output_buffered;
this->set_true_eof(false);
}
template<typename T, typename Tr, typename Alloc, typename Mode>
inline bool indirect_streambuf<T, Tr, Alloc, Mode>::is_open() const
{ return (flags_ & f_open) != 0; }
template<typename T, typename Tr, typename Alloc, typename Mode>
void indirect_streambuf<T, Tr, Alloc, Mode>::close()
{
using namespace std;
try { close(BOOST_IOS::in); } catch (std::exception&) { }
try { close(BOOST_IOS::out); } catch (std::exception&) { }
storage_.reset();
flags_ = 0;
}
template<typename T, typename Tr, typename Alloc, typename Mode>
bool indirect_streambuf<T, Tr, Alloc, Mode>::auto_close() const
{ return (flags_ & f_auto_close) != 0; }
template<typename T, typename Tr, typename Alloc, typename Mode>
void indirect_streambuf<T, Tr, Alloc, Mode>::set_auto_close(bool close)
{ flags_ = (flags_ & ~f_auto_close) | (close ? f_auto_close : 0); }
//--------------Implementation virtual functions------------------------------//
#ifndef BOOST_IOSTREAMS_NO_LOCALE
template<typename T, typename Tr, typename Alloc, typename Mode>
void indirect_streambuf<T, Tr, Alloc, Mode>::imbue(const std::locale& loc)
{
if (is_open()) {
obj().imbue(loc);
if (next_)
next_->pubimbue(loc);
}
}
#endif
template<typename T, typename Tr, typename Alloc, typename Mode>
typename indirect_streambuf<T, Tr, Alloc, Mode>::int_type
indirect_streambuf<T, Tr, Alloc, Mode>::underflow()
{
using namespace std;
if (!gptr()) init_get_area();
buffer_type& buf = in();
if (gptr() < egptr()) return traits_type::to_int_type(*gptr());
// Fill putback buffer.
streamsize keep = (std::min)( static_cast<streamsize>(gptr() - eback()),
pback_size_ );
if (keep)
traits_type::move( buf.data() + (pback_size_ - keep),
gptr() - keep, keep );
// Set pointers to reasonable values in case read throws.
setg( buf.data() + pback_size_ - keep,
buf.data() + pback_size_,
buf.data() + pback_size_ );
// Read from source.
streamsize chars =
obj().read(buf.data() + pback_size_, buf.size() - pback_size_, next_);
if (chars == -1) {
this->set_true_eof(true);
chars = 0;
}
setg(eback(), gptr(), buf.data() + pback_size_ + chars);
return chars != 0 ?
traits_type::to_int_type(*gptr()) :
traits_type::eof();
}
template<typename T, typename Tr, typename Alloc, typename Mode>
typename indirect_streambuf<T, Tr, Alloc, Mode>::int_type
indirect_streambuf<T, Tr, Alloc, Mode>::pbackfail(int_type c)
{
if (gptr() != eback()) {
gbump(-1);
if (!traits_type::eq_int_type(c, traits_type::eof()))
*gptr() = traits_type::to_char_type(c);
return traits_type::not_eof(c);
} else {
throw bad_putback();
}
}
template<typename T, typename Tr, typename Alloc, typename Mode>
typename indirect_streambuf<T, Tr, Alloc, Mode>::int_type
indirect_streambuf<T, Tr, Alloc, Mode>::overflow(int_type c)
{
if ( output_buffered() && pptr() == 0 ||
shared_buffer() && gptr() != 0 )
{
init_put_area();
}
if (!traits_type::eq_int_type(c, traits_type::eof())) {
if (output_buffered()) {
if (pptr() == epptr()) {
sync_impl();
if (pptr() == epptr())
return traits_type::eof();
}
*pptr() = traits_type::to_char_type(c);
pbump(1);
} else {
char_type d = traits_type::to_char_type(c);
if (obj().write(&d, 1, next_) != 1)
return traits_type::eof();
}
}
return traits_type::not_eof(c);
}
template<typename T, typename Tr, typename Alloc, typename Mode>
int indirect_streambuf<T, Tr, Alloc, Mode>::sync()
{
try { // sync() is no-throw.
sync_impl();
obj().flush(next_);
return 0;
} catch (std::exception&) { return -1; }
}
template<typename T, typename Tr, typename Alloc, typename Mode>
bool indirect_streambuf<T, Tr, Alloc, Mode>::strict_sync()
{
try { // sync() is no-throw.
sync_impl();
return obj().flush(next_);
} catch (std::exception&) { return false; }
}
template<typename T, typename Tr, typename Alloc, typename Mode>
inline typename indirect_streambuf<T, Tr, Alloc, Mode>::pos_type
indirect_streambuf<T, Tr, Alloc, Mode>::seekoff
(off_type off, BOOST_IOS::seekdir way, BOOST_IOS::openmode which)
{ return seek_impl(off, way, which); }
template<typename T, typename Tr, typename Alloc, typename Mode>
inline typename indirect_streambuf<T, Tr, Alloc, Mode>::pos_type
indirect_streambuf<T, Tr, Alloc, Mode>::seekpos
(pos_type sp, BOOST_IOS::openmode)
{
return seek_impl( position_to_offset(sp), BOOST_IOS::beg,
BOOST_IOS::in | BOOST_IOS::out );
}
template<typename T, typename Tr, typename Alloc, typename Mode>
typename indirect_streambuf<T, Tr, Alloc, Mode>::pos_type
indirect_streambuf<T, Tr, Alloc, Mode>::seek_impl
(stream_offset off, BOOST_IOS::seekdir way, BOOST_IOS::openmode which)
{
if (pptr() != 0)
this->BOOST_IOSTREAMS_PUBSYNC(); // sync() confuses VisualAge 6.
if (way == BOOST_IOS::cur && gptr())
off -= static_cast<off_type>(egptr() - gptr());
setg(0, 0, 0);
setp(0, 0);
return obj().seek(off, way, which, next_);
}
template<typename T, typename Tr, typename Alloc, typename Mode>
inline void indirect_streambuf<T, Tr, Alloc, Mode>::set_next
(streambuf_type* next)
{ next_ = next; }
template<typename T, typename Tr, typename Alloc, typename Mode>
inline void indirect_streambuf<T, Tr, Alloc, Mode>::close
(BOOST_IOS::openmode which)
{
close_impl(which);
try { obj().close(which, next_); } catch (std::exception&) { }
}
//----------State changing functions------------------------------------------//
template<typename T, typename Tr, typename Alloc, typename Mode>
inline void indirect_streambuf<T, Tr, Alloc, Mode>::close_impl
(BOOST_IOS::openmode which)
{
if (which == BOOST_IOS::in && (flags_ & f_input_closed) == 0) {
setg(0, 0, 0);
flags_ |= f_input_closed;
}
if (which == BOOST_IOS::out && (flags_ & f_output_closed) == 0) {
sync();
setp(0, 0);
flags_ |= f_output_closed;
}
}
template<typename T, typename Tr, typename Alloc, typename Mode>
void indirect_streambuf<T, Tr, Alloc, Mode>::sync_impl()
{
std::streamsize avail, amt;
if ((avail = static_cast<std::streamsize>(pptr() - pbase())) > 0) {
if ((amt = obj().write(pbase(), avail, next())) == avail)
setp(out().begin(), out().end());
else {
const char_type* ptr = pptr();
setp(out().begin() + amt, out().end());
pbump(ptr - pptr());
}
}
}
template<typename T, typename Tr, typename Alloc, typename Mode>
void indirect_streambuf<T, Tr, Alloc, Mode>::init_get_area()
{
if (shared_buffer() && pptr() != 0) {
sync_impl();
setp(0, 0);
}
setg(in().begin(), in().begin(), in().begin());
}
template<typename T, typename Tr, typename Alloc, typename Mode>
void indirect_streambuf<T, Tr, Alloc, Mode>::init_put_area()
{
using namespace std;
if (shared_buffer() && gptr() != 0)
setg(0, 0, 0);
if (output_buffered())
setp(out().begin(), out().end());
else
setp(0, 0);
}
//----------------------------------------------------------------------------//
} } } // End namespaces detail, iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC, BCC 5.x
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_INDIRECT_STREAMBUF_HPP_INCLUDED

80
boost/boost/iostreams/detail/streambuf/linked_streambuf.hpp Normal file
View File

@ -0,0 +1,80 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_LINKED_STREAMBUF_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_LINKED_STREAMBUF_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <typeinfo>
#include <boost/config.hpp> // member template friends.
#include <boost/iostreams/detail/char_traits.hpp>
#include <boost/iostreams/detail/ios.hpp> // openmode.
#include <boost/iostreams/detail/streambuf.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC.
namespace boost { namespace iostreams { namespace detail {
template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
class chain_base;
template<typename Chain, typename Access, typename Mode> class chainbuf;
#define BOOST_IOSTREAMS_USING_PROTECTED_STREAMBUF_MEMBERS(base) \
using base::eback; using base::gptr; using base::egptr; \
using base::setg; using base::gbump; using base::pbase; \
using base::pptr; using base::epptr; using base::setp; \
using base::pbump; using base::underflow; using base::pbackfail; \
using base::xsgetn; using base::overflow; using base::sputc; \
using base::xsputn; using base::sync; using base::seekoff; \
using base::seekpos; \
/**/
template<typename Ch, typename Tr = BOOST_IOSTREAMS_CHAR_TRAITS(Ch) >
class linked_streambuf : public BOOST_IOSTREAMS_BASIC_STREAMBUF(Ch, Tr) {
protected:
linked_streambuf() : true_eof_(false) { }
void set_true_eof(bool eof) { true_eof_ = eof; }
public:
// Should be called only after receiving an ordinary EOF indication,
// to confirm that it represents EOF rather than WOULD_BLOCK.
bool true_eof() const { return true_eof_; }
protected:
//----------grant friendship to chain_base and chainbuf-------------------//
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
template< typename Self, typename ChT, typename TrT,
typename Alloc, typename Mode >
friend class chain_base;
template<typename Chain, typename Mode, typename Access>
friend class chainbuf;
#else
public:
typedef BOOST_IOSTREAMS_BASIC_STREAMBUF(Ch, Tr) base;
BOOST_IOSTREAMS_USING_PROTECTED_STREAMBUF_MEMBERS(base)
#endif
virtual void set_next(linked_streambuf<Ch, Tr>* /* next */) { }
virtual void close(BOOST_IOS::openmode) = 0;
virtual bool auto_close() const = 0;
virtual void set_auto_close(bool) = 0;
virtual bool strict_sync() = 0;
virtual const std::type_info& component_type() const = 0;
virtual void* component_impl() = 0;
private:
bool true_eof_;
};
} } } // End namespaces detail, iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_LINKED_STREAMBUF_HPP_INCLUDED

25
boost/boost/iostreams/detail/template_params.hpp Normal file
View File

@ -0,0 +1,25 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_TEMPLATE_PARAMS_HPP_INCLUDED
#include <boost/preprocessor/control/expr_if.hpp>
#include <boost/preprocessor/control/if.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#define BOOST_IOSTREAMS_TEMPLATE_PARAMS(arity, param) \
BOOST_PP_EXPR_IF(arity, template<) \
BOOST_PP_ENUM_PARAMS(arity, typename param) \
BOOST_PP_EXPR_IF(arity, >) \
/**/
#define BOOST_IOSTREAMS_TEMPLATE_ARGS(arity, param) \
BOOST_PP_EXPR_IF(arity, <) \
BOOST_PP_ENUM_PARAMS(arity, param) \
BOOST_PP_EXPR_IF(arity, >) \
/**/
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_BUFFERS_HPP_INCLUDED

61
boost/boost/iostreams/detail/translate_int_type.hpp Normal file
View File

@ -0,0 +1,61 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_TRANSLATE_INT_TYPE_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_TRANSLATE_INT_TYPE_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/type_traits/is_same.hpp>
namespace boost { namespace iostreams { namespace detail {
template<bool IsSame>
struct translate_int_type_impl;
//
// Template name: translate_char.
// Description: Translates a character or an end-of-file indicator from the
// int_type of one character traits type to the int_type of another.
//
template<typename SourceTr, typename TargetTr>
typename TargetTr::int_type
translate_int_type(typename SourceTr::int_type c)
{
typedef translate_int_type_impl<is_same<SourceTr, TargetTr>::value> impl;
return impl::template inner<SourceTr, TargetTr>::translate(c);
}
//----------------------------------------------------------------------------//
template<>
struct translate_int_type_impl<true> {
template<typename SourceTr, typename TargetTr>
struct inner {
static typename TargetTr::int_type
translate(typename SourceTr::int_type c) { return c; }
};
};
template<>
struct translate_int_type_impl<false> {
template<typename SourceTr, typename TargetTr>
struct inner {
static typename TargetTr::int_type
translate(typename SourceTr::int_type c)
{
return SourceTr::eq_int_type(SourceTr::eof()) ?
TargetTr::eof() :
TargetTr::to_int_type(SourceTr::to_char_type(c));
}
};
};
} } } // End namespaces detail, iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_TRANSLATE_INT_TYPE_HPP_INCLUDED

126
boost/boost/iostreams/detail/wrap_unwrap.hpp Normal file
View File

@ -0,0 +1,126 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_WRAP_UNWRAP_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_WRAP_UNWRAP_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // SFINAE, MSVC.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/detail/enable_if_stream.hpp>
#include <boost/iostreams/traits_fwd.hpp> // is_std_io.
#include <boost/mpl/bool.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/if.hpp>
#include <boost/ref.hpp>
namespace boost { namespace iostreams { namespace detail {
//------------------Definition of wrap/unwrap traits--------------------------//
template<typename T>
struct wrapped_type
: mpl::if_<is_std_io<T>, reference_wrapper<T>, T>
{ };
template<typename T>
struct unwrapped_type
: unwrap_reference<T>
{ };
template<typename T>
struct unwrap_ios
: mpl::eval_if<
is_std_io<T>,
unwrap_reference<T>,
mpl::identity<T>
>
{ };
//------------------Definition of wrap----------------------------------------//
#ifndef BOOST_NO_SFINAE //----------------------------------------------------//
template<typename T>
inline T wrap(const T& t BOOST_IOSTREAMS_DISABLE_IF_STREAM(T))
{ return t; }
template<typename T>
inline typename wrapped_type<T>::type
wrap(T& t BOOST_IOSTREAMS_ENABLE_IF_STREAM(T)) { return boost::ref(t); }
#else // #ifndef BOOST_NO_SFINAE //-------------------------------------------//
template<typename T>
inline typename wrapped_type<T>::type // BCC 5.x needs namespace qualification.
wrap_impl(const T& t, mpl::true_) { return boost::ref(const_cast<T&>(t)); }
template<typename T>
inline typename wrapped_type<T>::type // BCC 5.x needs namespace qualification.
wrap_impl(T& t, mpl::true_) { return boost::ref(t); }
template<typename T>
inline typename wrapped_type<T>::type
wrap_impl(const T& t, mpl::false_) { return t; }
template<typename T>
inline typename wrapped_type<T>::type
wrap_impl(T& t, mpl::false_) { return t; }
template<typename T>
inline typename wrapped_type<T>::type
wrap(const T& t) { return wrap_impl(t, is_std_io<T>()); }
template<typename T>
inline typename wrapped_type<T>::type
wrap(T& t) { return wrap_impl(t, is_std_io<T>()); }
#endif // #ifndef BOOST_NO_SFINAE //------------------------------------------//
//------------------Definition of unwrap--------------------------------------//
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1310) //----------------------------------//
template<typename T>
typename unwrapped_type<T>::type&
unwrap(const reference_wrapper<T>& ref) { return ref.get(); }
template<typename T>
typename unwrapped_type<T>::type& unwrap(T& t) { return t; }
template<typename T>
const typename unwrapped_type<T>::type& unwrap(const T& t) { return t; }
#else // #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310) //-------------------------//
// Since unwrap is a potential bottleneck, we avoid runtime tag dispatch.
template<bool IsRefWrap>
struct unwrap_impl;
template<>
struct unwrap_impl<true> {
template<typename T>
static typename unwrapped_type<T>::type& unwrap(const T& t)
{ return t.get(); }
};
template<>
struct unwrap_impl<false> {
template<typename T>
static typename unwrapped_type<T>::type& unwrap(const T& t)
{ return const_cast<T&>(t); }
};
template<typename T>
typename unwrapped_type<T>::type&
unwrap(const T& t)
{ return unwrap_impl<is_reference_wrapper<T>::value>::unwrap(t); }
#endif // #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310) //------------------------//
} } } // End namespaces detail, iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_WRAP_UNWRAP_HPP_INCLUDED

143
boost/boost/iostreams/device/array.hpp Normal file
View File

@ -0,0 +1,143 @@
// (C) Copyright Jonathan Turkanis 2004.
// 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_ARRAY_HPP_INCLUDED
#define BOOST_IOSTREAMS_ARRAY_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // BOOST_MSVC, make sure size_t is in std.
#include <boost/detail/workaround.hpp>
#include <cstddef> // std::size_t.
#include <utility> // pair.
#include <boost/iostreams/categories.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_same.hpp>
namespace boost { namespace iostreams {
namespace detail {
template<typename Mode, typename Ch>
class array_adapter {
public:
typedef Ch char_type;
typedef std::pair<char_type*, char_type*> pair_type;
struct category
: public Mode,
public device_tag,
public direct_tag
{ };
array_adapter(char_type* begin, char_type* end);
array_adapter(char_type* begin, std::size_t length);
array_adapter(const char_type* begin, const char_type* end);
array_adapter(const char_type* begin, std::size_t length);
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
template<int N>
array_adapter(char_type (&ar)[N])
: begin_(ar), end_(ar + N)
{ }
#endif
pair_type input_sequence();
pair_type output_sequence();
private:
char_type* begin_;
char_type* end_;
};
} // End namespace detail.
// Local macros, #undef'd below.
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
# define BOOST_IOSTREAMS_ARRAY_CTOR(name, ch) \
template<int N> \
BOOST_PP_CAT(basic_, name)(ch (&ar)[N]) \
: base_type(ar) { } \
/**/
#else
# define BOOST_IOSTREAMS_ARRAY_CTOR(name, ch)
#endif
#define BOOST_IOSTREAMS_ARRAY(name, mode) \
template<typename Ch> \
struct BOOST_PP_CAT(basic_, name) : detail::array_adapter<mode, Ch> { \
private: \
typedef detail::array_adapter<mode, Ch> base_type; \
public: \
typedef typename base_type::char_type char_type; \
typedef typename base_type::category category; \
BOOST_PP_CAT(basic_, name)(char_type* begin, char_type* end) \
: base_type(begin, end) { } \
BOOST_PP_CAT(basic_, name)(char_type* begin, std::size_t length) \
: base_type(begin, length) { } \
BOOST_PP_CAT(basic_, name)(const char_type* begin, const char_type* end) \
: base_type(begin, end) { } \
BOOST_PP_CAT(basic_, name)(const char_type* begin, std::size_t length) \
: base_type(begin, length) { } \
BOOST_IOSTREAMS_ARRAY_CTOR(name, Ch) \
}; \
typedef BOOST_PP_CAT(basic_, name)<char> name; \
typedef BOOST_PP_CAT(basic_, name)<wchar_t> BOOST_PP_CAT(w, name); \
/**/
BOOST_IOSTREAMS_ARRAY(array_source, input_seekable)
BOOST_IOSTREAMS_ARRAY(array_sink, output_seekable)
BOOST_IOSTREAMS_ARRAY(array, seekable)
#undef BOOST_IOSTREAMS_ARRAY_CTOR
#undef BOOST_IOSTREAMS_ARRAY
//------------------Implementation of array_adapter---------------------------//
namespace detail {
template<typename Mode, typename Ch>
array_adapter<Mode, Ch>::array_adapter
(char_type* begin, char_type* end)
: begin_(begin), end_(end)
{ }
template<typename Mode, typename Ch>
array_adapter<Mode, Ch>::array_adapter
(char_type* begin, std::size_t length)
: begin_(begin), end_(begin + length)
{ }
template<typename Mode, typename Ch>
array_adapter<Mode, Ch>::array_adapter
(const char_type* begin, const char_type* end)
: begin_(const_cast<char_type*>(begin)), // Treated as read-only.
end_(const_cast<char_type*>(end)) // Treated as read-only.
{ BOOST_STATIC_ASSERT((!is_convertible<Mode, output>::value)); }
template<typename Mode, typename Ch>
array_adapter<Mode, Ch>::array_adapter
(const char_type* begin, std::size_t length)
: begin_(const_cast<char_type*>(begin)), // Treated as read-only.
end_(const_cast<char_type*>(begin) + length) // Treated as read-only.
{ BOOST_STATIC_ASSERT((!is_convertible<Mode, output>::value)); }
template<typename Mode, typename Ch>
typename array_adapter<Mode, Ch>::pair_type
array_adapter<Mode, Ch>::input_sequence()
{ BOOST_STATIC_ASSERT((is_convertible<Mode, input>::value));
return pair_type(begin_, end_); }
template<typename Mode, typename Ch>
typename array_adapter<Mode, Ch>::pair_type
array_adapter<Mode, Ch>::output_sequence()
{ BOOST_STATIC_ASSERT((is_convertible<Mode, output>::value));
return pair_type(begin_, end_); }
} // End namespace detail.
//----------------------------------------------------------------------------//
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_ARRAY_HPP_INCLUDED

40
boost/boost/iostreams/device/back_inserter.hpp Normal file
View File

@ -0,0 +1,40 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_BACK_INSERTER_HPP_INCLUDED
#define BOOST_IOSTREAMS_BACK_INSERTER_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/iostreams/detail/ios.hpp> // streamsize.
#include <boost/iostreams/categories.hpp>
namespace boost { namespace iostreams {
template<typename Container>
class back_insert_device {
public:
typedef typename Container::value_type char_type;
typedef sink_tag category;
back_insert_device(Container& cnt) : container(&cnt) { }
std::streamsize write(const char_type* s, std::streamsize n)
{
container->insert(container->end(), s, s + n);
return n;
}
protected:
Container* container;
};
template<typename Container>
back_insert_device<Container> back_inserter(Container& cnt)
{ return back_insert_device<Container>(cnt); }
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_BACK_INSERTER_HPP_INCLUDED

182
boost/boost/iostreams/device/file.hpp Normal file
View File

@ -0,0 +1,182 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
//
// Contains wrappers for standard file buffers, together
// with convenience typedefs:
// - basic_file_source
// - basic_file_sink
// - basic_file
//
#ifndef BOOST_IOSTREAMS_FILE_HPP_INCLUDED
#define BOOST_IOSTREAMS_FILE_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/iostreams/detail/config/wide_streams.hpp>
#ifndef BOOST_IOSTREAMS_NO_LOCALE
# include <locale>
#endif
#include <string> // pathnames, char_traits.
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/detail/ios.hpp> // openmode, seekdir, int types.
#include <boost/iostreams/detail/fstream.hpp>
#include <boost/iostreams/operations.hpp> // seek.
#include <boost/shared_ptr.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC.
namespace boost { namespace iostreams {
template<typename Ch>
class basic_file {
public:
typedef Ch char_type;
struct category
: public seekable_device_tag,
public closable_tag,
public localizable_tag
{ };
basic_file( const std::string& path,
BOOST_IOS::openmode mode =
BOOST_IOS::in | BOOST_IOS::out,
BOOST_IOS::openmode base_mode =
BOOST_IOS::in | BOOST_IOS::out );
std::streamsize read(char_type* s, std::streamsize n);
std::streamsize write(const char_type* s, std::streamsize n);
std::streampos seek( stream_offset off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which =
BOOST_IOS::in | BOOST_IOS::out );
void open( const std::string& path,
BOOST_IOS::openmode mode =
BOOST_IOS::in | BOOST_IOS::out,
BOOST_IOS::openmode base_mode =
BOOST_IOS::in | BOOST_IOS::out );
bool is_open() const;
void close();
#ifndef BOOST_IOSTREAMS_NO_LOCALE
void imbue(const std::locale& loc) { pimpl_->file_.pubimbue(loc); }
#endif
private:
struct impl {
impl(const std::string& path, BOOST_IOS::openmode mode)
{ file_.open(path.c_str(), mode); }
~impl() { if (file_.is_open()) file_.close(); }
BOOST_IOSTREAMS_BASIC_FILEBUF(Ch) file_;
};
shared_ptr<impl> pimpl_;
};
typedef basic_file<char> file;
typedef basic_file<wchar_t> wfile;
template<typename Ch>
struct basic_file_source : private basic_file<Ch> {
typedef Ch char_type;
struct category
: input_seekable,
device_tag,
closable_tag
{ };
using basic_file<Ch>::read;
using basic_file<Ch>::seek;
using basic_file<Ch>::is_open;
using basic_file<Ch>::close;
basic_file_source( const std::string& path,
BOOST_IOS::openmode mode =
BOOST_IOS::in )
: basic_file<Ch>(path, mode & ~BOOST_IOS::out, BOOST_IOS::in)
{ }
void open( const std::string& path,
BOOST_IOS::openmode mode = BOOST_IOS::in )
{
basic_file<Ch>::open(path, mode & ~BOOST_IOS::out, BOOST_IOS::in);
}
};
typedef basic_file_source<char> file_source;
typedef basic_file_source<wchar_t> wfile_source;
template<typename Ch>
struct basic_file_sink : private basic_file<Ch> {
typedef Ch char_type;
struct category
: output_seekable,
device_tag,
closable_tag
{ };
using basic_file<Ch>::write;
using basic_file<Ch>::seek;
using basic_file<Ch>::is_open;
using basic_file<Ch>::close;
basic_file_sink( const std::string& path,
BOOST_IOS::openmode mode = BOOST_IOS::out )
: basic_file<Ch>(path, mode & ~BOOST_IOS::in, BOOST_IOS::out)
{ }
void open( const std::string& path,
BOOST_IOS::openmode mode = BOOST_IOS::out )
{
basic_file<Ch>::open(path, mode & ~BOOST_IOS::in, BOOST_IOS::out);
}
};
typedef basic_file_sink<char> file_sink;
typedef basic_file_sink<wchar_t> wfile_sink;
//------------------Implementation of basic_file------------------------------//
template<typename Ch>
basic_file<Ch>::basic_file
( const std::string& path, BOOST_IOS::openmode mode,
BOOST_IOS::openmode base_mode )
{
open(path, mode, base_mode);
}
template<typename Ch>
inline std::streamsize basic_file<Ch>::read
(char_type* s, std::streamsize n)
{
std::streamsize result = pimpl_->file_.sgetn(s, n);
return result != 0 ? result : -1;
}
template<typename Ch>
inline std::streamsize basic_file<Ch>::write
(const char_type* s, std::streamsize n)
{ return pimpl_->file_.sputn(s, n); }
template<typename Ch>
std::streampos basic_file<Ch>::seek
( stream_offset off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode )
{ return iostreams::seek(pimpl_->file_, off, way); }
template<typename Ch>
void basic_file<Ch>::open
( const std::string& path, BOOST_IOS::openmode mode,
BOOST_IOS::openmode base_mode )
{
pimpl_.reset(new impl(path, mode | base_mode));
}
template<typename Ch>
bool basic_file<Ch>::is_open() const { return pimpl_->file_.is_open(); }
template<typename Ch>
void basic_file<Ch>::close() { pimpl_->file_.close(); }
//----------------------------------------------------------------------------//
} } // End namespaces iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC
#endif // #ifndef BOOST_IOSTREAMS_FILE_HPP_INCLUDED

64
boost/boost/iostreams/device/null.hpp Normal file
View File

@ -0,0 +1,64 @@
// (C) Copyright Jonathan Turkanis 2004.
// 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.
// Inspired by Daryle Walker's nullbuf from his More I/O submission.
#ifndef BOOST_IOSTREAMS_NULL_HPP_INCLUDED
#define BOOST_IOSTREAMS_NULL_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/detail/ios.hpp> // openmode, streamsize.
#include <boost/iostreams/positioning.hpp>
namespace boost { namespace iostreams {
template<typename Ch, typename Mode>
class basic_null_device {
public:
typedef Ch char_type;
struct category
: public Mode,
public device_tag,
public closable_tag
{ };
std::streamsize read(Ch*, std::streamsize) { return 0; }
std::streamsize write(const Ch*, std::streamsize n) { return n; }
std::streampos seek( stream_offset, BOOST_IOS::seekdir,
BOOST_IOS::openmode =
BOOST_IOS::in | BOOST_IOS::out )
{ return -1; }
void close(BOOST_IOS::openmode = BOOST_IOS::in | BOOST_IOS::out) { }
};
template<typename Ch>
struct basic_null_source : private basic_null_device<Ch, input> {
typedef Ch char_type;
typedef source_tag category;
using basic_null_device<Ch, input>::read;
using basic_null_device<Ch, input>::close;
};
typedef basic_null_source<char> null_source;
typedef basic_null_source<wchar_t> wnull_source;
template<typename Ch>
struct basic_null_sink : private basic_null_device<Ch, output> {
typedef Ch char_type;
typedef sink_tag category;
using basic_null_device<Ch, output>::write;
using basic_null_device<Ch, output>::close;
};
typedef basic_null_sink<char> null_sink;
typedef basic_null_sink<wchar_t> wnull_sink;
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_NULL_HPP_INCLUDED

387
boost/boost/iostreams/filter/bzip2.hpp Normal file
View File

@ -0,0 +1,387 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Note: custom allocators are not supported on VC6, since that compiler
// had trouble finding the function zlib_base::do_init.
#ifndef BOOST_IOSTREAMS_BZIP2_HPP_INCLUDED
#define BOOST_IOSTREAMS_BZIP2_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <cassert>
#include <memory> // allocator.
#include <new> // bad_alloc.
#include <boost/config.hpp> // MSVC, STATIC_CONSTANT, DEDUCED_TYPENAME, DINKUM.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/constants.hpp> // buffer size.
#include <boost/iostreams/detail/config/auto_link.hpp>
#include <boost/iostreams/detail/config/bzip2.hpp>
#include <boost/iostreams/detail/config/dyn_link.hpp>
#include <boost/iostreams/detail/config/wide_streams.hpp>
#include <boost/iostreams/detail/ios.hpp> // failure, streamsize.
#include <boost/iostreams/filter/symmetric.hpp>
#include <boost/iostreams/pipeline.hpp>
#include <boost/type_traits/is_same.hpp>
// Must come last.
#ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable:4251 4231 4660)
#endif
#include <boost/config/abi_prefix.hpp>
// Temporary fix.
#undef small
namespace boost { namespace iostreams {
namespace bzip2 {
// Typedefs.
typedef void* (*alloc_func)(void*, int, int);
typedef void (*free_func)(void*, void*);
// Status codes
BOOST_IOSTREAMS_DECL extern const int ok;
BOOST_IOSTREAMS_DECL extern const int run_ok;
BOOST_IOSTREAMS_DECL extern const int flush_ok;
BOOST_IOSTREAMS_DECL extern const int finish_ok;
BOOST_IOSTREAMS_DECL extern const int stream_end;
BOOST_IOSTREAMS_DECL extern const int sequence_error;
BOOST_IOSTREAMS_DECL extern const int param_error;
BOOST_IOSTREAMS_DECL extern const int mem_error;
BOOST_IOSTREAMS_DECL extern const int data_error;
BOOST_IOSTREAMS_DECL extern const int data_error_magic;
BOOST_IOSTREAMS_DECL extern const int io_error;
BOOST_IOSTREAMS_DECL extern const int unexpected_eof;
BOOST_IOSTREAMS_DECL extern const int outbuff_full;
BOOST_IOSTREAMS_DECL extern const int config_error;
// Action codes
BOOST_IOSTREAMS_DECL extern const int finish;
BOOST_IOSTREAMS_DECL extern const int run;
// Default values
const int default_block_size = 9;
const int default_work_factor = 30;
const bool default_small = false;
} // End namespace bzip2.
//
// Class name: bzip2_params.
// Description: Encapsulates the parameters passed to deflateInit2
// to customize compression.
//
struct bzip2_params {
// Non-explicit constructor for compression.
bzip2_params( int block_size = bzip2::default_block_size,
int work_factor = bzip2::default_work_factor )
: block_size(block_size), work_factor(work_factor)
{ }
// Constructor for decompression.
bzip2_params(bool small)
: small(small), work_factor(0)
{ }
union {
int block_size; // For compression.
bool small; // For decompression.
};
int work_factor;
};
//
// Class name: bzip2_error.
// Description: Subclass of std::ios_base::failure thrown to indicate
// bzip2 errors other than out-of-memory conditions.
//
class BOOST_IOSTREAMS_DECL bzip2_error : public BOOST_IOSTREAMS_FAILURE {
public:
explicit bzip2_error(int error);
int error() const { return error_; }
static void check(int error);
private:
int error_;
};
namespace detail {
template<typename Alloc>
struct bzip2_allocator_traits {
#ifndef BOOST_NO_STD_ALLOCATOR
typedef typename Alloc::template rebind<char>::other type;
#else
typedef std::allocator<char> type;
#endif
};
template< typename Alloc,
typename Base = // VC6 workaround (C2516)
BOOST_DEDUCED_TYPENAME bzip2_allocator_traits<Alloc>::type >
struct bzip2_allocator : private Base {
private:
typedef typename Base::size_type size_type;
public:
BOOST_STATIC_CONSTANT(bool, custom =
(!is_same<std::allocator<char>, Base>::value));
typedef typename bzip2_allocator_traits<Alloc>::type allocator_type;
static void* allocate(void* self, int items, int size);
static void deallocate(void* self, void* address);
};
class BOOST_IOSTREAMS_DECL bzip2_base {
public:
typedef char char_type;
protected:
bzip2_base(const bzip2_params& params);
~bzip2_base();
bzip2_params& params() { return params_; }
bool& ready() { return ready_; }
template<typename Alloc>
void init( bool compress,
bzip2_allocator<Alloc>& alloc )
{
bool custom = bzip2_allocator<Alloc>::custom;
do_init( compress,
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
custom ? bzip2_allocator<Alloc>::allocate : 0,
custom ? bzip2_allocator<Alloc>::deallocate : 0,
#endif
custom ? &alloc : 0 );
}
void before( const char*& src_begin, const char* src_end,
char*& dest_begin, char* dest_end );
void after(const char*& src_begin, char*& dest_begin);
int compress(int action);
int decompress();
void end(bool compress);
private:
void do_init( bool compress,
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
bzip2::alloc_func,
bzip2::free_func,
#endif
void* derived );
bzip2_params params_;
void* stream_; // Actual type: bz_stream*.
bool ready_;
};
//
// Template name: bzip2_compressor_impl
// Description: Model of SymmetricFilter implementing compression by
// delegating to the libbzip2 function BZ_bzCompress.
//
template<typename Alloc = std::allocator<char> >
class bzip2_compressor_impl
: public bzip2_base,
#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
public
#endif
bzip2_allocator<Alloc>
{
public:
bzip2_compressor_impl(const bzip2_params&);
bool filter( const char*& src_begin, const char* src_end,
char*& dest_begin, char* dest_end, bool flush );
void close();
private:
void init();
};
//
// Template name: bzip2_compressor
// Description: Model of SymmetricFilter implementing decompression by
// delegating to the libbzip2 function BZ_bzDecompress.
//
template<typename Alloc = std::allocator<char> >
class bzip2_decompressor_impl
: public bzip2_base,
#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
public
#endif
bzip2_allocator<Alloc>
{
public:
bzip2_decompressor_impl(bool small = bzip2::default_small);
bool filter( const char*& begin_in, const char* end_in,
char*& begin_out, char* end_out, bool flush );
void close();
private:
void init();
bool eof_; // Guard to make sure filter() isn't called after it returns false.
};
} // End namespace detail.
//
// Template name: bzip2_compressor
// Description: Model of InputFilter and OutputFilter implementing
// compression using libbzip2.
//
template<typename Alloc = std::allocator<char> >
struct basic_bzip2_compressor
: symmetric_filter<detail::bzip2_compressor_impl<Alloc>, Alloc>
{
private:
typedef detail::bzip2_compressor_impl<Alloc> impl_type;
typedef symmetric_filter<impl_type, Alloc> base_type;
public:
typedef typename base_type::char_type char_type;
typedef typename base_type::category category;
basic_bzip2_compressor( const bzip2_params& = bzip2::default_block_size,
int buffer_size = default_device_buffer_size );
};
BOOST_IOSTREAMS_PIPABLE(basic_bzip2_compressor, 1)
typedef basic_bzip2_compressor<> bzip2_compressor;
//
// Template name: bzip2_decompressor
// Description: Model of InputFilter and OutputFilter implementing
// decompression using libbzip2.
//
template<typename Alloc = std::allocator<char> >
struct basic_bzip2_decompressor
: symmetric_filter<detail::bzip2_decompressor_impl<Alloc>, Alloc>
{
private:
typedef detail::bzip2_decompressor_impl<Alloc> impl_type;
typedef symmetric_filter<impl_type, Alloc> base_type;
public:
typedef typename base_type::char_type char_type;
typedef typename base_type::category category;
basic_bzip2_decompressor( bool small = bzip2::default_small,
int buffer_size = default_device_buffer_size );
};
BOOST_IOSTREAMS_PIPABLE(basic_bzip2_decompressor, 1)
typedef basic_bzip2_decompressor<> bzip2_decompressor;
//----------------------------------------------------------------------------//
//------------------Implementation of bzip2_allocator-------------------------//
namespace detail {
template<typename Alloc, typename Base>
void* bzip2_allocator<Alloc, Base>::allocate(void* self, int items, int size)
{
size_type len = items * size;
char* ptr =
static_cast<allocator_type*>(self)->allocate
(len + sizeof(size_type)
#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
, (char*)0
#endif
);
*reinterpret_cast<size_type*>(ptr) = len;
return ptr + sizeof(size_type);
}
template<typename Alloc, typename Base>
void bzip2_allocator<Alloc, Base>::deallocate(void* self, void* address)
{
char* ptr = reinterpret_cast<char*>(address) - sizeof(size_type);
size_type len = *reinterpret_cast<size_type*>(ptr) + sizeof(size_type);
static_cast<allocator_type*>(self)->deallocate(ptr, len);
}
//------------------Implementation of bzip2_compressor_impl-------------------//
template<typename Alloc>
bzip2_compressor_impl<Alloc>::bzip2_compressor_impl(const bzip2_params& p)
: bzip2_base(p) { }
template<typename Alloc>
bool bzip2_compressor_impl<Alloc>::filter
( const char*& src_begin, const char* src_end,
char*& dest_begin, char* dest_end, bool flush )
{
if (!ready()) init();
before(src_begin, src_end, dest_begin, dest_end);
int result = compress(flush ? bzip2::finish : bzip2::run);
after(src_begin, dest_begin);
bzip2_error::check(result);
return result != bzip2::stream_end;
}
template<typename Alloc>
void bzip2_compressor_impl<Alloc>::close()
{
end(true);
}
template<typename Alloc>
inline void bzip2_compressor_impl<Alloc>::init()
{ bzip2_base::init(true, static_cast<bzip2_allocator<Alloc>&>(*this)); }
//------------------Implementation of bzip2_decompressor_impl-----------------//
template<typename Alloc>
bzip2_decompressor_impl<Alloc>::bzip2_decompressor_impl(bool small)
: bzip2_base(bzip2_params(small)), eof_(false) { }
template<typename Alloc>
bool bzip2_decompressor_impl<Alloc>::filter
( const char*& src_begin, const char* src_end,
char*& dest_begin, char* dest_end, bool /* flush */ )
{
if (!ready())
init();
if (eof_)
return false;
before(src_begin, src_end, dest_begin, dest_end);
int result = decompress();
after(src_begin, dest_begin);
bzip2_error::check(result);
return !(eof_ = result == bzip2::stream_end);
}
template<typename Alloc>
void bzip2_decompressor_impl<Alloc>::close() { end(false); eof_ = false; }
template<typename Alloc>
inline void bzip2_decompressor_impl<Alloc>::init()
{ bzip2_base::init(false, static_cast<bzip2_allocator<Alloc>&>(*this)); }
} // End namespace detail.
//------------------Implementation of bzip2_decompressor----------------------//
template<typename Alloc>
basic_bzip2_compressor<Alloc>::basic_bzip2_compressor
(const bzip2_params& p, int buffer_size)
: base_type(buffer_size, p)
{ }
//------------------Implementation of bzip2_decompressor----------------------//
template<typename Alloc>
basic_bzip2_decompressor<Alloc>::basic_bzip2_decompressor
(bool small, int buffer_size)
: base_type(buffer_size, small)
{ }
//----------------------------------------------------------------------------//
} } // End namespaces iostreams, boost.
#include <boost/config/abi_suffix.hpp> // Pops abi_suffix.hpp pragmas.
#ifdef BOOST_MSVC
# pragma warning(pop)
#endif
#endif // #ifndef BOOST_IOSTREAMS_BZIP2_HPP_INCLUDED

594
boost/boost/iostreams/filter/gzip.hpp Normal file
View File

@ -0,0 +1,594 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Contains the definitions of the class templates gzip_compressor and
// gzip_decompressor for reading and writing files in the gzip file format
// (RFC 1952). Based in part on work of Jonathan de Halleux; see [...]
#ifndef BOOST_IOSTREAMS_GZIP_HPP_INCLUDED
#define BOOST_IOSTREAMS_GZIP_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // STATIC_CONSTANT, STDC_NAMESPACE,
// DINKUMWARE_STDLIB, __STL_CONFIG_H.
#include <algorithm> // min.
#include <cstdio> // EOF.
#include <cstddef> // size_t.
#include <ctime> // std::time_t.
#include <memory> // allocator.
#include <boost/config.hpp> // Put size_t in std.
#include <boost/detail/workaround.hpp>
#include <boost/cstdint.hpp> // uint8_t, uint32_t.
#include <boost/iostreams/constants.hpp> // buffer size.
#include <boost/iostreams/detail/adapter/non_blocking_adapter.hpp>
#include <boost/iostreams/detail/adapter/range_adapter.hpp>
#include <boost/iostreams/detail/char_traits.hpp>
#include <boost/iostreams/detail/ios.hpp> // failure.
#include <boost/iostreams/operations.hpp>
#include <boost/iostreams/device/back_inserter.hpp>
#include <boost/iostreams/filter/zlib.hpp>
#include <boost/iostreams/pipeline.hpp>
// Must come last.
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable: 4309) // Truncation of constant value.
#endif
#ifdef BOOST_NO_STDC_NAMESPACE
namespace std { using ::time_t; }
#endif
namespace boost { namespace iostreams {
namespace gzip {
using namespace boost::iostreams::zlib;
// Error codes used by gzip_error.
const int zlib_error = 1;
const int bad_crc = 2; // Recorded crc doesn't match data.
const int bad_length = 3; // Recorded length doesn't match data.
const int bad_header = 4; // Malformed header.
const int bad_footer = 5; // Malformed footer.
namespace magic {
// Magic numbers used by gzip header.
const int id1 = 0x1f;
const int id2 = 0x8b;
} // End namespace magic.
namespace method {
// Codes used for the 'CM' byte of the gzip header.
const int deflate = 8;
} // End namespace method.
namespace flags {
// Codes used for the 'FLG' byte of the gzip header.
const int text = 1;
const int header_crc = 2;
const int extra = 4;
const int name = 8;
const int comment = 16;
} // End namespace flags.
namespace extra_flags {
// Codes used for the 'XFL' byte of the gzip header.
const int best_compression = 2;
const int best_speed = 4;
} // End namespace extra_flags.
// Codes used for the 'OS' byte of the gzip header.
const int os_fat = 0;
const int os_amiga = 1;
const int os_vms = 2;
const int os_unix = 3;
const int os_vm_cms = 4;
const int os_atari = 5;
const int os_hpfs = 6;
const int os_macintosh = 7;
const int os_z_system = 8;
const int os_cp_m = 9;
const int os_tops_20 = 10;
const int os_ntfs = 11;
const int os_qdos = 12;
const int os_acorn = 13;
const int os_unknown = 255;
} // End namespace gzip.
//
// Class name: gzip_params.
// Description: Subclass of zlib_params with an additional field
// representing a file name.
//
struct gzip_params : zlib_params {
// Non-explicit constructor.
gzip_params( int level = gzip::default_compression,
int method = gzip::deflated,
int window_bits = gzip::default_window_bits,
int mem_level = gzip::default_mem_level,
int strategy = gzip::default_strategy,
std::string file_name = "",
std::string comment = "",
std::time_t mtime = 0 )
: zlib_params(level, method, window_bits, mem_level, strategy),
file_name(file_name), mtime(mtime)
{ }
std::string file_name;
std::string comment;
std::time_t mtime;
};
//
// Class name: gzip_error.
// Description: Subclass of std::ios_base::failure thrown to indicate
// zlib errors other than out-of-memory conditions.
//
class gzip_error : public BOOST_IOSTREAMS_FAILURE {
public:
explicit gzip_error(int error)
: BOOST_IOSTREAMS_FAILURE("gzip error"),
error_(error), zlib_error_code_(zlib::okay) { }
explicit gzip_error(const zlib_error& e)
: BOOST_IOSTREAMS_FAILURE("gzip error"),
error_(gzip::zlib_error), zlib_error_code_(e.error())
{ }
int error() const { return error_; }
int zlib_error_code() const { return zlib_error_code_; }
private:
int error_;
int zlib_error_code_;
};
//
// Template name: gzip_compressor
// Description: Model of OutputFilter implementing compression in the
// gzip format.
//
template<typename Alloc = std::allocator<char> >
class basic_gzip_compressor : basic_zlib_compressor<Alloc> {
private:
typedef basic_zlib_compressor<Alloc> base_type;
public:
typedef char char_type;
struct category
: dual_use,
filter_tag,
multichar_tag,
closable_tag
{ };
basic_gzip_compressor( const gzip_params& = gzip::default_compression,
int buffer_size = default_device_buffer_size );
template<typename Source>
std::streamsize read(Source& src, char_type* s, std::streamsize n)
{
using namespace std;
streamsize result = 0;
// Read header.
if (!(flags_ & f_header_done))
result += read_string(s, n, header_);
// Read body.
if (!(flags_ & f_body_done)) {
// Read from basic_zlib_filter.
streamsize amt = base_type::read(src, s + result, n - result);
if (amt != -1) {
result += amt;
if (amt < n - result) { // Double-check for EOF.
amt = base_type::read(src, s + result, n - result);
if (amt != -1)
result += amt;
}
}
if (amt == -1)
prepare_footer();
}
// Read footer.
if ((flags_ & f_body_done) != 0 && result < n)
result += read_string(s + result, n - result, footer_);
return result != 0 ? result : -1;
}
template<typename Sink>
std::streamsize write(Sink& snk, const char_type* s, std::streamsize n)
{
if (!(flags_ & f_header_done)) {
std::streamsize amt =
static_cast<std::streamsize>(header_.size() - offset_);
offset_ += boost::iostreams::write(snk, header_.data() + offset_, amt);
if (offset_ == header_.size())
flags_ |= f_header_done;
else
return 0;
}
return base_type::write(snk, s, n);
}
template<typename Sink>
void close(Sink& snk, BOOST_IOS::openmode m)
{
namespace io = boost::iostreams;
if (m & BOOST_IOS::out) {
// Close zlib compressor.
base_type::close(snk, BOOST_IOS::out);
if (flags_ & f_header_done) {
// Write final fields of gzip file format.
write_long(this->crc(), snk);
write_long(this->total_in(), snk);
}
}
#if BOOST_WORKAROUND(__GNUC__, == 2) && defined(__STL_CONFIG_H) || \
BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) \
/**/
footer_.erase(0, std::string::npos);
#else
footer_.clear();
#endif
offset_ = 0;
flags_ = 0;
}
private:
static gzip_params normalize_params(gzip_params p);
void prepare_footer();
std::streamsize read_string(char* s, std::streamsize n, std::string& str);
template<typename Sink>
static void write_long(long n, Sink& next)
{
boost::iostreams::put(next, static_cast<char>(0xFF & n));
boost::iostreams::put(next, static_cast<char>(0xFF & (n >> 8)));
boost::iostreams::put(next, static_cast<char>(0xFF & (n >> 16)));
boost::iostreams::put(next, static_cast<char>(0xFF & (n >> 24)));
}
enum flag_type {
f_header_done = 1,
f_body_done = f_header_done << 1,
f_footer_done = f_body_done << 1
};
std::string header_;
std::string footer_;
std::size_t offset_;
int flags_;
};
BOOST_IOSTREAMS_PIPABLE(basic_gzip_compressor, 1)
typedef basic_gzip_compressor<> gzip_compressor;
//
// Template name: basic_gzip_decompressor
// Description: Model of InputFilter implementing compression in the
// gzip format.
//
template<typename Alloc = std::allocator<char> >
class basic_gzip_decompressor : basic_zlib_decompressor<Alloc> {
public:
typedef char char_type;
struct category
: multichar_input_filter_tag,
closable_tag
{ };
basic_gzip_decompressor( int window_bits = gzip::default_window_bits,
int buffer_size = default_device_buffer_size );
template<typename Source>
std::streamsize read(Source& src, char_type* s, std::streamsize n)
{
if ((flags_ & f_header_read) == 0) {
non_blocking_adapter<Source> nb(src);
read_header(nb);
flags_ |= f_header_read;
}
if ((flags_ & f_footer_read) != 0)
return -1;
try {
std::streamsize result = 0;
std::streamsize amt;
if ((amt = base_type::read(src, s, n)) != -1) {
result += amt;
if (amt < n) { // Double check for EOF.
amt = base_type::read(src, s + result, n - result);
if (amt != -1)
result += amt;
}
}
if (amt == -1) {
non_blocking_adapter<Source> nb(src);
read_footer(nb);
flags_ |= f_footer_read;
}
return result;
} catch (const zlib_error& e) {
throw gzip_error(e);
}
}
template<typename Source>
void close(Source& src)
{
try {
base_type::close(src, BOOST_IOS::in);
flags_ = 0;
} catch (const zlib_error& e) {
throw gzip_error(e);
}
}
std::string file_name() const { return file_name_; }
std::string comment() const { return comment_; }
bool text() const { return (flags_ & gzip::flags::text) != 0; }
int os() const { return os_; }
std::time_t mtime() const { return mtime_; }
private:
typedef basic_zlib_decompressor<Alloc> base_type;
typedef BOOST_IOSTREAMS_CHAR_TRAITS(char) traits_type;
static bool is_eof(int c) { return traits_type::eq_int_type(c, EOF); }
static gzip_params make_params(int window_bits);
template<typename Source>
static uint8_t read_uint8(Source& src, int error)
{
int c;
if ((c = boost::iostreams::get(src)) == EOF || c == WOULD_BLOCK)
throw gzip_error(error);
return static_cast<uint8_t>(traits_type::to_char_type(c));
}
template<typename Source>
static uint32_t read_uint32(Source& src, int error)
{
uint8_t b1 = read_uint8(src, error);
uint8_t b2 = read_uint8(src, error);
uint8_t b3 = read_uint8(src, error);
uint8_t b4 = read_uint8(src, error);
return b1 + (b2 << 8) + (b3 << 16) + (b4 << 24);
}
template<typename Source>
std::string read_string(Source& src)
{
std::string result;
while (true) {
int c;
if (is_eof(c = boost::iostreams::get(src)))
throw gzip_error(gzip::bad_header);
else if (c == 0)
return result;
else
result += static_cast<char>(c);
}
}
template<typename Source>
void read_header(Source& src) // Source is non-blocking.
{
// Reset saved values.
#if BOOST_WORKAROUND(__GNUC__, == 2) && defined(__STL_CONFIG_H) || \
BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) \
/**/
file_name_.erase(0, std::string::npos);
comment_.erase(0, std::string::npos);
#else
file_name_.clear();
comment_.clear();
#endif
os_ = gzip::os_unknown;
mtime_ = 0;
int flags;
// Read header, without checking header crc.
if ( boost::iostreams::get(src) != gzip::magic::id1 || // ID1.
boost::iostreams::get(src) != gzip::magic::id2 || // ID2.
is_eof(boost::iostreams::get(src)) || // CM.
is_eof(flags = boost::iostreams::get(src)) ) // FLG.
{
throw gzip_error(gzip::bad_header);
}
mtime_ = read_uint32(src, gzip::bad_header); // MTIME.
read_uint8(src, gzip::bad_header); // XFL.
os_ = read_uint8(src, gzip::bad_header); // OS.
if (flags & boost::iostreams::gzip::flags::text)
flags_ |= f_text;
// Skip extra field. (From J. Halleaux; see note at top.)
if (flags & gzip::flags::extra) {
int length =
static_cast<int>(
read_uint8(src, gzip::bad_header) +
(read_uint8(src, gzip::bad_header) << 8)
);
// length is garbage if EOF but the loop below will quit anyway.
do { }
while (length-- != 0 && !is_eof(boost::iostreams::get(src)));
}
if (flags & gzip::flags::name) // Read file name.
file_name_ = read_string(src);
if (flags & gzip::flags::comment) // Read comment.
comment_ = read_string(src);
if (flags & gzip::flags::header_crc) { // Skip header crc.
read_uint8(src, gzip::bad_header);
read_uint8(src, gzip::bad_header);
}
}
template<typename Source>
void read_footer(Source& src)
{
typename base_type::string_type footer =
this->unconsumed_input();
int c;
while (!is_eof(c = boost::iostreams::get(src)))
footer += c;
detail::range_adapter<input, std::string>
rng(footer.begin(), footer.end());
if (read_uint32(rng, gzip::bad_footer) != this->crc())
throw gzip_error(gzip::bad_crc);
if (static_cast<int>(read_uint32(rng, gzip::bad_footer)) != this->total_out())
throw gzip_error(gzip::bad_length);
}
enum flag_type {
f_header_read = 1,
f_footer_read = f_header_read << 1,
f_text = f_footer_read << 1
};
std::string file_name_;
std::string comment_;
int os_;
std::time_t mtime_;
int flags_;
};
BOOST_IOSTREAMS_PIPABLE(basic_gzip_decompressor, 1)
typedef basic_gzip_decompressor<> gzip_decompressor;
//------------------Implementation of gzip_compressor-------------------------//
template<typename Alloc>
basic_gzip_compressor<Alloc>::basic_gzip_compressor
(const gzip_params& p, int buffer_size)
: base_type(normalize_params(p), buffer_size),
offset_(0), flags_(0)
{
// Calculate gzip header.
bool has_name = !p.file_name.empty();
bool has_comment = !p.comment.empty();
std::string::size_type length =
10 +
(has_name ? p.file_name.size() + 1 : 0) +
(has_comment ? p.comment.size() + 1 : 0);
// + 2; // Header crc confuses gunzip.
int flags =
//gzip::flags::header_crc +
(has_name ? gzip::flags::name : 0) +
(has_comment ? gzip::flags::comment : 0);
int extra_flags =
( p.level == zlib::best_compression ?
gzip::extra_flags::best_compression :
0 ) +
( p.level == zlib::best_speed ?
gzip::extra_flags::best_speed :
0 );
header_.reserve(length);
header_ += gzip::magic::id1; // ID1.
header_ += gzip::magic::id2; // ID2.
header_ += gzip::method::deflate; // CM.
header_ += static_cast<char>(flags); // FLG.
header_ += static_cast<char>(0xFF & p.mtime); // MTIME.
header_ += static_cast<char>(0xFF & (p.mtime >> 8));
header_ += static_cast<char>(0xFF & (p.mtime >> 16));
header_ += static_cast<char>(0xFF & (p.mtime >> 24));
header_ += static_cast<char>(extra_flags); // XFL.
header_ += static_cast<char>(gzip::os_unknown); // OS.
if (has_name) {
header_ += p.file_name;
header_ += '\0';
}
if (has_comment) {
header_ += p.comment;
header_ += '\0';
}
}
template<typename Alloc>
gzip_params basic_gzip_compressor<Alloc>::normalize_params(gzip_params p)
{
p.noheader = true;
p.calculate_crc = true;
return p;
}
template<typename Alloc>
void basic_gzip_compressor<Alloc>::prepare_footer()
{
boost::iostreams::back_insert_device<std::string> out(footer_);
write_long(this->crc(), out);
write_long(this->total_in(), out);
flags_ |= f_body_done;
offset_ = 0;
}
template<typename Alloc>
std::streamsize basic_gzip_compressor<Alloc>::read_string
(char* s, std::streamsize n, std::string& str)
{
using namespace std;
streamsize avail =
static_cast<streamsize>(str.size() - offset_);
streamsize amt = (std::min)(avail, n);
std::copy( str.data() + offset_,
str.data() + offset_ + amt,
s );
offset_ += amt;
if ( !(flags_ & f_header_done) &&
offset_ == static_cast<std::size_t>(str.size()) )
{
flags_ |= f_header_done;
}
return amt;
}
//------------------Implementation of gzip_decompressor-----------------------//
template<typename Alloc>
basic_gzip_decompressor<Alloc>::basic_gzip_decompressor
(int window_bits, int buffer_size)
: base_type(make_params(window_bits), buffer_size),
os_(gzip::os_unknown), mtime_(0), flags_(0)
{ }
template<typename Alloc>
gzip_params basic_gzip_decompressor<Alloc>::make_params(int window_bits)
{
gzip_params p;
p.window_bits = window_bits;
p.noheader = true;
p.calculate_crc = true;
return p;
}
//----------------------------------------------------------------------------//
} } // End namespaces iostreams, boost.
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
#endif // #ifndef BOOST_IOSTREAMS_GZIP_HPP_INCLUDED

302
boost/boost/iostreams/filter/symmetric.hpp Normal file
View File

@ -0,0 +1,302 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Contains the definitions of the class templates symmetric_filter,
// which models DualUseFilter based on a model of the Symmetric Filter.
//
// Roughly, a Symmetric Filter is a class type with the following interface:
//
// struct symmetric_filter {
// typedef xxx char_type;
//
// bool filter( const char*& begin_in, const char* end_in,
// char*& begin_out, char* end_out, bool flush )
// {
// // Consume as many characters as possible from the interval
// // [begin_in, end_in), without exhausting the output range
// // [begin_out, end_out). If flush is true, write as mush output
// // as possible.
// // A return value of true indicates that filter should be called
// // again. More precisely, if flush is false, a return value of
// // false indicates that the natural end of stream has been reached
// // and that all filtered data has been forwarded; if flush is
// // true, a return value of false indicates that all filtered data
// // has been forwarded.
// }
// void close() { /* Reset filter's state. */ }
// };
//
// Symmetric Filter filters need not be CopyConstructable.
//
#ifndef BOOST_IOSTREAMS_SYMMETRIC_FILTER_HPP_INCLUDED
#define BOOST_IOSTREAMS_SYMMETRIC_FILTER_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <cassert>
#include <memory> // allocator, auto_ptr.
#include <boost/config.hpp> // BOOST_DEDUCED_TYPENAME.
#include <boost/iostreams/char_traits.hpp>
#include <boost/iostreams/constants.hpp> // buffer size.
#include <boost/iostreams/detail/buffer.hpp>
#include <boost/iostreams/detail/char_traits.hpp>
#include <boost/iostreams/detail/closer.hpp>
#include <boost/iostreams/detail/config/limits.hpp>
#include <boost/iostreams/detail/template_params.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/iostreams/operations.hpp> // read, write.
#include <boost/iostreams/pipeline.hpp>
#include <boost/preprocessor/iteration/local.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/shared_ptr.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC.
namespace boost { namespace iostreams {
template< typename SymmetricFilter,
typename Alloc =
std::allocator<
BOOST_DEDUCED_TYPENAME char_type_of<SymmetricFilter>::type
> >
class symmetric_filter {
public:
typedef typename char_type_of<SymmetricFilter>::type char_type;
typedef std::basic_string<char_type> string_type;
struct category
: dual_use,
filter_tag,
multichar_tag,
closable_tag
{ };
// Expands to a sequence of ctors which forward to impl.
#define BOOST_PP_LOCAL_MACRO(n) \
BOOST_IOSTREAMS_TEMPLATE_PARAMS(n, T) \
explicit symmetric_filter( \
int buffer_size BOOST_PP_COMMA_IF(n) \
BOOST_PP_ENUM_BINARY_PARAMS(n, const T, &t) ) \
: pimpl_(new impl(buffer_size BOOST_PP_COMMA_IF(n) \
BOOST_PP_ENUM_PARAMS(n, t))) \
{ } \
/**/
#define BOOST_PP_LOCAL_LIMITS (0, BOOST_IOSTREAMS_MAX_FORWARDING_ARITY)
#include BOOST_PP_LOCAL_ITERATE()
#undef BOOST_PP_LOCAL_MACRO
template<typename Source>
std::streamsize read(Source& src, char_type* s, std::streamsize n)
{
using namespace std;
if (!(state() & f_read))
begin_read();
buffer_type& buf = pimpl_->buf_;
int status = (state() & f_eof) != 0 ? f_eof : f_good;
char_type *next_s = s,
*end_s = s + n;
while (true)
{
// Invoke filter if there are unconsumed characters in buffer or if
// filter must be flushed.
bool flush = status == f_eof;
if (buf.ptr() != buf.eptr() || flush) {
const char_type* next = buf.ptr();
bool done =
!filter().filter(next, buf.eptr(), next_s, end_s, flush);
buf.ptr() = buf.data() + (next - buf.data());
if (done)
return detail::check_eof(static_cast<streamsize>(next_s - s));
}
// If no more characters are available without blocking, or
// if read request has been satisfied, return.
if ( status == f_would_block && buf.ptr() == buf.eptr() ||
next_s == end_s )
{
return static_cast<streamsize>(next_s - s);
}
// Fill buffer.
if (status == f_good)
status = fill(src);
}
}
template<typename Sink>
std::streamsize write(Sink& snk, const char_type* s, std::streamsize n)
{
if (!(state() & f_write))
begin_write();
buffer_type& buf = pimpl_->buf_;
const char_type *next_s, *end_s;
for (next_s = s, end_s = s + n; next_s != end_s; ) {
if (buf.ptr() == buf.eptr() && !flush(snk))
break;
filter().filter(next_s, end_s, buf.ptr(), buf.eptr(), false);
}
return static_cast<std::streamsize>(next_s - s);
}
// Give detail::closer<> permission to call close().
typedef symmetric_filter<SymmetricFilter, Alloc> self;
friend struct detail::closer<self>;
template<typename Sink>
void close(Sink& snk, BOOST_IOS::openmode which)
{
using namespace std;
if ((state() & f_read) && (which & BOOST_IOS::in))
close();
if ((state() & f_write) && (which & BOOST_IOS::out)) {
// Repeatedly invoke filter() with no input.
detail::closer<self> closer(*this);
buffer_type& buf = pimpl_->buf_;
char dummy;
const char* end = &dummy;
bool again = true;
while (again) {
if (buf.ptr() != buf.eptr())
again = filter().filter(end, end, buf.ptr(), buf.eptr(), true);
flush(snk);
}
}
}
SymmetricFilter& filter() { return *pimpl_; }
string_type unconsumed_input() const;
// Give impl access to buffer_type on Tru64
#if !BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
private:
#endif
typedef detail::buffer<char_type, Alloc> buffer_type;
private:
buffer_type& buf() { return pimpl_->buf_; }
const buffer_type& buf() const { return pimpl_->buf_; }
int& state() { return pimpl_->state_; }
void begin_read();
void begin_write();
template<typename Source>
int fill(Source& src)
{
std::streamsize amt = iostreams::read(src, buf().data(), buf().size());
if (amt == -1) {
state() |= f_eof;
return f_eof;
}
buf().set(0, amt);
return amt == buf().size() ? f_good : f_would_block;
}
// Attempts to write the contents of the buffer the given Sink.
// Returns true if at least on character was written.
template<typename Sink>
bool flush(Sink& snk)
{
typedef typename iostreams::category_of<Sink>::type category;
typedef is_convertible<category, output> can_write;
return flush(snk, can_write());
}
template<typename Sink>
bool flush(Sink& snk, mpl::true_)
{
using std::streamsize;
typedef char_traits<char_type> traits_type;
streamsize amt =
static_cast<streamsize>(buf().ptr() - buf().data());
streamsize result =
boost::iostreams::write(snk, buf().data(), amt);
if (result < amt && result > 0)
traits_type::move(buf().data(), buf().data() + result, amt - result);
buf().set(amt - result, buf().size());
return result != 0;
}
template<typename Sink>
bool flush(Sink& snk, mpl::false_) { return true;}
void close();
enum flag_type {
f_read = 1,
f_write = f_read << 1,
f_eof = f_write << 1,
f_good,
f_would_block
};
struct impl : SymmetricFilter {
// Expands to a sequence of ctors which forward to SymmetricFilter.
#define BOOST_PP_LOCAL_MACRO(n) \
BOOST_IOSTREAMS_TEMPLATE_PARAMS(n, T) \
impl( int buffer_size BOOST_PP_COMMA_IF(n) \
BOOST_PP_ENUM_BINARY_PARAMS(n, const T, &t) ) \
: SymmetricFilter(BOOST_PP_ENUM_PARAMS(n, t)), \
buf_(buffer_size), state_(0) \
{ } \
/**/
#define BOOST_PP_LOCAL_LIMITS (0, BOOST_IOSTREAMS_MAX_FORWARDING_ARITY)
#include BOOST_PP_LOCAL_ITERATE()
#undef BOOST_PP_LOCAL_MACRO
buffer_type buf_;
int state_;
};
shared_ptr<impl> pimpl_;
};
BOOST_IOSTREAMS_PIPABLE(symmetric_filter, 2)
//------------------Implementation of symmetric_filter----------------//
template<typename SymmetricFilter, typename Alloc>
void symmetric_filter<SymmetricFilter, Alloc>::begin_read()
{
assert(!(state() & f_write));
state() |= f_read;
buf().set(0, 0);
}
template<typename SymmetricFilter, typename Alloc>
void symmetric_filter<SymmetricFilter, Alloc>::begin_write()
{
assert(!(state() & f_read));
state() |= f_write;
buf().set(0, buf().size());
}
template<typename SymmetricFilter, typename Alloc>
void symmetric_filter<SymmetricFilter, Alloc>::close()
{
state() = 0;
buf().set(0, 0);
filter().close();
}
template<typename SymmetricFilter, typename Alloc>
typename symmetric_filter<SymmetricFilter, Alloc>::string_type
symmetric_filter<SymmetricFilter, Alloc>::unconsumed_input() const
{ return string_type(buf().ptr(), buf().eptr()); }
//----------------------------------------------------------------------------//
} } // End namespaces iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC.
#endif // #ifndef BOOST_IOSTREAMS_SYMMETRIC_FILTER_HPP_INCLUDED

415
boost/boost/iostreams/filter/zlib.hpp Normal file
View File

@ -0,0 +1,415 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Note: custom allocators are not supported on VC6, since that compiler
// had trouble finding the function zlib_base::do_init.
#ifndef BOOST_IOSTREAMS_ZLIB_HPP_INCLUDED
#define BOOST_IOSTREAMS_ZLIB_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <cassert>
#include <iosfwd> // streamsize.
#include <memory> // allocator, bad_alloc.
#include <new>
#include <boost/config.hpp> // MSVC, STATIC_CONSTANT, DEDUCED_TYPENAME, DINKUM.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/constants.hpp> // buffer size.
#include <boost/iostreams/detail/config/auto_link.hpp>
#include <boost/iostreams/detail/config/dyn_link.hpp>
#include <boost/iostreams/detail/config/wide_streams.hpp>
#include <boost/iostreams/detail/config/zlib.hpp>
#include <boost/iostreams/detail/ios.hpp> // failure, streamsize.
#include <boost/iostreams/filter/symmetric.hpp>
#include <boost/iostreams/pipeline.hpp>
#include <boost/type_traits/is_same.hpp>
// Must come last.
#ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable:4251 4231 4660) // Dependencies not exported.
#endif
#include <boost/config/abi_prefix.hpp>
namespace boost { namespace iostreams {
namespace zlib {
// Typedefs
typedef unsigned int uint;
typedef unsigned char byte;
typedef unsigned long ulong;
typedef void* (*alloc_func)(void*, zlib::uint, zlib::uint);
typedef void (*free_func)(void*, void*);
// Compression levels
BOOST_IOSTREAMS_DECL extern const int no_compression;
BOOST_IOSTREAMS_DECL extern const int best_speed;
BOOST_IOSTREAMS_DECL extern const int best_compression;
BOOST_IOSTREAMS_DECL extern const int default_compression;
// Compression methods
BOOST_IOSTREAMS_DECL extern const int deflated;
// Compression strategies
BOOST_IOSTREAMS_DECL extern const int default_strategy;
BOOST_IOSTREAMS_DECL extern const int filtered;
BOOST_IOSTREAMS_DECL extern const int huffman_only;
// Status codes
BOOST_IOSTREAMS_DECL extern const int okay;
BOOST_IOSTREAMS_DECL extern const int stream_end;
BOOST_IOSTREAMS_DECL extern const int stream_error;
BOOST_IOSTREAMS_DECL extern const int version_error;
BOOST_IOSTREAMS_DECL extern const int data_error;
BOOST_IOSTREAMS_DECL extern const int mem_error;
BOOST_IOSTREAMS_DECL extern const int buf_error;
// Flush codes
BOOST_IOSTREAMS_DECL extern const int finish;
BOOST_IOSTREAMS_DECL extern const int no_flush;
BOOST_IOSTREAMS_DECL extern const int sync_flush;
// Code for current OS
//BOOST_IOSTREAMS_DECL extern const int os_code;
// Null pointer constant.
const int null = 0;
// Default values
const int default_window_bits = 15;
const int default_mem_level = 8;
const bool default_crc = false;
const bool default_noheader = false;
} // End namespace zlib.
//
// Class name: zlib_params.
// Description: Encapsulates the parameters passed to deflateInit2
// and inflateInit2 to customize compression and decompression.
//
struct zlib_params {
// Non-explicit constructor.
zlib_params( int level = zlib::default_compression,
int method = zlib::deflated,
int window_bits = zlib::default_window_bits,
int mem_level = zlib::default_mem_level,
int strategy = zlib::default_strategy,
bool noheader = zlib::default_noheader,
bool calculate_crc = zlib::default_crc )
: level(level), method(method), window_bits(window_bits),
mem_level(mem_level), strategy(strategy),
noheader(noheader), calculate_crc(calculate_crc)
{ }
int level;
int method;
int window_bits;
int mem_level;
int strategy;
bool noheader;
bool calculate_crc;
};
//
// Class name: zlib_error.
// Description: Subclass of std::ios::failure thrown to indicate
// zlib errors other than out-of-memory conditions.
//
class BOOST_IOSTREAMS_DECL zlib_error : public BOOST_IOSTREAMS_FAILURE {
public:
explicit zlib_error(int error);
int error() const { return error_; }
static void check(int error);
private:
int error_;
};
namespace detail {
template<typename Alloc>
struct zlib_allocator_traits {
#ifndef BOOST_NO_STD_ALLOCATOR
typedef typename Alloc::template rebind<char>::other type;
#else
typedef std::allocator<char> type;
#endif
};
template< typename Alloc,
typename Base = // VC6 workaround (C2516)
BOOST_DEDUCED_TYPENAME zlib_allocator_traits<Alloc>::type >
struct zlib_allocator : private Base {
private:
typedef typename Base::size_type size_type;
public:
BOOST_STATIC_CONSTANT(bool, custom =
(!is_same<std::allocator<char>, Base>::value));
typedef typename zlib_allocator_traits<Alloc>::type allocator_type;
static void* allocate(void* self, zlib::uint items, zlib::uint size);
static void deallocate(void* self, void* address);
};
class BOOST_IOSTREAMS_DECL zlib_base {
public:
typedef char char_type;
protected:
zlib_base();
~zlib_base();
void* stream() { return stream_; }
template<typename Alloc>
void init( const zlib_params& p,
bool compress,
zlib_allocator<Alloc>& zalloc )
{
bool custom = zlib_allocator<Alloc>::custom;
do_init( p, compress,
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
custom ? zlib_allocator<Alloc>::allocate : 0,
custom ? zlib_allocator<Alloc>::deallocate : 0,
#endif
&zalloc );
}
void before( const char*& src_begin, const char* src_end,
char*& dest_begin, char* dest_end );
void after( const char*& src_begin, char*& dest_begin,
bool compress );
int deflate(int flush);
int inflate(int flush);
void reset(bool compress, bool realloc);
public:
zlib::ulong crc() const { return crc_; }
int total_in() const { return total_in_; }
int total_out() const { return total_out_; }
private:
void do_init( const zlib_params& p, bool compress,
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
zlib::alloc_func,
zlib::free_func,
#endif
void* derived );
void* stream_; // Actual type: z_stream*.
bool calculate_crc_;
zlib::ulong crc_;
int total_in_;
int total_out_;
};
//
// Template name: zlib_compressor_impl
// Description: Model of C-Style Filte implementing compression by
// delegating to the zlib function deflate.
//
template<typename Alloc = std::allocator<char> >
class zlib_compressor_impl : public zlib_base, public zlib_allocator<Alloc> {
public:
zlib_compressor_impl(const zlib_params& = zlib::default_compression);
~zlib_compressor_impl();
bool filter( const char*& src_begin, const char* src_end,
char*& dest_begin, char* dest_end, bool flush );
void close();
};
//
// Template name: zlib_compressor
// Description: Model of C-Style Filte implementing decompression by
// delegating to the zlib function inflate.
//
template<typename Alloc = std::allocator<char> >
class zlib_decompressor_impl : public zlib_base, public zlib_allocator<Alloc> {
public:
zlib_decompressor_impl(const zlib_params&);
zlib_decompressor_impl(int window_bits = zlib::default_window_bits);
~zlib_decompressor_impl();
bool filter( const char*& begin_in, const char* end_in,
char*& begin_out, char* end_out, bool flush );
void close();
};
} // End namespace detail.
//
// Template name: zlib_compressor
// Description: Model of InputFilter and OutputFilter implementing
// compression using zlib.
//
template<typename Alloc = std::allocator<char> >
struct basic_zlib_compressor
: symmetric_filter<detail::zlib_compressor_impl<Alloc>, Alloc>
{
private:
typedef detail::zlib_compressor_impl<Alloc> impl_type;
typedef symmetric_filter<impl_type, Alloc> base_type;
public:
typedef typename base_type::char_type char_type;
typedef typename base_type::category category;
basic_zlib_compressor( const zlib_params& = zlib::default_compression,
int buffer_size = default_device_buffer_size );
zlib::ulong crc() { return this->filter().crc(); }
int total_in() { return this->filter().total_in(); }
};
BOOST_IOSTREAMS_PIPABLE(basic_zlib_compressor, 1)
typedef basic_zlib_compressor<> zlib_compressor;
//
// Template name: zlib_decompressor
// Description: Model of InputFilter and OutputFilter implementing
// decompression using zlib.
//
template<typename Alloc = std::allocator<char> >
struct basic_zlib_decompressor
: symmetric_filter<detail::zlib_decompressor_impl<Alloc>, Alloc>
{
private:
typedef detail::zlib_decompressor_impl<Alloc> impl_type;
typedef symmetric_filter<impl_type, Alloc> base_type;
public:
typedef typename base_type::char_type char_type;
typedef typename base_type::category category;
basic_zlib_decompressor( int window_bits = zlib::default_window_bits,
int buffer_size = default_device_buffer_size );
basic_zlib_decompressor( const zlib_params& p,
int buffer_size = default_device_buffer_size );
zlib::ulong crc() { return this->filter().crc(); }
int total_out() { return this->filter().total_out(); }
};
BOOST_IOSTREAMS_PIPABLE(basic_zlib_decompressor, 1)
typedef basic_zlib_decompressor<> zlib_decompressor;
//----------------------------------------------------------------------------//
//------------------Implementation of zlib_allocator--------------------------//
namespace detail {
template<typename Alloc, typename Base>
void* zlib_allocator<Alloc, Base>::allocate
(void* self, zlib::uint items, zlib::uint size)
{
size_type len = items * size;
char* ptr =
static_cast<allocator_type*>(self)->allocate
(len + sizeof(size_type)
#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
, (char*)0
#endif
);
*reinterpret_cast<size_type*>(ptr) = len;
return ptr + sizeof(size_type);
}
template<typename Alloc, typename Base>
void zlib_allocator<Alloc, Base>::deallocate(void* self, void* address)
{
char* ptr = reinterpret_cast<char*>(address) - sizeof(size_type);
size_type len = *reinterpret_cast<size_type*>(ptr) + sizeof(size_type);
static_cast<allocator_type*>(self)->deallocate(ptr, len);
}
//------------------Implementation of zlib_compressor_impl--------------------//
template<typename Alloc>
zlib_compressor_impl<Alloc>::zlib_compressor_impl(const zlib_params& p)
{ init(p, true, static_cast<zlib_allocator<Alloc>&>(*this)); }
template<typename Alloc>
zlib_compressor_impl<Alloc>::~zlib_compressor_impl()
{ reset(true, false); }
template<typename Alloc>
bool zlib_compressor_impl<Alloc>::filter
( const char*& src_begin, const char* src_end,
char*& dest_begin, char* dest_end, bool flush )
{
before(src_begin, src_end, dest_begin, dest_end);
int result = deflate(flush ? zlib::finish : zlib::no_flush);
after(src_begin, dest_begin, true);
zlib_error::check(result);
return result != zlib::stream_end;
}
template<typename Alloc>
void zlib_compressor_impl<Alloc>::close() { reset(true, true); }
//------------------Implementation of zlib_decompressor_impl------------------//
template<typename Alloc>
zlib_decompressor_impl<Alloc>::zlib_decompressor_impl(const zlib_params& p)
{ init(p, false, static_cast<zlib_allocator<Alloc>&>(*this)); }
template<typename Alloc>
zlib_decompressor_impl<Alloc>::~zlib_decompressor_impl()
{ reset(false, false); }
template<typename Alloc>
zlib_decompressor_impl<Alloc>::zlib_decompressor_impl(int window_bits)
{
zlib_params p;
p.window_bits = window_bits;
init(p, false, static_cast<zlib_allocator<Alloc>&>(*this));
}
template<typename Alloc>
bool zlib_decompressor_impl<Alloc>::filter
( const char*& src_begin, const char* src_end,
char*& dest_begin, char* dest_end, bool /* flush */ )
{
before(src_begin, src_end, dest_begin, dest_end);
int result = inflate(zlib::sync_flush);
after(src_begin, dest_begin, false);
zlib_error::check(result);
return result != zlib::stream_end;
}
template<typename Alloc>
void zlib_decompressor_impl<Alloc>::close() { reset(false, true); }
} // End namespace detail.
//------------------Implementation of zlib_decompressor-----------------------//
template<typename Alloc>
basic_zlib_compressor<Alloc>::basic_zlib_compressor
(const zlib_params& p, int buffer_size)
: base_type(buffer_size, p) { }
//------------------Implementation of zlib_decompressor-----------------------//
template<typename Alloc>
basic_zlib_decompressor<Alloc>::basic_zlib_decompressor
(int window_bits, int buffer_size)
: base_type(buffer_size, window_bits) { }
template<typename Alloc>
basic_zlib_decompressor<Alloc>::basic_zlib_decompressor
(const zlib_params& p, int buffer_size)
: base_type(buffer_size, p) { }
//----------------------------------------------------------------------------//
} } // End namespaces iostreams, boost.
#include <boost/config/abi_suffix.hpp> // Pops abi_suffix.hpp pragmas.
#ifdef BOOST_MSVC
# pragma warning(pop)
#endif
#endif // #ifndef BOOST_IOSTREAMS_ZLIB_HPP_INCLUDED

148
boost/boost/iostreams/filtering_stream.hpp Normal file
View File

@ -0,0 +1,148 @@
// (C) Copyright Jonathan Turkanis 2004
// 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_FILTER_STREAM_HPP_INCLUDED
#define BOOST_IOSTREAMS_FILTER_STREAM_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <memory> // allocator.
#include <boost/iostreams/detail/access_control.hpp>
#include <boost/iostreams/detail/char_traits.hpp>
#include <boost/iostreams/detail/iostream.hpp> // standard streams.
#include <boost/iostreams/detail/push.hpp>
#include <boost/iostreams/detail/select.hpp>
#include <boost/iostreams/detail/streambuf.hpp> // pubsync.
#include <boost/iostreams/filtering_streambuf.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_convertible.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC.
namespace boost { namespace iostreams {
//--------------Definition of filtered_istream--------------------------------//
namespace detail {
template<typename Mode, typename Ch, typename Tr>
struct filtering_stream_traits {
typedef typename
iostreams::select< // Disambiguation for Tru64
mpl::and_<
is_convertible<Mode, input>,
is_convertible<Mode, output>
>,
BOOST_IOSTREAMS_BASIC_IOSTREAM(Ch, Tr),
is_convertible<Mode, input>,
BOOST_IOSTREAMS_BASIC_ISTREAM(Ch, Tr),
else_,
BOOST_IOSTREAMS_BASIC_OSTREAM(Ch, Tr)
>::type type;
};
template<typename Chain, typename Access>
class filtering_stream_base
: public access_control<
boost::iostreams::detail::chain_client<Chain>,
Access
>,
public filtering_stream_traits<
typename Chain::mode,
typename Chain::char_type,
typename Chain::traits_type
>::type
{
public:
typedef Chain chain_type;
typedef access_control<
boost::iostreams::detail::chain_client<Chain>,
Access
> client_type;
protected:
typedef typename
filtering_stream_traits<
typename Chain::mode,
typename Chain::char_type,
typename Chain::traits_type
>::type stream_type;
filtering_stream_base() : stream_type(0) { this->set_chain(&chain_); }
private:
void notify() { this->rdbuf(chain_.empty() ? 0 : &chain_.front()); }
Chain chain_;
};
} // End namespace detail.
//
// Macro: BOOST_IOSTREAMS_DEFINE_FILTER_STREAM(name_, chain_type_, default_char_)
// Description: Defines a template derived from std::basic_streambuf which uses
// a chain to perform i/o. The template has the following parameters:
// Mode - the i/o mode.
// Ch - The character type.
// Tr - The character traits type.
// Alloc - The allocator type.
// Access - Indicates accessibility of the chain interface; must be either
// public_ or protected_; defaults to public_.
// Macro parameters:
// name_ - The name of the template to be defined.
// chain_type_ - The name of the chain template.
// default_char_ - The default value for the char template parameter.
//
#define BOOST_IOSTREAMS_DEFINE_FILTER_STREAM(name_, chain_type_, default_char_) \
template< typename Mode, \
typename Ch = default_char_, \
typename Tr = BOOST_IOSTREAMS_CHAR_TRAITS(Ch), \
typename Alloc = std::allocator<Ch>, \
typename Access = public_ > \
class name_ \
: public boost::iostreams::detail::filtering_stream_base< \
chain_type_<Mode, Ch, Tr, Alloc>, Access \
> \
{ \
public: \
typedef Ch char_type; \
BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr) \
typedef Mode mode; \
typedef chain_type_<Mode, Ch, Tr, Alloc> chain_type; \
name_() { } \
BOOST_IOSTREAMS_DEFINE_PUSH_CONSTRUCTOR(name_, mode, Ch, push_impl) \
~name_() { \
if (this->is_complete()) \
this->rdbuf()->BOOST_IOSTREAMS_PUBSYNC(); \
} \
private: \
typedef access_control< \
boost::iostreams::detail::chain_client< \
chain_type_<Mode, Ch, Tr, Alloc> \
>, \
Access \
> client_type; \
template<typename T> \
void push_impl(const T& t BOOST_IOSTREAMS_PUSH_PARAMS()) \
{ client_type::push(t BOOST_IOSTREAMS_PUSH_ARGS()); } \
}; \
/**/
BOOST_IOSTREAMS_DEFINE_FILTER_STREAM(filtering_stream, boost::iostreams::chain, char)
BOOST_IOSTREAMS_DEFINE_FILTER_STREAM(wfiltering_stream, boost::iostreams::chain, wchar_t)
typedef filtering_stream<input> filtering_istream;
typedef filtering_stream<output> filtering_ostream;
typedef wfiltering_stream<input> filtering_wistream;
typedef wfiltering_stream<output> filtering_wostream;
//----------------------------------------------------------------------------//
} } // End namespace iostreams, boost
#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC
#endif // #ifndef BOOST_IOSTREAMS_FILTER_STREAM_HPP_INCLUDED

64
boost/boost/iostreams/filtering_streambuf.hpp Normal file
View File

@ -0,0 +1,64 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_FILTERING_STREAMBUF_HPP_INCLUDED
#define BOOST_IOSTREAMS_FILTERING_STREAMBUF_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <exception>
#include <memory> // allocator.
#include <boost/iostreams/chain.hpp>
#include <boost/iostreams/detail/access_control.hpp>
#include <boost/iostreams/detail/char_traits.hpp>
#include <boost/iostreams/detail/push.hpp>
#include <boost/iostreams/detail/streambuf.hpp> // pubsync.
#include <boost/iostreams/detail/streambuf/chainbuf.hpp>
#include <boost/mpl/if.hpp>
namespace boost { namespace iostreams {
//
// Macro: BOOST_IOSTREAMS_DEFINE_FILTERBUF(name_, chain_type_, default_char_)
// Description: Defines a template derived from std::basic_streambuf which uses
// a chain to perform i/o. The template has the following parameters:
// Ch - The character type.
// Tr - The character traits type.
// Alloc - The allocator type.
// Access - Indicates accessibility of the chain interface; must be either
// public_ or protected_; defaults to public_.
//
#define BOOST_IOSTREAMS_DEFINE_FILTER_STREAMBUF(name_, chain_type_, default_char_) \
template< typename Mode, typename Ch = default_char_, \
typename Tr = BOOST_IOSTREAMS_CHAR_TRAITS(Ch), \
typename Alloc = std::allocator<Ch>, typename Access = public_ > \
class name_ : public boost::iostreams::detail::chainbuf< \
chain_type_<Mode, Ch, Tr, Alloc>, Mode, Access \
> \
{ \
public: \
typedef Ch char_type; \
BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr) \
typedef Mode mode; \
typedef chain_type_<Mode, Ch, Tr, Alloc> chain_type; \
name_() { } \
BOOST_IOSTREAMS_DEFINE_PUSH_CONSTRUCTOR(name_, mode, Ch, push_impl) \
~name_() { if (this->is_complete()) this->BOOST_IOSTREAMS_PUBSYNC(); } \
}; \
/**/
BOOST_IOSTREAMS_DEFINE_FILTER_STREAMBUF(filtering_streambuf, boost::iostreams::chain, char)
BOOST_IOSTREAMS_DEFINE_FILTER_STREAMBUF(filtering_wstreambuf, boost::iostreams::chain, wchar_t)
typedef filtering_streambuf<input> filtering_istreambuf;
typedef filtering_streambuf<output> filtering_ostreambuf;
typedef filtering_wstreambuf<input> filtering_wistreambuf;
typedef filtering_wstreambuf<output> filtering_wostreambuf;
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_FILTERING_STREAMBUF_HPP_INCLUDED

124
boost/boost/iostreams/flush.hpp Normal file
View File

@ -0,0 +1,124 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_FLUSH_HPP_INCLUDED
#define BOOST_IOSTREAMS_FLUSH_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // DEDUCED_TYPENAME, MSVC.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/detail/dispatch.hpp>
#include <boost/iostreams/detail/streambuf.hpp>
#include <boost/iostreams/detail/wrap_unwrap.hpp>
#include <boost/iostreams/operations_fwd.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/mpl/if.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp>
namespace boost { namespace iostreams {
namespace detail {
template<typename T>
struct flush_device_impl;
template<typename T>
struct flush_filter_impl;
} // End namespace detail.
template<typename T>
bool flush(T& t)
{ return detail::flush_device_impl<T>::flush(detail::unwrap(t)); }
template<typename T, typename Sink>
bool flush(T& t, Sink& snk)
{ return detail::flush_filter_impl<T>::flush(detail::unwrap(t), snk); }
namespace detail {
//------------------Definition of flush_device_impl---------------------------//
template<typename T>
struct flush_device_impl
: mpl::if_<
is_custom<T>,
operations<T>,
flush_device_impl<
BOOST_DEDUCED_TYPENAME
dispatch<
T, ostream_tag, streambuf_tag, flushable_tag, any_tag
>::type
>
>::type
{ };
template<>
struct flush_device_impl<ostream_tag> {
template<typename T>
static bool flush(T& t)
{ return t.rdbuf()->BOOST_IOSTREAMS_PUBSYNC() == 0; }
};
template<>
struct flush_device_impl<streambuf_tag> {
template<typename T>
static bool flush(T& t)
{ return t.BOOST_IOSTREAMS_PUBSYNC() == 0; }
};
template<>
struct flush_device_impl<flushable_tag> {
template<typename T>
static bool flush(T& t) { return t.flush(); }
};
template<>
struct flush_device_impl<any_tag> {
template<typename T>
static bool flush(T&) { return true; }
};
//------------------Definition of flush_filter_impl---------------------------//
template<typename T>
struct flush_filter_impl
: mpl::if_<
is_custom<T>,
operations<T>,
flush_filter_impl<
BOOST_DEDUCED_TYPENAME
dispatch<
T, flushable_tag, any_tag
>::type
>
>::type
{ };
template<>
struct flush_filter_impl<flushable_tag> {
template<typename T, typename Sink>
static bool flush(T& t, Sink& snk) { return t.flush(snk); }
};
template<>
struct flush_filter_impl<any_tag> {
template<typename T, typename Sink>
static bool flush(T&, Sink&) { return false; }
};
} // End namespace detail.
} } // End namespaces iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp>
#endif // #ifndef BOOST_IOSTREAMS_FLUSH_HPP_INCLUDED

16
boost/boost/iostreams/get.hpp Normal file
View File

@ -0,0 +1,16 @@
// (C) Copyright Jonathan Turkanis 2005.
// 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_GET_HPP_INCLUDED
#define BOOST_IOSTREAMS_GET_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/iostreams/read.hpp>
#endif // #ifndef BOOST_IOSTREAMS_GET_HPP_INCLUDED

81
boost/boost/iostreams/imbue.hpp Normal file
View File

@ -0,0 +1,81 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_IMBUE_HPP_INCLUDED
#define BOOST_IOSTREAMS_IMBUE_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // DEDUCED_TYPENAME, MSVC.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/detail/dispatch.hpp>
#include <boost/iostreams/detail/streambuf.hpp>
#include <boost/iostreams/detail/wrap_unwrap.hpp>
#include <boost/iostreams/operations_fwd.hpp>
#include <boost/mpl/if.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp>
namespace boost { namespace iostreams {
namespace detail {
// Implementation templates for simulated tag dispatch.
template<typename T>
struct imbue_impl;
} // End namespace detail.
template<typename T, typename Locale>
void imbue(T& t, const Locale& loc)
{ detail::imbue_impl<T>::imbue(detail::unwrap(t), loc); }
namespace detail {
//------------------Definition of imbue_impl----------------------------------//
template<typename T>
struct imbue_impl
: mpl::if_<
is_custom<T>,
operations<T>,
imbue_impl<
BOOST_DEDUCED_TYPENAME
dispatch<
T, streambuf_tag, localizable_tag, any_tag
>::type
>
>::type
{ };
template<>
struct imbue_impl<any_tag> {
template<typename T, typename Locale>
static void imbue(T&, const Locale&) { }
};
template<>
struct imbue_impl<streambuf_tag> {
template<typename T, typename Locale>
static void imbue(T& t, const Locale& loc) { t.pubimbue(loc); }
};
template<>
struct imbue_impl<localizable_tag> {
template<typename T, typename Locale>
static void imbue(T& t, const Locale& loc) { t.imbue(loc); }
};
} // End namespace detail.
} } // End namespaces iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp>
#endif // #ifndef BOOST_IOSTREAMS_IMBUE_HPP_INCLUDED

70
boost/boost/iostreams/input_sequence.hpp Normal file
View File

@ -0,0 +1,70 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_INPUT_SEQUENCE_HPP_INCLUDED
#define BOOST_IOSTREAMS_INPUT_SEQUENCE_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <utility> // pair.
#include <boost/config.hpp> // DEDUCED_TYPENAME, MSVC.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/detail/wrap_unwrap.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/mpl/if.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp>
namespace boost { namespace iostreams {
namespace detail {
template<typename T>
struct input_sequence_impl;
} // End namespace detail.
template<typename T>
inline std::pair<
BOOST_DEDUCED_TYPENAME char_type_of<T>::type*,
BOOST_DEDUCED_TYPENAME char_type_of<T>::type*
>
input_sequence(T& t)
{ return detail::input_sequence_impl<T>::input_sequence(t); }
namespace detail {
//------------------Definition of direct_impl-------------------------------//
template<typename T>
struct input_sequence_impl
: mpl::if_<
detail::is_custom<T>,
operations<T>,
input_sequence_impl<direct_tag>
>::type
{ };
template<>
struct input_sequence_impl<direct_tag> {
template<typename U>
static std::pair<
BOOST_DEDUCED_TYPENAME char_type_of<U>::type*,
BOOST_DEDUCED_TYPENAME char_type_of<U>::type*
>
input_sequence(U& u) { return u.input_sequence(); }
};
} // End namespace detail.
} } // End namespaces iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp>
#endif // #ifndef BOOST_IOSTREAMS_INPUT_SEQUENCE_HPP_INCLUDED

25
boost/boost/iostreams/operations.hpp Normal file
View File

@ -0,0 +1,25 @@
// (C) Copyright Jonathan Turkanis 2005.
// 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_OPERATIONS_HPP_INCLUDED
#define BOOST_IOSTREAMS_OPERATIONS_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/iostreams/operations_fwd.hpp>
#include <boost/iostreams/close.hpp>
#include <boost/iostreams/flush.hpp>
#include <boost/iostreams/imbue.hpp>
#include <boost/iostreams/input_sequence.hpp>
#include <boost/iostreams/optimal_buffer_size.hpp>
#include <boost/iostreams/output_sequence.hpp>
#include <boost/iostreams/read.hpp>
#include <boost/iostreams/seek.hpp>
#include <boost/iostreams/write.hpp>
#endif // #ifndef BOOST_IOSTREAMS_OPERATIONS_HPP_INCLUDED

40
boost/boost/iostreams/operations_fwd.hpp Normal file
View File

@ -0,0 +1,40 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_OPERATIONS_FWD_HPP_INCLUDED
#define BOOST_IOSTREAMS_OPERATIONS_FWD_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/mpl/not.hpp>
#include <boost/type_traits/is_base_and_derived.hpp>
namespace boost { namespace iostreams {
template<typename T>
struct operations;
namespace detail {
struct custom_tag { };
template<typename T>
struct is_custom
: mpl::not_<
is_base_and_derived< custom_tag, operations<T> >
>
{ };
} // End namespace detail.
template<typename T>
struct operations : detail::custom_tag { };
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_OPERATIONS_FWD_HPP_INCLUDED //--------------//

86
boost/boost/iostreams/optimal_buffer_size.hpp Normal file
View File

@ -0,0 +1,86 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_OPTIMAL_BUFFER_SIZE_HPP_INCLUDED
#define BOOST_IOSTREAMS_OPTIMAL_BUFFER_SIZE_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // DEDUCED_TYPENAME, MSVC.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/constants.hpp> // constants.
#include <boost/iostreams/detail/dispatch.hpp>
#include <boost/iostreams/detail/wrap_unwrap.hpp>
#include <boost/iostreams/operations_fwd.hpp>
#include <boost/mpl/if.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp>
namespace boost { namespace iostreams {
namespace detail {
template<typename T>
struct optimal_buffer_size_impl;
} // End namespace detail.
template<typename T>
std::streamsize optimal_buffer_size(const T& t)
{
typedef detail::optimal_buffer_size_impl<T> impl;
return impl::optimal_buffer_size(detail::unwrap(t));
}
namespace detail {
//------------------Definition of optimal_buffer_size_impl--------------------//
template<typename T>
struct optimal_buffer_size_impl
: mpl::if_<
is_custom<T>,
operations<T>,
optimal_buffer_size_impl<
BOOST_DEDUCED_TYPENAME
dispatch<
T, optimally_buffered_tag, device_tag, filter_tag
>::type
>
>::type
{ };
template<>
struct optimal_buffer_size_impl<optimally_buffered_tag> {
template<typename T>
static std::streamsize optimal_buffer_size(const T& t)
{ return t.optimal_buffer_size(); }
};
template<>
struct optimal_buffer_size_impl<device_tag> {
template<typename T>
static std::streamsize optimal_buffer_size(const T&)
{ return default_device_buffer_size; }
};
template<>
struct optimal_buffer_size_impl<filter_tag> {
template<typename T>
static std::streamsize optimal_buffer_size(const T&)
{ return default_filter_buffer_size; }
};
} // End namespace detail.
} } // End namespaces iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp>
#endif // #ifndef BOOST_IOSTREAMS_OPTIMAL_BUFFER_SIZE_HPP_INCLUDED

70
boost/boost/iostreams/output_sequence.hpp Normal file
View File

@ -0,0 +1,70 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_OUTPUT_SEQUENCE_HPP_INCLUDED
#define BOOST_IOSTREAMS_OUTPUT_SEQUENCE_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <utility> // pair.
#include <boost/config.hpp> // DEDUCED_TYPENAME, MSVC.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/detail/wrap_unwrap.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/mpl/if.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp>
namespace boost { namespace iostreams {
namespace detail {
template<typename T>
struct output_sequence_impl;
} // End namespace detail.
template<typename T>
inline std::pair<
BOOST_DEDUCED_TYPENAME char_type_of<T>::type*,
BOOST_DEDUCED_TYPENAME char_type_of<T>::type*
>
output_sequence(T& t)
{ return detail::output_sequence_impl<T>::output_sequence(t); }
namespace detail {
//------------------Definition of output_sequence_impl------------------------//
template<typename T>
struct output_sequence_impl
: mpl::if_<
detail::is_custom<T>,
operations<T>,
output_sequence_impl<direct_tag>
>::type
{ };
template<>
struct output_sequence_impl<direct_tag> {
template<typename U>
static std::pair<
BOOST_DEDUCED_TYPENAME char_type_of<U>::type*,
BOOST_DEDUCED_TYPENAME char_type_of<U>::type*
>
output_sequence(U& u) { return u.output_sequence(); }
};
} // End namespace detail.
} } // End namespaces iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp>
#endif // #ifndef BOOST_IOSTREAMS_OUTPUT_SEQUENCE_HPP_INCLUDED

125
boost/boost/iostreams/pipeline.hpp Normal file
View File

@ -0,0 +1,125 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_PIPABLE_HPP_INCLUDED
#define BOOST_IOSTREAMS_PIPABLE_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // BOOST_MSVC.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/detail/template_params.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/static_assert.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
# include <boost/type_traits/is_base_and_derived.hpp>
#endif
#define BOOST_IOSTREAMS_PIPABLE(filter, arity) \
template< BOOST_PP_ENUM_PARAMS(arity, typename T) \
BOOST_PP_COMMA_IF(arity) typename Component> \
::boost::iostreams::pipeline< \
::boost::iostreams::detail::pipeline_segment< \
filter BOOST_IOSTREAMS_TEMPLATE_ARGS(arity, T) \
>, \
Component \
> operator|( const filter BOOST_IOSTREAMS_TEMPLATE_ARGS(arity, T)& f, \
const Component& c ) \
{ \
typedef ::boost::iostreams::detail::pipeline_segment< \
filter BOOST_IOSTREAMS_TEMPLATE_ARGS(arity, T) \
> segment; \
return ::boost::iostreams::pipeline<segment, Component> \
(segment(f), c); \
} \
/**/
namespace boost { namespace iostreams {
template<typename Pipeline, typename Component>
struct pipeline;
namespace detail {
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
struct pipeline_base { };
template<typename T>
struct is_pipeline
: is_base_and_derived<pipeline_base, T>
{ };
#endif
#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
template<typename T>
struct is_pipeline : mpl::false_ { };
template<typename Pipeline, typename Component>
struct is_pipeline< pipeline<Pipeline, Component> > : mpl::true_ { };
#endif
template<typename Component>
class pipeline_segment
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
: pipeline_base
#endif
{
public:
pipeline_segment(const Component& component)
: component_(component)
{ }
template<typename Fn>
void for_each(Fn fn) const { fn(component_); }
template<typename Chain>
void push(Chain& chn) const { chn.push(component_); }
private:
const Component& component_;
};
} // End namespace detail.
//------------------Definition of Pipeline------------------------------------//
template<typename Pipeline, typename Component>
struct pipeline : Pipeline {
typedef Pipeline pipeline_type;
typedef Component component_type;
pipeline(const Pipeline& p, const Component& component)
: Pipeline(p), component_(component)
{ }
template<typename Fn>
void for_each(Fn fn) const
{
Pipeline::for_each(fn);
fn(component_);
}
template<typename Chain>
void push(Chain& chn) const
{
Pipeline::push(chn);
chn.push(component_);
}
const Pipeline& tail() const { return *this; }
const Component& head() const { return component_; }
private:
const Component& component_;
};
template<typename Pipeline, typename Filter, typename Component>
pipeline<pipeline<Pipeline, Filter>, Component>
operator|(const pipeline<Pipeline, Filter>& p, const Component& cmp)
{
BOOST_STATIC_ASSERT(is_filter<Filter>::value);
return pipeline<pipeline<Pipeline, Filter>, Component>(p, cmp);
}
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_PIPABLE_HPP_INCLUDED

97
boost/boost/iostreams/positioning.hpp Normal file
View File

@ -0,0 +1,97 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Thanks to Gareth Sylvester-Bradley for the Dinkumware versions of the
// positioning functions.
#ifndef BOOST_IOSTREAMS_POSITIONING_HPP_INCLUDED
#define BOOST_IOSTREAMS_POSITIONING_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/cstdint.hpp>
#include <boost/integer_traits.hpp>
#include <boost/iostreams/detail/config/codecvt.hpp> // mbstate_t.
#include <boost/iostreams/detail/ios.hpp> // streamoff, streampos.
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp>
namespace boost { namespace iostreams {
typedef boost::intmax_t stream_offset;
inline std::streamoff stream_offset_to_streamoff(stream_offset off)
{ return static_cast<stream_offset>(off); }
template<typename PosType> // Hande custom pos_type's.
inline stream_offset position_to_offset(PosType pos)
{ return std::streamoff(pos); }
#if ((defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)) && \
!defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) \
&& !defined(__QNX__) \
/**/
/* Dinkumware */
inline std::streampos offset_to_position(stream_offset off)
{
// Use implementation-specific constructor.
return std::streampos(std::mbstate_t(), off);
}
inline stream_offset fpos_t_to_offset(fpos_t pos)
{ // Helper function.
#if defined(_POSIX_) || (_INTEGRAL_MAX_BITS >= 64)
return pos;
#else
return _FPOSOFF(pos);
#endif
}
# if defined(_CPPLIB_VER) //--------------------------------------------------//
/* Recent Dinkumware */
inline stream_offset position_to_offset(std::streampos pos)
{
// Use implementation-specific member function seekpos().
return fpos_t_to_offset(pos.seekpos()) +
stream_offset(std::streamoff(pos)) -
stream_offset(std::streamoff(pos.seekpos()));
}
# else // # if defined(_CPPLIB_VER) //----------------------------------------//
/* Old Dinkumware */
inline stream_offset position_to_offset(std::streampos pos)
{
// use implementation-specific member function get_fpos_t().
return fpos_t_to_offset(pos.get_fpos_t()) +
stream_offset(std::streamoff(pos)) -
stream_offset(std::streamoff(pos.get_fpos_t()));
}
# endif // # if defined(_CPPLIB_VER) //---------------------------------------//
#else // Dinkumware //--------------------------------------------------------//
/* Non-Dinkumware */
inline std::streampos offset_to_position(stream_offset off) { return off; }
inline stream_offset position_to_offset(std::streampos pos) { return pos; }
#endif // Dinkumware //-------------------------------------------------------//
} } // End namespaces iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp>
#endif // #ifndef BOOST_IOSTREAMS_POSITIONING_HPP_INCLUDED

16
boost/boost/iostreams/put.hpp Normal file
View File

@ -0,0 +1,16 @@
// (C) Copyright Jonathan Turkanis 2005.
// 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_PUT_HPP_INCLUDED
#define BOOST_IOSTREAMS_PUT_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/iostreams/write.hpp>
#endif // #ifndef BOOST_IOSTREAMS_PUT_HPP_INCLUDED

246
boost/boost/iostreams/read.hpp Normal file
View File

@ -0,0 +1,246 @@
// (C) Copyright Jonathan Turkanis 2005.
// 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_READ_HPP_INCLUDED
#define BOOST_IOSTREAMS_READ_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // DEDUCED_TYPENAME, MSVC.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/char_traits.hpp>
#include <boost/iostreams/detail/char_traits.hpp>
#include <boost/iostreams/detail/dispatch.hpp>
#include <boost/iostreams/detail/ios.hpp> // streamsize.
#include <boost/iostreams/detail/streambuf.hpp>
#include <boost/iostreams/detail/wrap_unwrap.hpp>
#include <boost/iostreams/operations_fwd.hpp>
#include <boost/mpl/if.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) //-----------------------------------//
# include <boost/iostreams/detail/vc6/read.hpp>
#else // #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) //--------------------------//
namespace boost { namespace iostreams {
namespace detail {
template<typename T>
struct read_device_impl;
template<typename T>
struct read_filter_impl;
} // End namespace detail.
template<typename T>
typename int_type_of<T>::type get(T& t)
{ return detail::read_device_impl<T>::get(detail::unwrap(t)); }
template<typename T>
inline std::streamsize
read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
{ return detail::read_device_impl<T>::read(detail::unwrap(t), s, n); }
template<typename T, typename Source>
std::streamsize
read(T& t, Source& src, typename char_type_of<T>::type* s, std::streamsize n)
{ return detail::read_filter_impl<T>::read(detail::unwrap(t), src, s, n); }
template<typename T>
bool putback(T& t, typename char_type_of<T>::type c)
{ return detail::read_device_impl<T>::putback(detail::unwrap(t), c); }
//----------------------------------------------------------------------------//
namespace detail {
// Helper function for adding -1 as EOF indicator.
inline std::streamsize check_eof(std::streamsize n) { return n != 0 ? n : -1; }
// Helper templates for reading from streambufs.
template<bool IsLinked>
struct true_eof_impl;
template<>
struct true_eof_impl<true> {
template<typename T>
static bool true_eof(T& t) { return t.true_eof(); }
};
template<>
struct true_eof_impl<false> {
template<typename T>
static bool true_eof(T& t) { return true; }
};
template<typename T>
inline bool true_eof(T& t)
{
const bool linked = is_linked<T>::value;
return true_eof_impl<linked>::true_eof(t);
}
//------------------Definition of read_device_impl----------------------------//
template<typename T>
struct read_device_impl
: mpl::if_<
detail::is_custom<T>,
operations<T>,
read_device_impl<
BOOST_DEDUCED_TYPENAME
detail::dispatch<
T, istream_tag, streambuf_tag, input
>::type
>
>::type
{ };
template<>
struct read_device_impl<istream_tag> {
template<typename T>
static typename int_type_of<T>::type get(T& t)
{ return t.get(); }
template<typename T>
static std::streamsize
read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
{ return check_eof(t.rdbuf()->sgetn(s, n)); }
template<typename T>
static bool putback(T& t, typename char_type_of<T>::type c)
{
typedef typename char_type_of<T>::type char_type;
typedef BOOST_IOSTREAMS_CHAR_TRAITS(char_type) traits_type;
return !traits_type::eq_int_type( t.rdbuf()->sputbackc(c),
traits_type::eof() );
}
};
template<>
struct read_device_impl<streambuf_tag> {
template<typename T>
static typename int_type_of<T>::type
get(T& t)
{ // gcc 2.95 needs namespace qualification for char_traits.
typedef typename char_type_of<T>::type char_type;
typedef iostreams::char_traits<char_type> traits_type;
typename int_type_of<T>::type c;
return !traits_type::is_eof(c = t.sbumpc()) ||
detail::true_eof(t)
?
c : traits_type::would_block();
}
template<typename T>
static std::streamsize
read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
{
std::streamsize amt;
return (amt = t.sgetn(s, n)) != 0 ?
amt :
detail::true_eof(t) ?
-1 :
0;
}
template<typename T>
static bool putback(T& t, typename char_type_of<T>::type c)
{ // gcc 2.95 needs namespace qualification for char_traits.
typedef typename char_type_of<T>::type char_type;
typedef iostreams::char_traits<char_type> traits_type;
return !traits_type::is_eof(t.sputbackc(c));
}
};
template<>
struct read_device_impl<input> {
template<typename T>
static typename int_type_of<T>::type
get(T& t)
{ // gcc 2.95 needs namespace qualification for char_traits.
typedef typename char_type_of<T>::type char_type;
typedef iostreams::char_traits<char_type> traits_type;
char_type c;
std::streamsize amt;
return (amt = t.read(&c, 1)) == 1 ?
traits_type::to_int_type(c) :
amt == -1 ?
traits_type::eof() :
traits_type::would_block();
}
template<typename T>
static std::streamsize
read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
{ return t.read(s, n); }
template<typename T>
static bool putback(T& t, typename char_type_of<T>::type c)
{ // T must be Peekable.
return t.putback(c);
}
};
//------------------Definition of read_filter_impl----------------------------//
template<typename T>
struct read_filter_impl
: mpl::if_<
detail::is_custom<T>,
operations<T>,
read_filter_impl<
BOOST_DEDUCED_TYPENAME
detail::dispatch<
T, multichar_tag, any_tag
>::type
>
>::type
{ };
template<>
struct read_filter_impl<multichar_tag> {
template<typename T, typename Source>
static std::streamsize read
(T& t, Source& src, typename char_type_of<T>::type* s, std::streamsize n)
{ return t.read(src, s, n); }
};
template<>
struct read_filter_impl<any_tag> {
template<typename T, typename Source>
static std::streamsize read
(T& t, Source& src, typename char_type_of<T>::type* s, std::streamsize n)
{ // gcc 2.95 needs namespace qualification for char_traits.
typedef typename char_type_of<T>::type char_type;
typedef iostreams::char_traits<char_type> traits_type;
for (std::streamsize off = 0; off < n; ++off) {
typename traits_type::int_type c = t.get(src);
if (traits_type::is_eof(c))
return check_eof(off);
if (traits_type::would_block(c))
return off;
s[off] = traits_type::to_char_type(c);
}
return n;
}
};
} // End namespace detail.
} } // End namespaces iostreams, boost.
#endif // #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) //-------------------------//
#include <boost/iostreams/detail/config/enable_warnings.hpp>
#endif // #ifndef BOOST_IOSTREAMS_READ_HPP_INCLUDED

179
boost/boost/iostreams/seek.hpp Normal file
View File

@ -0,0 +1,179 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_SEEK_HPP_INCLUDED
#define BOOST_IOSTREAMS_SEEK_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // DEDUCED_TYPENAME, MSVC.
#include <boost/integer_traits.hpp>
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/detail/dispatch.hpp>
#include <boost/iostreams/detail/ios.hpp> // streamsize, seekdir, openmode.
#include <boost/iostreams/detail/streambuf.hpp>
#include <boost/iostreams/detail/wrap_unwrap.hpp>
#include <boost/iostreams/operations_fwd.hpp>
#include <boost/iostreams/positioning.hpp>
#include <boost/mpl/if.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp>
namespace boost { namespace iostreams {
namespace detail {
template<typename T>
struct seek_device_impl;
template<typename T>
struct seek_filter_impl;
} // End namespace detail.
template<typename T>
inline std::streampos
seek( T& t, stream_offset off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out )
{
using namespace detail;
return seek_device_impl<T>::seek(detail::unwrap(t), off, way, which);
}
template<typename T, typename Device>
inline std::streampos
seek( T& t, Device& dev, stream_offset off, BOOST_IOS::seekdir way,
BOOST_IOS::openmode which = BOOST_IOS::in | BOOST_IOS::out )
{
using namespace detail;
return seek_filter_impl<T>::seek(detail::unwrap(t), dev, off, way, which);
}
namespace detail {
//------------------Definition of seek_device_impl----------------------------//
template<typename T>
struct seek_device_impl
: mpl::if_<
is_custom<T>,
operations<T>,
seek_device_impl<
BOOST_DEDUCED_TYPENAME
dispatch<
T, iostream_tag, istream_tag, ostream_tag,
streambuf_tag, two_head, any_tag
>::type
>
>::type
{ };
struct seek_impl_basic_ios {
template<typename T>
static std::streampos seek( T& t, stream_offset off,
BOOST_IOS::seekdir way,
BOOST_IOS::openmode which )
{
if ( way == BOOST_IOS::beg &&
( off < integer_traits<std::streamoff>::const_min ||
off > integer_traits<std::streamoff>::const_max ) )
{
return t.rdbuf()->pubseekpos(offset_to_position(off));
} else {
return t.rdbuf()->pubseekoff(off, way, which);
}
}
};
template<>
struct seek_device_impl<iostream_tag> : seek_impl_basic_ios { };
template<>
struct seek_device_impl<istream_tag> : seek_impl_basic_ios { };
template<>
struct seek_device_impl<ostream_tag> : seek_impl_basic_ios { };
template<>
struct seek_device_impl<streambuf_tag> {
template<typename T>
static std::streampos seek( T& t, stream_offset off,
BOOST_IOS::seekdir way,
BOOST_IOS::openmode which )
{
if ( way == BOOST_IOS::beg &&
( off < integer_traits<std::streamoff>::const_min ||
off > integer_traits<std::streamoff>::const_max ) )
{
return t.BOOST_IOSTREAMS_PUBSEEKPOS(offset_to_position(off));
} else {
return t.BOOST_IOSTREAMS_PUBSEEKOFF(off, way, which);
}
}
};
template<>
struct seek_device_impl<two_head> {
template<typename T>
static std::streampos seek( T& t, stream_offset off,
BOOST_IOS::seekdir way,
BOOST_IOS::openmode which )
{ return t.seek(off, way, which); }
};
template<>
struct seek_device_impl<any_tag> {
template<typename T>
static std::streampos seek( T& t, stream_offset off,
BOOST_IOS::seekdir way,
BOOST_IOS::openmode )
{ return t.seek(off, way); }
};
//------------------Definition of seek_filter_impl----------------------------//
template<typename T>
struct seek_filter_impl
: mpl::if_<
is_custom<T>,
operations<T>,
seek_filter_impl<
BOOST_DEDUCED_TYPENAME
dispatch<T, two_head, any_tag>::type
>
>::type
{ };
template<>
struct seek_filter_impl<two_head> {
template<typename T, typename Device>
static std::streampos seek( T& t, Device& d,
stream_offset off,
BOOST_IOS::seekdir way,
BOOST_IOS::openmode which )
{ return t.seek(d, off, way, which); }
};
template<>
struct seek_filter_impl<any_tag> {
template<typename T, typename Device>
static std::streampos seek( T& t, Device& d,
stream_offset off,
BOOST_IOS::seekdir way,
BOOST_IOS::openmode )
{ return t.seek(d, off, way); }
};
} // End namespace detail.
} } // End namespaces iostreams, boost.
#include <boost/iostreams/detail/config/enable_warnings.hpp>
#endif // #ifndef BOOST_IOSTREAMS_SEEK_HPP_INCLUDED

108
boost/boost/iostreams/stream_buffer.hpp Normal file
View File

@ -0,0 +1,108 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_STREAM_BUFFER_HPP_INCLUDED
#define BOOST_IOSTREAMS_STREAM_BUFFER_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <memory> // allocator.
#include <boost/config.hpp> // BOOST_DEDUCED_TYPENAME.
#include <boost/iostreams/detail/char_traits.hpp>
#include <boost/iostreams/detail/config/overload_resolution.hpp>
#include <boost/iostreams/detail/forward.hpp>
#include <boost/iostreams/detail/ios.hpp> // failure, streamsize.
#include <boost/iostreams/detail/streambuf/direct_streambuf.hpp>
#include <boost/iostreams/detail/streambuf/indirect_streambuf.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_convertible.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC.
namespace boost { namespace iostreams { namespace detail {
template<typename T, typename Tr, typename Alloc, typename Mode>
struct stream_buffer_traits {
typedef typename
mpl::if_<
is_convertible<
BOOST_DEDUCED_TYPENAME category_of<T>::type,
direct_tag
>,
direct_streambuf<T, Tr>,
indirect_streambuf<T, Tr, Alloc, Mode>
>::type type;
};
} } } // End namespaces detail, iostreams, boost
#ifdef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION
# include <boost/iostreams/detail/broken_overload_resolution/stream_buffer.hpp>
#else
namespace boost { namespace iostreams {
template< typename T,
typename Tr =
BOOST_IOSTREAMS_CHAR_TRAITS(
BOOST_DEDUCED_TYPENAME char_type_of<T>::type
),
typename Alloc =
std::allocator<
BOOST_DEDUCED_TYPENAME char_type_of<T>::type
>,
typename Mode = BOOST_DEDUCED_TYPENAME mode_of<T>::type >
class stream_buffer
: public detail::stream_buffer_traits<T, Tr, Alloc, Mode>::type
{
private:
BOOST_STATIC_ASSERT((
is_convertible<
BOOST_DEDUCED_TYPENAME iostreams::category_of<T>::type, Mode
>::value
));
typedef typename
detail::stream_buffer_traits<
T, Tr, Alloc, Mode
>::type base_type;
typedef T policy_type;
public:
typedef typename char_type_of<T>::type char_type;
BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)
public:
stream_buffer() { }
~stream_buffer()
{
try {
if (this->is_open() && this->auto_close())
this->close();
} catch (std::exception&) { }
}
BOOST_IOSTREAMS_FORWARD( stream_buffer, open_impl, T,
BOOST_IOSTREAMS_PUSH_PARAMS,
BOOST_IOSTREAMS_PUSH_ARGS )
T& operator*() { return *this->component(); }
T* operator->() { return this->component(); }
private:
void open_impl(const T& t BOOST_IOSTREAMS_PUSH_PARAMS())
{ // Used for forwarding.
if (this->is_open())
BOOST_IOSTREAMS_FAILURE("already open");
base_type::open(t BOOST_IOSTREAMS_PUSH_ARGS());
}
};
} } // End namespaces iostreams, boost.
#endif // #ifdef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION
#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC.
#endif // #ifndef BOOST_IOSTREAMS_STREAM_BUFFER_HPP_INCLUDED

256
boost/boost/iostreams/traits.hpp Normal file
View File

@ -0,0 +1,256 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
//
// Contains metafunctions char_type_of, category_of and mode_of used for
// deducing the i/o category and i/o mode of a model of Filter or Device.
//
// Also contains several utility metafunctions, functions and macros.
//
#ifndef BOOST_IOSTREAMS_IO_TRAITS_HPP_INCLUDED
#define BOOST_IOSTREAMS_IO_TRAITS_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <iosfwd> // stream types, char_traits.
#include <boost/config.hpp> // partial spec, deduced typename.
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/detail/bool_trait_def.hpp>
#include <boost/iostreams/detail/config/wide_streams.hpp>
#include <boost/iostreams/detail/is_iterator_range.hpp>
#include <boost/iostreams/detail/select.hpp>
#include <boost/iostreams/detail/select_by_size.hpp>
#include <boost/iostreams/detail/wrap_unwrap.hpp>
#include <boost/iostreams/traits_fwd.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/or.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/value_type.hpp>
#include <boost/type_traits/is_convertible.hpp>
namespace boost { namespace iostreams {
//------------------Definitions of predicates for streams and stream buffers--//
#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //--------------------------------//
BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_istream, std::basic_istream, 2)
BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_ostream, std::basic_ostream, 2)
BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_iostream, std::basic_iostream, 2)
BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_streambuf, std::basic_streambuf, 2)
BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_stringstream, std::basic_stringstream, 3)
BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_stringbuf, std::basic_stringbuf, 3)
#else // #ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-----------------------//
BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_istream, std::istream, 0)
BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_ostream, std::ostream, 0)
BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_iostream, std::iostream, 0)
BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_streambuf, std::streambuf, 0)
#endif // #ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //----------------------//
template<typename T>
struct is_std_io
: mpl::or_< is_istream<T>, is_ostream<T>, is_streambuf<T> >
{ };
namespace detail {
template<typename T, typename Tr>
class linked_streambuf;
BOOST_IOSTREAMS_BOOL_TRAIT_DEF(is_linked, linked_streambuf, 2)
} // End namespace detail.
//------------------Definitions of char_type_of-------------------------------//
namespace detail {
template<typename T>
struct member_char_type { typedef typename T::char_type type; };
} // End namespace detail.
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION //---------------------------//
# ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-------------------------------//
template<typename T>
struct char_type_of
: detail::member_char_type<
typename detail::unwrapped_type<T>::type
>
{ };
# else // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //---------------------//
template<typename T>
struct char_type_of {
typedef typename detail::unwrapped_type<T>::type U;
typedef typename
mpl::eval_if<
is_std_io<U>,
mpl::identity<char>,
detail::member_char_type<U>
>::type type;
};
# endif // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //--------------------//
template<typename Iter>
struct char_type_of< iterator_range<Iter> > {
typedef typename iterator_value<Iter>::type type;
};
#else // #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION //------------------//
template<typename T>
struct char_type_of {
template<typename U>
struct get_value_type {
typedef typename range_value<U>::type type;
};
typedef typename
mpl::eval_if<
is_iterator_range<T>,
get_value_type<T>,
detail::member_char_type<
BOOST_DEDUCED_TYPENAME detail::unwrapped_type<T>::type
>
>::type type;
};
#endif // #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION //-----------------//
//------------------Definitions of category_of--------------------------------//
namespace detail {
template<typename T>
struct member_category { typedef typename T::category type; };
} // End namespace detail.
template<typename T>
struct category_of {
template<typename U>
struct member_category {
typedef typename U::category type;
};
typedef typename detail::unwrapped_type<T>::type U;
typedef typename
mpl::eval_if<
is_std_io<U>,
iostreams::select< // Disambiguation for Tru64
is_iostream<U>, iostream_tag,
is_istream<U>, istream_tag,
is_ostream<U>, ostream_tag,
is_streambuf<U>, streambuf_tag
>,
detail::member_category<U>
>::type type;
};
//------------------Definition of get_category--------------------------------//
//
// Returns an object of type category_of<T>::type.
//
template<typename T>
inline typename category_of<T>::type get_category(const T&)
{ typedef typename category_of<T>::type category; return category(); }
//------------------Definition of int_type_of---------------------------------//
template<typename T>
struct int_type_of {
#ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
typedef std::char_traits<
BOOST_DEDUCED_TYPENAME char_type_of<T>::type
> traits_type;
typedef typename traits_type::int_type type;
#else
typedef int type;
#endif
};
//------------------Definition of mode----------------------------------------//
namespace detail {
template<int N> struct io_mode_impl;
#define BOOST_IOSTREAMS_MODE_HELPER(tag_, id_) \
case_<id_> io_mode_impl_helper(tag_); \
template<> struct io_mode_impl<id_> { typedef tag_ type; }; \
/**/
BOOST_IOSTREAMS_MODE_HELPER(input, 1)
BOOST_IOSTREAMS_MODE_HELPER(output, 2)
BOOST_IOSTREAMS_MODE_HELPER(bidirectional, 3)
BOOST_IOSTREAMS_MODE_HELPER(input_seekable, 4)
BOOST_IOSTREAMS_MODE_HELPER(output_seekable, 5)
BOOST_IOSTREAMS_MODE_HELPER(seekable, 6)
BOOST_IOSTREAMS_MODE_HELPER(dual_seekable, 7)
BOOST_IOSTREAMS_MODE_HELPER(bidirectional_seekable, 8)
BOOST_IOSTREAMS_MODE_HELPER(dual_use, 9)
#undef BOOST_IOSTREAMS_MODE_HELPER
template<typename T>
struct io_mode_id {
typedef typename category_of<T>::type category;
BOOST_SELECT_BY_SIZE(int, value, detail::io_mode_impl_helper(category()));
};
} // End namespace detail.
template<typename T> // Borland 5.6.4 requires this circumlocution.
struct mode_of : detail::io_mode_impl< detail::io_mode_id<T>::value > { };
//------------------Definition of is_device, is_filter and is_direct----------//
namespace detail {
template<typename T, typename Tag>
struct has_trait_impl {
typedef typename category_of<T>::type category;
BOOST_STATIC_CONSTANT(bool, value = (is_convertible<category, Tag>::value));
};
template<typename T, typename Tag>
struct has_trait
: mpl::bool_<has_trait_impl<T, Tag>::value>
{ };
} // End namespace detail.
template<typename T>
struct is_device : detail::has_trait<T, device_tag> { };
template<typename T>
struct is_filter : detail::has_trait<T, filter_tag> { };
template<typename T>
struct is_direct : detail::has_trait<T, direct_tag> { };
//------------------Definition of BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS----------//
#define BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr) \
typedef Tr traits_type; \
typedef typename traits_type::int_type int_type; \
typedef typename traits_type::off_type off_type; \
typedef typename traits_type::pos_type pos_type; \
/**/
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_IO_TRAITS_HPP_INCLUDED

71
boost/boost/iostreams/traits_fwd.hpp Normal file
View File

@ -0,0 +1,71 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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.
// Forward declarations of templates defined in traits.hpp.
#ifndef BOOST_IOSTREAMS_IO_TRAITS_FWD_HPP_INCLUDED
#define BOOST_IOSTREAMS_IO_TRAITS_FWD_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <iosfwd> // stream types, char_traits.
namespace boost { namespace iostreams {
template<typename T>
struct is_istream;
template<typename T>
struct is_ostream;
template<typename T>
struct is_iostream;
template<typename T>
struct is_streambuf;
template<typename T>
struct is_stringstream;
template<typename T>
struct is_stringbuf;
template<typename T>
struct is_std_io;
template<typename T>
struct char_type_of;
template<typename T>
struct category_of;
template<typename T>
struct int_type_of;
template<typename T>
struct mode_of;
template<typename T>
struct is_device;
template<typename T>
struct is_filter;
template<typename T>
struct is_direct;
namespace detail {
template<typename T>
struct is_linked;
} // End namespace detail.
} } // End namespaces iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_IO_TRAITS_FWD_HPP_INCLUDED

170
boost/boost/iostreams/write.hpp Normal file
View File

@ -0,0 +1,170 @@
// (C) Copyright Jonathan Turkanis 2003.
// 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_WRITE_HPP_INCLUDED
#define BOOST_IOSTREAMS_WRITE_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp> // DEDUCED_TYPENAME, MSVC.
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/detail/char_traits.hpp>
#include <boost/iostreams/detail/dispatch.hpp>
#include <boost/iostreams/detail/ios.hpp> // streamsize.
#include <boost/iostreams/detail/streambuf.hpp>
#include <boost/iostreams/detail/wrap_unwrap.hpp>
#include <boost/iostreams/operations_fwd.hpp>
#include <boost/iostreams/traits.hpp>
#include <boost/mpl/if.hpp>
// Must come last.
#include <boost/iostreams/detail/config/disable_warnings.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) //-----------------------------------//
# include <boost/iostreams/detail/vc6/write.hpp>
#else // #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) //--------------------------//
namespace boost { namespace iostreams {
namespace detail {
template<typename T>
struct write_device_impl;
template<typename T>
struct write_filter_impl;
} // End namespace detail.
template<typename T>
bool put(T& t, typename char_type_of<T>::type c)
{ return detail::write_device_impl<T>::put(detail::unwrap(t), c); }
template<typename T>
inline std::streamsize write
(T& t, const typename char_type_of<T>::type* s, std::streamsize n)
{ return detail::write_device_impl<T>::write(detail::unwrap(t), s, n); }
template<typename T, typename Sink>
inline std::streamsize
write( T& t, Sink& snk, const typename char_type_of<T>::type* s,
std::streamsize n )
{ return detail::write_filter_impl<T>::write(detail::unwrap(t), snk, s, n); }
namespace detail {
//------------------Definition of write_device_impl---------------------------//
template<typename T>
struct write_device_impl
: mpl::if_<
is_custom<T>,
operations<T>,
write_device_impl<
BOOST_DEDUCED_TYPENAME
dispatch<
T, ostream_tag, streambuf_tag, output
>::type
>
>::type
{ };
template<>
struct write_device_impl<ostream_tag> {
template<typename T>
static bool put(T& t, typename char_type_of<T>::type c)
{
typedef typename char_type_of<T>::type char_type;
typedef BOOST_IOSTREAMS_CHAR_TRAITS(char_type) traits_type;
return !traits_type::eq_int_type( t.rdbuf()->s.sputc(),
traits_type::eof() );
}
template<typename T>
static std::streamsize write
(T& t, const typename char_type_of<T>::type* s, std::streamsize n)
{ return t.rdbuf()->sputn(s, n); }
};
template<>
struct write_device_impl<streambuf_tag> {
template<typename T>
static bool put(T& t, typename char_type_of<T>::type c)
{
typedef typename char_type_of<T>::type char_type;
typedef BOOST_IOSTREAMS_CHAR_TRAITS(char_type) traits_type;
return !traits_type::eq_int_type(t.sputc(c), traits_type::eof());
}
template<typename T>
static std::streamsize write
(T& t, const typename char_type_of<T>::type* s, std::streamsize n)
{ return t.sputn(s, n); }
};
template<>
struct write_device_impl<output> {
template<typename T>
static bool put(T& t, typename char_type_of<T>::type c)
{ return t.write(&c, 1) == 1; }
template<typename T>
static std::streamsize
write(T& t, const typename char_type_of<T>::type* s, std::streamsize n)
{ return t.write(s, n); }
};
//------------------Definition of write_filter_impl---------------------------//
template<typename T>
struct write_filter_impl
: mpl::if_<
is_custom<T>,
operations<T>,
write_filter_impl<
BOOST_DEDUCED_TYPENAME
dispatch<
T, multichar_tag, any_tag
>::type
>
>::type
{ };
template<>
struct write_filter_impl<multichar_tag> {
template<typename T, typename Sink>
static std::streamsize
write( T& t, Sink& snk, const typename char_type_of<T>::type* s,
std::streamsize n )
{ return t.write(snk, s, n); }
};
template<>
struct write_filter_impl<any_tag> {
template<typename T, typename Sink>
static std::streamsize
write( T& t, Sink& snk, const typename char_type_of<T>::type* s,
std::streamsize n )
{
for (std::streamsize off = 0; off < n; ++off)
if (!t.put(snk, s[off]))
return off;
return n;
}
};
} // End namespace detail.
} } // End namespaces iostreams, boost.
#endif // #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) //-------------------------//
#include <boost/iostreams/detail/config/enable_warnings.hpp>
#endif // #ifndef BOOST_IOSTREAMS_WRITE_HPP_INCLUDED

0
boost/boost/iterator/detail/facade_iterator_category.hpp Executable file → Normal file
View File

0
boost/boost/iterator/detail/minimum_category.hpp Executable file → Normal file
View File

69
boost/boost/iterator/reverse_iterator.hpp Normal file
View File

@ -0,0 +1,69 @@
// (C) Copyright David Abrahams 2002.
// (C) Copyright Jeremy Siek 2002.
// (C) Copyright Thomas Witt 2002.
// 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_REVERSE_ITERATOR_23022003THW_HPP
#define BOOST_REVERSE_ITERATOR_23022003THW_HPP
#include <boost/iterator.hpp>
#include <boost/utility.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
namespace boost
{
//
//
//
template <class Iterator>
class reverse_iterator
: public iterator_adaptor< reverse_iterator<Iterator>, Iterator >
{
typedef iterator_adaptor< reverse_iterator<Iterator>, Iterator > super_t;
friend class iterator_core_access;
public:
reverse_iterator() {}
explicit reverse_iterator(Iterator x)
: super_t(x) {}
template<class OtherIterator>
reverse_iterator(
reverse_iterator<OtherIterator> const& r
, typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
)
: super_t(r.base())
{}
private:
typename super_t::reference dereference() const { return *boost::prior(this->base()); }
void increment() { --this->base_reference(); }
void decrement() { ++this->base_reference(); }
void advance(typename super_t::difference_type n)
{
this->base_reference() += -n;
}
template <class OtherIterator>
typename super_t::difference_type
distance_to(reverse_iterator<OtherIterator> const& y) const
{
return this->base_reference() - y.base();
}
};
template <class BidirectionalIterator>
reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
{
return reverse_iterator<BidirectionalIterator>(x);
}
} // namespace boost
#endif // BOOST_REVERSE_ITERATOR_23022003THW_HPP

0
boost/boost/mpl/eval_if.hpp Executable file → Normal file
View File

0
boost/boost/pointee.hpp Executable file → Normal file
View File

30
boost/boost/preprocessor/control/expr_if.hpp Normal file
View File

@ -0,0 +1,30 @@
# /* Copyright (C) 2001
# * Housemarque Oy
# * http://www.housemarque.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)
# */
#
# /* Revised by Paul Mensonides (2002) */
#
# /* See http://www.boost.org for most recent version. */
#
# ifndef BOOST_PREPROCESSOR_CONTROL_EXPR_IF_HPP
# define BOOST_PREPROCESSOR_CONTROL_EXPR_IF_HPP
#
# include <boost/preprocessor/config/config.hpp>
# include <boost/preprocessor/control/expr_iif.hpp>
# include <boost/preprocessor/logical/bool.hpp>
#
# /* BOOST_PP_EXPR_IF */
#
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
# define BOOST_PP_EXPR_IF(cond, expr) BOOST_PP_EXPR_IIF(BOOST_PP_BOOL(cond), expr)
# else
# define BOOST_PP_EXPR_IF(cond, expr) BOOST_PP_EXPR_IF_I(cond, expr)
# define BOOST_PP_EXPR_IF_I(cond, expr) BOOST_PP_EXPR_IIF(BOOST_PP_BOOL(cond), expr)
# endif
#
# endif

812
boost/boost/preprocessor/iteration/detail/local.hpp Normal file
View File

@ -0,0 +1,812 @@
# /* **************************************************************************
# * *
# * (C) Copyright Paul Mensonides 2002.
# * 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 for most recent version. */
#
# if !defined(BOOST_PP_LOCAL_LIMITS)
# error BOOST_PP_ERROR: local iteration boundaries are not defined
# elif !defined(BOOST_PP_LOCAL_MACRO)
# error BOOST_PP_ERROR: local iteration target macro is not defined
# else
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
# define BOOST_PP_LOCAL_S BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_LOCAL_LIMITS)
# define BOOST_PP_LOCAL_F BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_LOCAL_LIMITS)
# else
# define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_LOCAL_LIMITS)
# include <boost/preprocessor/iteration/detail/start.hpp>
# define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_LOCAL_LIMITS)
# include <boost/preprocessor/iteration/detail/finish.hpp>
# define BOOST_PP_LOCAL_S BOOST_PP_LOCAL_SE()
# define BOOST_PP_LOCAL_F BOOST_PP_LOCAL_FE()
# endif
# endif
#
# if (BOOST_PP_LOCAL_S) > (BOOST_PP_LOCAL_F)
# include <boost/preprocessor/iteration/detail/rlocal.hpp>
# else
# if BOOST_PP_LOCAL_C(0)
BOOST_PP_LOCAL_MACRO(0)
# endif
# if BOOST_PP_LOCAL_C(1)
BOOST_PP_LOCAL_MACRO(1)
# endif
# if BOOST_PP_LOCAL_C(2)
BOOST_PP_LOCAL_MACRO(2)
# endif
# if BOOST_PP_LOCAL_C(3)
BOOST_PP_LOCAL_MACRO(3)
# endif
# if BOOST_PP_LOCAL_C(4)
BOOST_PP_LOCAL_MACRO(4)
# endif
# if BOOST_PP_LOCAL_C(5)
BOOST_PP_LOCAL_MACRO(5)
# endif
# if BOOST_PP_LOCAL_C(6)
BOOST_PP_LOCAL_MACRO(6)
# endif
# if BOOST_PP_LOCAL_C(7)
BOOST_PP_LOCAL_MACRO(7)
# endif
# if BOOST_PP_LOCAL_C(8)
BOOST_PP_LOCAL_MACRO(8)
# endif
# if BOOST_PP_LOCAL_C(9)
BOOST_PP_LOCAL_MACRO(9)
# endif
# if BOOST_PP_LOCAL_C(10)
BOOST_PP_LOCAL_MACRO(10)
# endif
# if BOOST_PP_LOCAL_C(11)
BOOST_PP_LOCAL_MACRO(11)
# endif
# if BOOST_PP_LOCAL_C(12)
BOOST_PP_LOCAL_MACRO(12)
# endif
# if BOOST_PP_LOCAL_C(13)
BOOST_PP_LOCAL_MACRO(13)
# endif
# if BOOST_PP_LOCAL_C(14)
BOOST_PP_LOCAL_MACRO(14)
# endif
# if BOOST_PP_LOCAL_C(15)
BOOST_PP_LOCAL_MACRO(15)
# endif
# if BOOST_PP_LOCAL_C(16)
BOOST_PP_LOCAL_MACRO(16)
# endif
# if BOOST_PP_LOCAL_C(17)
BOOST_PP_LOCAL_MACRO(17)
# endif
# if BOOST_PP_LOCAL_C(18)
BOOST_PP_LOCAL_MACRO(18)
# endif
# if BOOST_PP_LOCAL_C(19)
BOOST_PP_LOCAL_MACRO(19)
# endif
# if BOOST_PP_LOCAL_C(20)
BOOST_PP_LOCAL_MACRO(20)
# endif
# if BOOST_PP_LOCAL_C(21)
BOOST_PP_LOCAL_MACRO(21)
# endif
# if BOOST_PP_LOCAL_C(22)
BOOST_PP_LOCAL_MACRO(22)
# endif
# if BOOST_PP_LOCAL_C(23)
BOOST_PP_LOCAL_MACRO(23)
# endif
# if BOOST_PP_LOCAL_C(24)
BOOST_PP_LOCAL_MACRO(24)
# endif
# if BOOST_PP_LOCAL_C(25)
BOOST_PP_LOCAL_MACRO(25)
# endif
# if BOOST_PP_LOCAL_C(26)
BOOST_PP_LOCAL_MACRO(26)
# endif
# if BOOST_PP_LOCAL_C(27)
BOOST_PP_LOCAL_MACRO(27)
# endif
# if BOOST_PP_LOCAL_C(28)
BOOST_PP_LOCAL_MACRO(28)
# endif
# if BOOST_PP_LOCAL_C(29)
BOOST_PP_LOCAL_MACRO(29)
# endif
# if BOOST_PP_LOCAL_C(30)
BOOST_PP_LOCAL_MACRO(30)
# endif
# if BOOST_PP_LOCAL_C(31)
BOOST_PP_LOCAL_MACRO(31)
# endif
# if BOOST_PP_LOCAL_C(32)
BOOST_PP_LOCAL_MACRO(32)
# endif
# if BOOST_PP_LOCAL_C(33)
BOOST_PP_LOCAL_MACRO(33)
# endif
# if BOOST_PP_LOCAL_C(34)
BOOST_PP_LOCAL_MACRO(34)
# endif
# if BOOST_PP_LOCAL_C(35)
BOOST_PP_LOCAL_MACRO(35)
# endif
# if BOOST_PP_LOCAL_C(36)
BOOST_PP_LOCAL_MACRO(36)
# endif
# if BOOST_PP_LOCAL_C(37)
BOOST_PP_LOCAL_MACRO(37)
# endif
# if BOOST_PP_LOCAL_C(38)
BOOST_PP_LOCAL_MACRO(38)
# endif
# if BOOST_PP_LOCAL_C(39)
BOOST_PP_LOCAL_MACRO(39)
# endif
# if BOOST_PP_LOCAL_C(40)
BOOST_PP_LOCAL_MACRO(40)
# endif
# if BOOST_PP_LOCAL_C(41)
BOOST_PP_LOCAL_MACRO(41)
# endif
# if BOOST_PP_LOCAL_C(42)
BOOST_PP_LOCAL_MACRO(42)
# endif
# if BOOST_PP_LOCAL_C(43)
BOOST_PP_LOCAL_MACRO(43)
# endif
# if BOOST_PP_LOCAL_C(44)
BOOST_PP_LOCAL_MACRO(44)
# endif
# if BOOST_PP_LOCAL_C(45)
BOOST_PP_LOCAL_MACRO(45)
# endif
# if BOOST_PP_LOCAL_C(46)
BOOST_PP_LOCAL_MACRO(46)
# endif
# if BOOST_PP_LOCAL_C(47)
BOOST_PP_LOCAL_MACRO(47)
# endif
# if BOOST_PP_LOCAL_C(48)
BOOST_PP_LOCAL_MACRO(48)
# endif
# if BOOST_PP_LOCAL_C(49)
BOOST_PP_LOCAL_MACRO(49)
# endif
# if BOOST_PP_LOCAL_C(50)
BOOST_PP_LOCAL_MACRO(50)
# endif
# if BOOST_PP_LOCAL_C(51)
BOOST_PP_LOCAL_MACRO(51)
# endif
# if BOOST_PP_LOCAL_C(52)
BOOST_PP_LOCAL_MACRO(52)
# endif
# if BOOST_PP_LOCAL_C(53)
BOOST_PP_LOCAL_MACRO(53)
# endif
# if BOOST_PP_LOCAL_C(54)
BOOST_PP_LOCAL_MACRO(54)
# endif
# if BOOST_PP_LOCAL_C(55)
BOOST_PP_LOCAL_MACRO(55)
# endif
# if BOOST_PP_LOCAL_C(56)
BOOST_PP_LOCAL_MACRO(56)
# endif
# if BOOST_PP_LOCAL_C(57)
BOOST_PP_LOCAL_MACRO(57)
# endif
# if BOOST_PP_LOCAL_C(58)
BOOST_PP_LOCAL_MACRO(58)
# endif
# if BOOST_PP_LOCAL_C(59)
BOOST_PP_LOCAL_MACRO(59)
# endif
# if BOOST_PP_LOCAL_C(60)
BOOST_PP_LOCAL_MACRO(60)
# endif
# if BOOST_PP_LOCAL_C(61)
BOOST_PP_LOCAL_MACRO(61)
# endif
# if BOOST_PP_LOCAL_C(62)
BOOST_PP_LOCAL_MACRO(62)
# endif
# if BOOST_PP_LOCAL_C(63)
BOOST_PP_LOCAL_MACRO(63)
# endif
# if BOOST_PP_LOCAL_C(64)
BOOST_PP_LOCAL_MACRO(64)
# endif
# if BOOST_PP_LOCAL_C(65)
BOOST_PP_LOCAL_MACRO(65)
# endif
# if BOOST_PP_LOCAL_C(66)
BOOST_PP_LOCAL_MACRO(66)
# endif
# if BOOST_PP_LOCAL_C(67)
BOOST_PP_LOCAL_MACRO(67)
# endif
# if BOOST_PP_LOCAL_C(68)
BOOST_PP_LOCAL_MACRO(68)
# endif
# if BOOST_PP_LOCAL_C(69)
BOOST_PP_LOCAL_MACRO(69)
# endif
# if BOOST_PP_LOCAL_C(70)
BOOST_PP_LOCAL_MACRO(70)
# endif
# if BOOST_PP_LOCAL_C(71)
BOOST_PP_LOCAL_MACRO(71)
# endif
# if BOOST_PP_LOCAL_C(72)
BOOST_PP_LOCAL_MACRO(72)
# endif
# if BOOST_PP_LOCAL_C(73)
BOOST_PP_LOCAL_MACRO(73)
# endif
# if BOOST_PP_LOCAL_C(74)
BOOST_PP_LOCAL_MACRO(74)
# endif
# if BOOST_PP_LOCAL_C(75)
BOOST_PP_LOCAL_MACRO(75)
# endif
# if BOOST_PP_LOCAL_C(76)
BOOST_PP_LOCAL_MACRO(76)
# endif
# if BOOST_PP_LOCAL_C(77)
BOOST_PP_LOCAL_MACRO(77)
# endif
# if BOOST_PP_LOCAL_C(78)
BOOST_PP_LOCAL_MACRO(78)
# endif
# if BOOST_PP_LOCAL_C(79)
BOOST_PP_LOCAL_MACRO(79)
# endif
# if BOOST_PP_LOCAL_C(80)
BOOST_PP_LOCAL_MACRO(80)
# endif
# if BOOST_PP_LOCAL_C(81)
BOOST_PP_LOCAL_MACRO(81)
# endif
# if BOOST_PP_LOCAL_C(82)
BOOST_PP_LOCAL_MACRO(82)
# endif
# if BOOST_PP_LOCAL_C(83)
BOOST_PP_LOCAL_MACRO(83)
# endif
# if BOOST_PP_LOCAL_C(84)
BOOST_PP_LOCAL_MACRO(84)
# endif
# if BOOST_PP_LOCAL_C(85)
BOOST_PP_LOCAL_MACRO(85)
# endif
# if BOOST_PP_LOCAL_C(86)
BOOST_PP_LOCAL_MACRO(86)
# endif
# if BOOST_PP_LOCAL_C(87)
BOOST_PP_LOCAL_MACRO(87)
# endif
# if BOOST_PP_LOCAL_C(88)
BOOST_PP_LOCAL_MACRO(88)
# endif
# if BOOST_PP_LOCAL_C(89)
BOOST_PP_LOCAL_MACRO(89)
# endif
# if BOOST_PP_LOCAL_C(90)
BOOST_PP_LOCAL_MACRO(90)
# endif
# if BOOST_PP_LOCAL_C(91)
BOOST_PP_LOCAL_MACRO(91)
# endif
# if BOOST_PP_LOCAL_C(92)
BOOST_PP_LOCAL_MACRO(92)
# endif
# if BOOST_PP_LOCAL_C(93)
BOOST_PP_LOCAL_MACRO(93)
# endif
# if BOOST_PP_LOCAL_C(94)
BOOST_PP_LOCAL_MACRO(94)
# endif
# if BOOST_PP_LOCAL_C(95)
BOOST_PP_LOCAL_MACRO(95)
# endif
# if BOOST_PP_LOCAL_C(96)
BOOST_PP_LOCAL_MACRO(96)
# endif
# if BOOST_PP_LOCAL_C(97)
BOOST_PP_LOCAL_MACRO(97)
# endif
# if BOOST_PP_LOCAL_C(98)
BOOST_PP_LOCAL_MACRO(98)
# endif
# if BOOST_PP_LOCAL_C(99)
BOOST_PP_LOCAL_MACRO(99)
# endif
# if BOOST_PP_LOCAL_C(100)
BOOST_PP_LOCAL_MACRO(100)
# endif
# if BOOST_PP_LOCAL_C(101)
BOOST_PP_LOCAL_MACRO(101)
# endif
# if BOOST_PP_LOCAL_C(102)
BOOST_PP_LOCAL_MACRO(102)
# endif
# if BOOST_PP_LOCAL_C(103)
BOOST_PP_LOCAL_MACRO(103)
# endif
# if BOOST_PP_LOCAL_C(104)
BOOST_PP_LOCAL_MACRO(104)
# endif
# if BOOST_PP_LOCAL_C(105)
BOOST_PP_LOCAL_MACRO(105)
# endif
# if BOOST_PP_LOCAL_C(106)
BOOST_PP_LOCAL_MACRO(106)
# endif
# if BOOST_PP_LOCAL_C(107)
BOOST_PP_LOCAL_MACRO(107)
# endif
# if BOOST_PP_LOCAL_C(108)
BOOST_PP_LOCAL_MACRO(108)
# endif
# if BOOST_PP_LOCAL_C(109)
BOOST_PP_LOCAL_MACRO(109)
# endif
# if BOOST_PP_LOCAL_C(110)
BOOST_PP_LOCAL_MACRO(110)
# endif
# if BOOST_PP_LOCAL_C(111)
BOOST_PP_LOCAL_MACRO(111)
# endif
# if BOOST_PP_LOCAL_C(112)
BOOST_PP_LOCAL_MACRO(112)
# endif
# if BOOST_PP_LOCAL_C(113)
BOOST_PP_LOCAL_MACRO(113)
# endif
# if BOOST_PP_LOCAL_C(114)
BOOST_PP_LOCAL_MACRO(114)
# endif
# if BOOST_PP_LOCAL_C(115)
BOOST_PP_LOCAL_MACRO(115)
# endif
# if BOOST_PP_LOCAL_C(116)
BOOST_PP_LOCAL_MACRO(116)
# endif
# if BOOST_PP_LOCAL_C(117)
BOOST_PP_LOCAL_MACRO(117)
# endif
# if BOOST_PP_LOCAL_C(118)
BOOST_PP_LOCAL_MACRO(118)
# endif
# if BOOST_PP_LOCAL_C(119)
BOOST_PP_LOCAL_MACRO(119)
# endif
# if BOOST_PP_LOCAL_C(120)
BOOST_PP_LOCAL_MACRO(120)
# endif
# if BOOST_PP_LOCAL_C(121)
BOOST_PP_LOCAL_MACRO(121)
# endif
# if BOOST_PP_LOCAL_C(122)
BOOST_PP_LOCAL_MACRO(122)
# endif
# if BOOST_PP_LOCAL_C(123)
BOOST_PP_LOCAL_MACRO(123)
# endif
# if BOOST_PP_LOCAL_C(124)
BOOST_PP_LOCAL_MACRO(124)
# endif
# if BOOST_PP_LOCAL_C(125)
BOOST_PP_LOCAL_MACRO(125)
# endif
# if BOOST_PP_LOCAL_C(126)
BOOST_PP_LOCAL_MACRO(126)
# endif
# if BOOST_PP_LOCAL_C(127)
BOOST_PP_LOCAL_MACRO(127)
# endif
# if BOOST_PP_LOCAL_C(128)
BOOST_PP_LOCAL_MACRO(128)
# endif
# if BOOST_PP_LOCAL_C(129)
BOOST_PP_LOCAL_MACRO(129)
# endif
# if BOOST_PP_LOCAL_C(130)
BOOST_PP_LOCAL_MACRO(130)
# endif
# if BOOST_PP_LOCAL_C(131)
BOOST_PP_LOCAL_MACRO(131)
# endif
# if BOOST_PP_LOCAL_C(132)
BOOST_PP_LOCAL_MACRO(132)
# endif
# if BOOST_PP_LOCAL_C(133)
BOOST_PP_LOCAL_MACRO(133)
# endif
# if BOOST_PP_LOCAL_C(134)
BOOST_PP_LOCAL_MACRO(134)
# endif
# if BOOST_PP_LOCAL_C(135)
BOOST_PP_LOCAL_MACRO(135)
# endif
# if BOOST_PP_LOCAL_C(136)
BOOST_PP_LOCAL_MACRO(136)
# endif
# if BOOST_PP_LOCAL_C(137)
BOOST_PP_LOCAL_MACRO(137)
# endif
# if BOOST_PP_LOCAL_C(138)
BOOST_PP_LOCAL_MACRO(138)
# endif
# if BOOST_PP_LOCAL_C(139)
BOOST_PP_LOCAL_MACRO(139)
# endif
# if BOOST_PP_LOCAL_C(140)
BOOST_PP_LOCAL_MACRO(140)
# endif
# if BOOST_PP_LOCAL_C(141)
BOOST_PP_LOCAL_MACRO(141)
# endif
# if BOOST_PP_LOCAL_C(142)
BOOST_PP_LOCAL_MACRO(142)
# endif
# if BOOST_PP_LOCAL_C(143)
BOOST_PP_LOCAL_MACRO(143)
# endif
# if BOOST_PP_LOCAL_C(144)
BOOST_PP_LOCAL_MACRO(144)
# endif
# if BOOST_PP_LOCAL_C(145)
BOOST_PP_LOCAL_MACRO(145)
# endif
# if BOOST_PP_LOCAL_C(146)
BOOST_PP_LOCAL_MACRO(146)
# endif
# if BOOST_PP_LOCAL_C(147)
BOOST_PP_LOCAL_MACRO(147)
# endif
# if BOOST_PP_LOCAL_C(148)
BOOST_PP_LOCAL_MACRO(148)
# endif
# if BOOST_PP_LOCAL_C(149)
BOOST_PP_LOCAL_MACRO(149)
# endif
# if BOOST_PP_LOCAL_C(150)
BOOST_PP_LOCAL_MACRO(150)
# endif
# if BOOST_PP_LOCAL_C(151)
BOOST_PP_LOCAL_MACRO(151)
# endif
# if BOOST_PP_LOCAL_C(152)
BOOST_PP_LOCAL_MACRO(152)
# endif
# if BOOST_PP_LOCAL_C(153)
BOOST_PP_LOCAL_MACRO(153)
# endif
# if BOOST_PP_LOCAL_C(154)
BOOST_PP_LOCAL_MACRO(154)
# endif
# if BOOST_PP_LOCAL_C(155)
BOOST_PP_LOCAL_MACRO(155)
# endif
# if BOOST_PP_LOCAL_C(156)
BOOST_PP_LOCAL_MACRO(156)
# endif
# if BOOST_PP_LOCAL_C(157)
BOOST_PP_LOCAL_MACRO(157)
# endif
# if BOOST_PP_LOCAL_C(158)
BOOST_PP_LOCAL_MACRO(158)
# endif
# if BOOST_PP_LOCAL_C(159)
BOOST_PP_LOCAL_MACRO(159)
# endif
# if BOOST_PP_LOCAL_C(160)
BOOST_PP_LOCAL_MACRO(160)
# endif
# if BOOST_PP_LOCAL_C(161)
BOOST_PP_LOCAL_MACRO(161)
# endif
# if BOOST_PP_LOCAL_C(162)
BOOST_PP_LOCAL_MACRO(162)
# endif
# if BOOST_PP_LOCAL_C(163)
BOOST_PP_LOCAL_MACRO(163)
# endif
# if BOOST_PP_LOCAL_C(164)
BOOST_PP_LOCAL_MACRO(164)
# endif
# if BOOST_PP_LOCAL_C(165)
BOOST_PP_LOCAL_MACRO(165)
# endif
# if BOOST_PP_LOCAL_C(166)
BOOST_PP_LOCAL_MACRO(166)
# endif
# if BOOST_PP_LOCAL_C(167)
BOOST_PP_LOCAL_MACRO(167)
# endif
# if BOOST_PP_LOCAL_C(168)
BOOST_PP_LOCAL_MACRO(168)
# endif
# if BOOST_PP_LOCAL_C(169)
BOOST_PP_LOCAL_MACRO(169)
# endif
# if BOOST_PP_LOCAL_C(170)
BOOST_PP_LOCAL_MACRO(170)
# endif
# if BOOST_PP_LOCAL_C(171)
BOOST_PP_LOCAL_MACRO(171)
# endif
# if BOOST_PP_LOCAL_C(172)
BOOST_PP_LOCAL_MACRO(172)
# endif
# if BOOST_PP_LOCAL_C(173)
BOOST_PP_LOCAL_MACRO(173)
# endif
# if BOOST_PP_LOCAL_C(174)
BOOST_PP_LOCAL_MACRO(174)
# endif
# if BOOST_PP_LOCAL_C(175)
BOOST_PP_LOCAL_MACRO(175)
# endif
# if BOOST_PP_LOCAL_C(176)
BOOST_PP_LOCAL_MACRO(176)
# endif
# if BOOST_PP_LOCAL_C(177)
BOOST_PP_LOCAL_MACRO(177)
# endif
# if BOOST_PP_LOCAL_C(178)
BOOST_PP_LOCAL_MACRO(178)
# endif
# if BOOST_PP_LOCAL_C(179)
BOOST_PP_LOCAL_MACRO(179)
# endif
# if BOOST_PP_LOCAL_C(180)
BOOST_PP_LOCAL_MACRO(180)
# endif
# if BOOST_PP_LOCAL_C(181)
BOOST_PP_LOCAL_MACRO(181)
# endif
# if BOOST_PP_LOCAL_C(182)
BOOST_PP_LOCAL_MACRO(182)
# endif
# if BOOST_PP_LOCAL_C(183)
BOOST_PP_LOCAL_MACRO(183)
# endif
# if BOOST_PP_LOCAL_C(184)
BOOST_PP_LOCAL_MACRO(184)
# endif
# if BOOST_PP_LOCAL_C(185)
BOOST_PP_LOCAL_MACRO(185)
# endif
# if BOOST_PP_LOCAL_C(186)
BOOST_PP_LOCAL_MACRO(186)
# endif
# if BOOST_PP_LOCAL_C(187)
BOOST_PP_LOCAL_MACRO(187)
# endif
# if BOOST_PP_LOCAL_C(188)
BOOST_PP_LOCAL_MACRO(188)
# endif
# if BOOST_PP_LOCAL_C(189)
BOOST_PP_LOCAL_MACRO(189)
# endif
# if BOOST_PP_LOCAL_C(190)
BOOST_PP_LOCAL_MACRO(190)
# endif
# if BOOST_PP_LOCAL_C(191)
BOOST_PP_LOCAL_MACRO(191)
# endif
# if BOOST_PP_LOCAL_C(192)
BOOST_PP_LOCAL_MACRO(192)
# endif
# if BOOST_PP_LOCAL_C(193)
BOOST_PP_LOCAL_MACRO(193)
# endif
# if BOOST_PP_LOCAL_C(194)
BOOST_PP_LOCAL_MACRO(194)
# endif
# if BOOST_PP_LOCAL_C(195)
BOOST_PP_LOCAL_MACRO(195)
# endif
# if BOOST_PP_LOCAL_C(196)
BOOST_PP_LOCAL_MACRO(196)
# endif
# if BOOST_PP_LOCAL_C(197)
BOOST_PP_LOCAL_MACRO(197)
# endif
# if BOOST_PP_LOCAL_C(198)
BOOST_PP_LOCAL_MACRO(198)
# endif
# if BOOST_PP_LOCAL_C(199)
BOOST_PP_LOCAL_MACRO(199)
# endif
# if BOOST_PP_LOCAL_C(200)
BOOST_PP_LOCAL_MACRO(200)
# endif
# if BOOST_PP_LOCAL_C(201)
BOOST_PP_LOCAL_MACRO(201)
# endif
# if BOOST_PP_LOCAL_C(202)
BOOST_PP_LOCAL_MACRO(202)
# endif
# if BOOST_PP_LOCAL_C(203)
BOOST_PP_LOCAL_MACRO(203)
# endif
# if BOOST_PP_LOCAL_C(204)
BOOST_PP_LOCAL_MACRO(204)
# endif
# if BOOST_PP_LOCAL_C(205)
BOOST_PP_LOCAL_MACRO(205)
# endif
# if BOOST_PP_LOCAL_C(206)
BOOST_PP_LOCAL_MACRO(206)
# endif
# if BOOST_PP_LOCAL_C(207)
BOOST_PP_LOCAL_MACRO(207)
# endif
# if BOOST_PP_LOCAL_C(208)
BOOST_PP_LOCAL_MACRO(208)
# endif
# if BOOST_PP_LOCAL_C(209)
BOOST_PP_LOCAL_MACRO(209)
# endif
# if BOOST_PP_LOCAL_C(210)
BOOST_PP_LOCAL_MACRO(210)
# endif
# if BOOST_PP_LOCAL_C(211)
BOOST_PP_LOCAL_MACRO(211)
# endif
# if BOOST_PP_LOCAL_C(212)
BOOST_PP_LOCAL_MACRO(212)
# endif
# if BOOST_PP_LOCAL_C(213)
BOOST_PP_LOCAL_MACRO(213)
# endif
# if BOOST_PP_LOCAL_C(214)
BOOST_PP_LOCAL_MACRO(214)
# endif
# if BOOST_PP_LOCAL_C(215)
BOOST_PP_LOCAL_MACRO(215)
# endif
# if BOOST_PP_LOCAL_C(216)
BOOST_PP_LOCAL_MACRO(216)
# endif
# if BOOST_PP_LOCAL_C(217)
BOOST_PP_LOCAL_MACRO(217)
# endif
# if BOOST_PP_LOCAL_C(218)
BOOST_PP_LOCAL_MACRO(218)
# endif
# if BOOST_PP_LOCAL_C(219)
BOOST_PP_LOCAL_MACRO(219)
# endif
# if BOOST_PP_LOCAL_C(220)
BOOST_PP_LOCAL_MACRO(220)
# endif
# if BOOST_PP_LOCAL_C(221)
BOOST_PP_LOCAL_MACRO(221)
# endif
# if BOOST_PP_LOCAL_C(222)
BOOST_PP_LOCAL_MACRO(222)
# endif
# if BOOST_PP_LOCAL_C(223)
BOOST_PP_LOCAL_MACRO(223)
# endif
# if BOOST_PP_LOCAL_C(224)
BOOST_PP_LOCAL_MACRO(224)
# endif
# if BOOST_PP_LOCAL_C(225)
BOOST_PP_LOCAL_MACRO(225)
# endif
# if BOOST_PP_LOCAL_C(226)
BOOST_PP_LOCAL_MACRO(226)
# endif
# if BOOST_PP_LOCAL_C(227)
BOOST_PP_LOCAL_MACRO(227)
# endif
# if BOOST_PP_LOCAL_C(228)
BOOST_PP_LOCAL_MACRO(228)
# endif
# if BOOST_PP_LOCAL_C(229)
BOOST_PP_LOCAL_MACRO(229)
# endif
# if BOOST_PP_LOCAL_C(230)
BOOST_PP_LOCAL_MACRO(230)
# endif
# if BOOST_PP_LOCAL_C(231)
BOOST_PP_LOCAL_MACRO(231)
# endif
# if BOOST_PP_LOCAL_C(232)
BOOST_PP_LOCAL_MACRO(232)
# endif
# if BOOST_PP_LOCAL_C(233)
BOOST_PP_LOCAL_MACRO(233)
# endif
# if BOOST_PP_LOCAL_C(234)
BOOST_PP_LOCAL_MACRO(234)
# endif
# if BOOST_PP_LOCAL_C(235)
BOOST_PP_LOCAL_MACRO(235)
# endif
# if BOOST_PP_LOCAL_C(236)
BOOST_PP_LOCAL_MACRO(236)
# endif
# if BOOST_PP_LOCAL_C(237)
BOOST_PP_LOCAL_MACRO(237)
# endif
# if BOOST_PP_LOCAL_C(238)
BOOST_PP_LOCAL_MACRO(238)
# endif
# if BOOST_PP_LOCAL_C(239)
BOOST_PP_LOCAL_MACRO(239)
# endif
# if BOOST_PP_LOCAL_C(240)
BOOST_PP_LOCAL_MACRO(240)
# endif
# if BOOST_PP_LOCAL_C(241)
BOOST_PP_LOCAL_MACRO(241)
# endif
# if BOOST_PP_LOCAL_C(242)
BOOST_PP_LOCAL_MACRO(242)
# endif
# if BOOST_PP_LOCAL_C(243)
BOOST_PP_LOCAL_MACRO(243)
# endif
# if BOOST_PP_LOCAL_C(244)
BOOST_PP_LOCAL_MACRO(244)
# endif
# if BOOST_PP_LOCAL_C(245)
BOOST_PP_LOCAL_MACRO(245)
# endif
# if BOOST_PP_LOCAL_C(246)
BOOST_PP_LOCAL_MACRO(246)
# endif
# if BOOST_PP_LOCAL_C(247)
BOOST_PP_LOCAL_MACRO(247)
# endif
# if BOOST_PP_LOCAL_C(248)
BOOST_PP_LOCAL_MACRO(248)
# endif
# if BOOST_PP_LOCAL_C(249)
BOOST_PP_LOCAL_MACRO(249)
# endif
# if BOOST_PP_LOCAL_C(250)
BOOST_PP_LOCAL_MACRO(250)
# endif
# if BOOST_PP_LOCAL_C(251)
BOOST_PP_LOCAL_MACRO(251)
# endif
# if BOOST_PP_LOCAL_C(252)
BOOST_PP_LOCAL_MACRO(252)
# endif
# if BOOST_PP_LOCAL_C(253)
BOOST_PP_LOCAL_MACRO(253)
# endif
# if BOOST_PP_LOCAL_C(254)
BOOST_PP_LOCAL_MACRO(254)
# endif
# if BOOST_PP_LOCAL_C(255)
BOOST_PP_LOCAL_MACRO(255)
# endif
# if BOOST_PP_LOCAL_C(256)
BOOST_PP_LOCAL_MACRO(256)
# endif
# endif
#
# undef BOOST_PP_LOCAL_LIMITS
#
# undef BOOST_PP_LOCAL_S
# undef BOOST_PP_LOCAL_F
#
# undef BOOST_PP_LOCAL_MACRO

26
boost/boost/preprocessor/iteration/local.hpp Normal file
View File

@ -0,0 +1,26 @@
# /* **************************************************************************
# * *
# * (C) Copyright Paul Mensonides 2002.
# * 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 for most recent version. */
#
# ifndef BOOST_PREPROCESSOR_ITERATION_LOCAL_HPP
# define BOOST_PREPROCESSOR_ITERATION_LOCAL_HPP
#
# include <boost/preprocessor/config/config.hpp>
# include <boost/preprocessor/slot/slot.hpp>
# include <boost/preprocessor/tuple/elem.hpp>
#
# /* BOOST_PP_LOCAL_ITERATE */
#
# define BOOST_PP_LOCAL_ITERATE() <boost/preprocessor/iteration/detail/local.hpp>
#
# define BOOST_PP_LOCAL_C(n) (BOOST_PP_LOCAL_S) <= n && (BOOST_PP_LOCAL_F) >= n
# define BOOST_PP_LOCAL_R(n) (BOOST_PP_LOCAL_F) <= n && (BOOST_PP_LOCAL_S) >= n
#
# endif

197
boost/boost/range/begin.hpp Normal file
View File

@ -0,0 +1,197 @@
// Boost.Range library
//
// Copyright Thorsten Ottosen 2003-2004. Use, modification and
// distribution is subject to 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)
//
// For more information, see http://www.boost.org/libs/range/
//
#ifndef BOOST_RANGE_BEGIN_HPP
#define BOOST_RANGE_BEGIN_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif
#include <boost/type_traits/remove_const.hpp>
#include <boost/range/config.hpp>
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#include <boost/range/detail/begin.hpp>
#else
#include <boost/range/iterator.hpp>
#include <boost/range/const_iterator.hpp>
namespace boost
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
!BOOST_WORKAROUND(__GNUC__, < 3) \
/**/
namespace range_detail
{
#endif
//////////////////////////////////////////////////////////////////////
// primary template
//////////////////////////////////////////////////////////////////////
template< typename C >
inline BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type
boost_range_begin( const C& c )
{
return c.begin();
}
template< typename C >
inline BOOST_DEDUCED_TYPENAME range_iterator<
typename remove_const<C>::type >::type
boost_range_begin( C& c )
{
return c.begin();
}
//////////////////////////////////////////////////////////////////////
// pair
//////////////////////////////////////////////////////////////////////
template< typename Iterator >
inline Iterator boost_range_begin( const std::pair<Iterator,Iterator>& p )
{
return p.first;
}
template< typename Iterator >
inline Iterator boost_range_begin( std::pair<Iterator,Iterator>& p )
{
return p.first;
}
//////////////////////////////////////////////////////////////////////
// array
//////////////////////////////////////////////////////////////////////
template< typename T, std::size_t sz >
inline const T* boost_range_begin( const T (&array)[sz] )
{
return array;
}
template< typename T, std::size_t sz >
inline T* boost_range_begin( T (&array)[sz] )
{
return array;
}
//////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////
#if 1 || BOOST_WORKAROUND(__MWERKS__, <= 0x3204 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
// CW up to 9.3 and borland have troubles with function ordering
inline const char* boost_range_begin( const char* s )
{
return s;
}
inline char* boost_range_begin( char* s )
{
return s;
}
inline const wchar_t* boost_range_begin( const wchar_t* s )
{
return s;
}
inline wchar_t* boost_range_begin( wchar_t* s )
{
return s;
}
#else
inline const char* boost_range_begin( const char*& s )
{
return s;
}
inline char* boost_range_begin( char*& s )
{
return s;
}
inline const wchar_t* boost_range_begin( const wchar_t*& s )
{
return s;
}
inline wchar_t* boost_range_begin( wchar_t*& s )
{
return s;
}
#endif
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
!BOOST_WORKAROUND(__GNUC__, < 3) \
/**/
} // namespace 'range_detail'
#endif
template< class T >
inline BOOST_DEDUCED_TYPENAME range_iterator<
typename remove_const<T>::type >::type begin( T& r )
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
!BOOST_WORKAROUND(__GNUC__, < 3) \
/**/
using namespace range_detail;
#endif
return boost_range_begin( r );
}
template< class T >
inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type begin( const T& r )
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
!BOOST_WORKAROUND(__GNUC__, < 3) \
/**/
using namespace range_detail;
#endif
return boost_range_begin( r );
}
#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
// BCB and CW are not able to overload pointer when class overloads are also available.
template<>
inline range_const_iterator<const char*>::type begin<const char*>( const char*& r )
{
return r;
}
template<>
inline range_const_iterator<const wchar_t*>::type begin<const wchar_t*>( const wchar_t*& r )
{
return r;
}
#endif
} // namespace boost
#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
namespace boost
{
template< class T >
inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
const_begin( const T& r )
{
return begin( r );
}
}
#endif

55
boost/boost/range/config.hpp Normal file
View File

@ -0,0 +1,55 @@
// Boost.Range library
//
// Copyright Thorsten Ottosen 2003-2004. Use, modification and
// distribution is subject to 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)
//
// For more information, see http://www.boost.org/libs/range/
//
#ifndef BOOST_RANGE_CONFIG_HPP
#define BOOST_RANGE_CONFIG_HPP
#include <boost/detail/workaround.hpp>
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif
#include <boost/config.hpp>
#ifdef BOOST_RANGE_DEDUCED_TYPENAME
#error "macro already defined!"
#endif
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
# define BOOST_RANGE_DEDUCED_TYPENAME typename
#else
# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) && !defined(_MSC_EXTENSIONS)
# define BOOST_RANGE_DEDUCED_TYPENAME typename
# else
# define BOOST_RANGE_DEDUCED_TYPENAME BOOST_DEDUCED_TYPENAME
# endif
#endif
#ifdef BOOST_RANGE_NO_ARRAY_SUPPORT
#error "macro already defined!"
#endif
//#if BOOST_WORKAROUND( BOOST_MSVC, <= 1200 ) || __MWERKS__ <= 0x3003
#if _MSC_VER <= 1300 && !defined( __COMO__ ) && !defined( __GNUC__ ) && __MWERKS__ <= 0x3003
#define BOOST_RANGE_NO_ARRAY_SUPPORT 1
#endif
#ifdef BOOST_RANGE_NO_ARRAY_SUPPORT
#define BOOST_RANGE_ARRAY_REF() (boost_range_array)
#define BOOST_RANGE_NO_STATIC_ASSERT
#else
#define BOOST_RANGE_ARRAY_REF() (&boost_range_array)
#endif
#endif

127
boost/boost/range/const_iterator.hpp Normal file
View File

@ -0,0 +1,127 @@
// Boost.Range library
//
// Copyright Thorsten Ottosen 2003-2004. Use, modification and
// distribution is subject to 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)
//
// For more information, see http://www.boost.org/libs/range/
//
#ifndef BOOST_RANGE_CONST_ITERATOR_HPP
#define BOOST_RANGE_CONST_ITERATOR_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif
#include <boost/range/config.hpp>
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#include <boost/range/detail/const_iterator.hpp>
#else
#include <cstddef>
#include <utility>
namespace boost
{
//////////////////////////////////////////////////////////////////////////
// default
//////////////////////////////////////////////////////////////////////////
template< typename C >
struct range_const_iterator
{
typedef BOOST_DEDUCED_TYPENAME C::const_iterator type;
};
//////////////////////////////////////////////////////////////////////////
// pair
//////////////////////////////////////////////////////////////////////////
template< typename Iterator >
struct range_const_iterator< std::pair<Iterator,Iterator> >
{
typedef Iterator type;
};
template< typename Iterator >
struct range_const_iterator< const std::pair<Iterator,Iterator> >
{
typedef Iterator type;
};
//////////////////////////////////////////////////////////////////////////
// array
//////////////////////////////////////////////////////////////////////////
template< typename T, std::size_t sz >
struct range_const_iterator< T[sz] >
{
typedef const T* type;
};
template< typename T, std::size_t sz >
struct range_const_iterator< const T[sz] >
{
typedef const T* type;
};
//////////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////////
template<>
struct range_const_iterator< char* >
{
typedef const char* type;
};
template<>
struct range_const_iterator< wchar_t* >
{
typedef const wchar_t* type;
};
template<>
struct range_const_iterator< const char* >
{
typedef const char* type;
};
template<>
struct range_const_iterator< const wchar_t* >
{
typedef const wchar_t* type;
};
template<>
struct range_const_iterator< char* const >
{
typedef const char* type;
};
template<>
struct range_const_iterator< wchar_t* const >
{
typedef const wchar_t* type;
};
template<>
struct range_const_iterator< const char* const >
{
typedef const char* type;
};
template<>
struct range_const_iterator< const wchar_t* const >
{
typedef const wchar_t* type;
};
} // namespace boost
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif

37
boost/boost/range/const_reverse_iterator.hpp Normal file
View File

@ -0,0 +1,37 @@
// Boost.Range library
//
// Copyright Thorsten Ottosen 2003-2004. Use, modification and
// distribution is subject to 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)
//
// For more information, see http://www.boost.org/libs/range/
//
#ifndef BOOST_RANGE_CONST_REVERSE_ITERATOR_HPP
#define BOOST_RANGE_CONST_REVERSE_ITERATOR_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif
#include <boost/range/config.hpp>
#include <boost/range/const_iterator.hpp>
#include <boost/iterator/reverse_iterator.hpp>
namespace boost
{
//////////////////////////////////////////////////////////////////////////
// default
//////////////////////////////////////////////////////////////////////////
template< typename C >
struct range_const_reverse_iterator
{
typedef reverse_iterator<
BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type > type;
};
} // namespace boost
#endif

116
boost/boost/range/detail/common.hpp Normal file
View File

@ -0,0 +1,116 @@
// Boost.Range library
//
// Copyright Thorsten Ottosen 2003-2004. Use, modification and
// distribution is subject to 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)
//
// For more information, see http://www.boost.org/libs/range/
//
#ifndef BOOST_RANGE_DETAIL_COMMON_HPP
#define BOOST_RANGE_DETAIL_COMMON_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif
#include <boost/range/config.hpp>
#include <boost/range/detail/sfinae.hpp>
#include <boost/type_traits/is_void.hpp>
#include <boost/type_traits/detail/ice_or.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/int.hpp>
#include <cstddef>
//////////////////////////////////////////////////////////////////////////////
// missing partial specialization workaround.
//////////////////////////////////////////////////////////////////////////////
namespace boost
{
namespace range_detail
{
// 1 = std containers
// 2 = std::pair
// 3 = const std::pair
// 4 = array
// 5 = const array
// 6 = char array
// 7 = wchar_t array
// 8 = char*
// 9 = const char*
// 10 = whar_t*
// 11 = const wchar_t*
// 12 = string
typedef mpl::int_<1>::type std_container_;
typedef mpl::int_<2>::type std_pair_;
typedef mpl::int_<3>::type const_std_pair_;
typedef mpl::int_<4>::type array_;
typedef mpl::int_<5>::type const_array_;
typedef mpl::int_<6>::type char_array_;
typedef mpl::int_<7>::type wchar_t_array_;
typedef mpl::int_<8>::type char_ptr_;
typedef mpl::int_<9>::type const_char_ptr_;
typedef mpl::int_<10>::type wchar_t_ptr_;
typedef mpl::int_<11>::type const_wchar_t_ptr_;
typedef mpl::int_<12>::type string_;
template< typename C >
struct range_helper
{
static C* c;
static C ptr;
BOOST_STATIC_CONSTANT( bool, is_pair_ = sizeof( boost::range_detail::is_pair_impl( c ) ) == sizeof( yes_type ) );
BOOST_STATIC_CONSTANT( bool, is_char_ptr_ = sizeof( boost::range_detail::is_char_ptr_impl( ptr ) ) == sizeof( yes_type ) );
BOOST_STATIC_CONSTANT( bool, is_const_char_ptr_ = sizeof( boost::range_detail::is_const_char_ptr_impl( ptr ) ) == sizeof( yes_type ) );
BOOST_STATIC_CONSTANT( bool, is_wchar_t_ptr_ = sizeof( boost::range_detail::is_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) );
BOOST_STATIC_CONSTANT( bool, is_const_wchar_t_ptr_ = sizeof( boost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) );
BOOST_STATIC_CONSTANT( bool, is_char_array_ = sizeof( boost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type ) );
BOOST_STATIC_CONSTANT( bool, is_wchar_t_array_ = sizeof( boost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type ) );
BOOST_STATIC_CONSTANT( bool, is_string_ = (boost::type_traits::ice_or<is_const_char_ptr_, is_const_wchar_t_ptr_>::value ));
BOOST_STATIC_CONSTANT( bool, is_array_ = boost::is_array<C>::value );
};
template< typename C >
class range
{
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< boost::range_detail::range_helper<C>::is_pair_,
boost::range_detail::std_pair_,
void >::type pair_t;
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< boost::range_detail::range_helper<C>::is_array_,
boost::range_detail::array_,
pair_t >::type array_t;
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< boost::range_detail::range_helper<C>::is_string_,
boost::range_detail::string_,
array_t >::type string_t;
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< boost::range_detail::range_helper<C>::is_const_char_ptr_,
boost::range_detail::const_char_ptr_,
string_t >::type const_char_ptr_t;
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< boost::range_detail::range_helper<C>::is_char_ptr_,
boost::range_detail::char_ptr_,
const_char_ptr_t >::type char_ptr_t;
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< boost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
boost::range_detail::const_wchar_t_ptr_,
char_ptr_t >::type const_wchar_ptr_t;
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< boost::range_detail::range_helper<C>::is_wchar_t_ptr_,
boost::range_detail::wchar_t_ptr_,
const_wchar_ptr_t >::type wchar_ptr_t;
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< boost::range_detail::range_helper<C>::is_wchar_t_array_,
boost::range_detail::wchar_t_array_,
wchar_ptr_t >::type wchar_array_t;
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< boost::range_detail::range_helper<C>::is_char_array_,
boost::range_detail::char_array_,
wchar_array_t >::type char_array_t;
public:
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< boost::is_void<char_array_t>::value,
boost::range_detail::std_container_,
char_array_t >::type type;
}; // class 'range'
}
}
#endif

162
boost/boost/range/detail/implementation_help.hpp Normal file
View File

@ -0,0 +1,162 @@
// Boost.Range library
//
// Copyright Thorsten Ottosen 2003-2004. Use, modification and
// distribution is subject to 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)
//
// For more information, see http://www.boost.org/libs/range/
//
#ifndef BOOST_RANGE_DETAIL_IMPLEMENTATION_HELP_HPP
#define BOOST_RANGE_DETAIL_IMPLEMENTATION_HELP_HPP
#include <boost/range/config.hpp>
#include <boost/range/detail/common.hpp>
#include <boost/type_traits/is_same.hpp>
#include <cstddef>
#include <string.h>
#ifndef BOOST_NO_CWCHAR
#include <wchar.h>
#endif
namespace boost
{
namespace range_detail
{
/////////////////////////////////////////////////////////////////////
// end() help
/////////////////////////////////////////////////////////////////////
inline const char* str_end( const char* s, const char* )
{
return s + strlen( s );
}
#ifndef BOOST_NO_CWCHAR
inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
{
return s + wcslen( s );
}
#else
inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
{
if( s == 0 && s[0] == 0 )
return s;
while( *++s != 0 )
;
return s;
}
#endif
template< class Char >
inline Char* str_end( Char* s )
{
return (Char*)str_end( s, s );
}
template< class T, std::size_t sz >
inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz], int )
{
return boost_range_array + sz;
}
template< class T, std::size_t sz >
inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz], int )
{
return boost_range_array + sz;
}
template< class T, std::size_t sz >
inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz], char_or_wchar_t_array_tag )
{
return boost_range_array + sz - 1;
}
template< class T, std::size_t sz >
inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz], char_or_wchar_t_array_tag )
{
return boost_range_array + sz - 1;
}
template< class T, std::size_t sz >
inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz] )
{
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< is_same<char,T>::value || is_same<wchar_t,T>::value,
char_or_wchar_t_array_tag,
int >::type tag;
return array_end<T,sz>( boost_range_array, tag() );
}
template< class T, std::size_t sz >
inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] )
{
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< is_same<char,T>::value || is_same<wchar_t,T>::value,
char_or_wchar_t_array_tag,
int >::type tag;
return array_end<T,sz>( boost_range_array, tag() );
}
/////////////////////////////////////////////////////////////////////
// size() help
/////////////////////////////////////////////////////////////////////
template< class Char >
inline std::size_t str_size( const Char* const& s )
{
return str_end( s ) - s;
}
template< class T, std::size_t sz >
inline std::size_t array_size( T BOOST_RANGE_ARRAY_REF()[sz], int )
{
return sz;
}
template< class T, std::size_t sz >
inline std::size_t array_size( const T BOOST_RANGE_ARRAY_REF()[sz], int )
{
return sz;
}
template< class T, std::size_t sz >
inline std::size_t array_size( T BOOST_RANGE_ARRAY_REF()[sz], char_or_wchar_t_array_tag )
{
return sz - 1;
}
template< class T, std::size_t sz >
inline std::size_t array_size( const T BOOST_RANGE_ARRAY_REF()[sz], char_or_wchar_t_array_tag )
{
return sz - 1;
}
template< class T, std::size_t sz >
inline std::size_t array_size( T BOOST_RANGE_ARRAY_REF()[sz] )
{
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< is_same<const char,T>::value || is_same<const wchar_t,T>::value ||
is_same<char,T>::value || is_same<wchar_t,T>::value,
char_or_wchar_t_array_tag,
int >::type tag;
return array_size<T,sz>( boost_range_array, tag() );
}
template< class T, std::size_t sz >
inline std::size_t array_size( const T BOOST_RANGE_ARRAY_REF()[sz] )
{
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< is_same<char,T>::value || is_same<wchar_t,T>::value,
char_or_wchar_t_array_tag,
int >::type tag;
return array_size<T,sz>( boost_range_array, tag() );
}
} // namespace 'range_detail'
} // namespace 'boost'
#endif

77
boost/boost/range/detail/sfinae.hpp Normal file
View File

@ -0,0 +1,77 @@
// Boost.Range library
//
// Copyright Thorsten Ottosen 2003-2004. Use, modification and
// distribution is subject to 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)
//
// For more information, see http://www.boost.org/libs/range/
//
#ifndef BOOST_RANGE_DETAIL_SFINAE_HPP
#define BOOST_RANGE_DETAIL_SFINAE_HPP
#include <boost/range/config.hpp>
#include <boost/type_traits/is_array.hpp>
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <utility>
namespace boost
{
namespace range_detail
{
using type_traits::yes_type;
using type_traits::no_type;
//////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////
yes_type is_string_impl( const char* const );
yes_type is_string_impl( const wchar_t* const );
no_type is_string_impl( ... );
template< std::size_t sz >
yes_type is_char_array_impl( char BOOST_RANGE_ARRAY_REF()[sz] );
template< std::size_t sz >
yes_type is_char_array_impl( const char BOOST_RANGE_ARRAY_REF()[sz] );
no_type is_char_array_impl( ... );
template< std::size_t sz >
yes_type is_wchar_t_array_impl( wchar_t BOOST_RANGE_ARRAY_REF()[sz] );
template< std::size_t sz >
yes_type is_wchar_t_array_impl( const wchar_t BOOST_RANGE_ARRAY_REF()[sz] );
no_type is_wchar_t_array_impl( ... );
yes_type is_char_ptr_impl( char* const );
no_type is_char_ptr_impl( ... );
yes_type is_const_char_ptr_impl( const char* const );
no_type is_const_char_ptr_impl( ... );
yes_type is_wchar_t_ptr_impl( wchar_t* const );
no_type is_wchar_t_ptr_impl( ... );
yes_type is_const_wchar_t_ptr_impl( const wchar_t* const );
no_type is_const_wchar_t_ptr_impl( ... );
//////////////////////////////////////////////////////////////////////
// pair
//////////////////////////////////////////////////////////////////////
template< typename Iterator >
yes_type is_pair_impl( const std::pair<Iterator,Iterator>* );
no_type is_pair_impl( ... );
//////////////////////////////////////////////////////////////////////
// tags
//////////////////////////////////////////////////////////////////////
struct char_or_wchar_t_array_tag {};
} // namespace 'range_detail'
} // namespace 'boost'
#endif

145
boost/boost/range/difference_type.hpp Normal file
View File

@ -0,0 +1,145 @@
// Boost.Range library
//
// Copyright Thorsten Ottosen 2003-2004. Use, modification and
// distribution is subject to 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)
//
// For more information, see http://www.boost.org/libs/range/
//
#ifndef BOOST_RANGE_DIFFERENCE_TYPE_HPP
#define BOOST_RANGE_DIFFERENCE_TYPE_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif
#include <boost/range/config.hpp>
#include <boost/range/const_iterator.hpp>
#include <boost/iterator/iterator_traits.hpp>
namespace boost
{
template< class T >
struct range_difference
{
typedef BOOST_DEDUCED_TYPENAME iterator_difference<
BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type >::type
type;
};
}
//#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
//#include <boost/range/detail/difference_type.hpp>
//#else
/*
#include <cstddef>
#include <utility>
namespace boost
{
//////////////////////////////////////////////////////////////////////////
// default
//////////////////////////////////////////////////////////////////////////
template< typename C >
struct range_difference
{
typedef BOOST_DEDUCED_TYPENAME C::difference_type type;
};
//////////////////////////////////////////////////////////////////////////
// pair
//////////////////////////////////////////////////////////////////////////
template< typename Iterator >
struct range_difference< std::pair<Iterator,Iterator> >
{
typedef BOOST_DEDUCED_TYPENAME
iterator_difference<Iterator>::type type;
};
template< typename Iterator >
struct range_difference< const std::pair<Iterator,Iterator> >
{
typedef BOOST_DEDUCED_TYPENAME
iterator_difference<Iterator>::type type;
};
//////////////////////////////////////////////////////////////////////////
// array
//////////////////////////////////////////////////////////////////////////
template< typename T, std::size_t sz >
struct range_difference< T[sz] >
{
typedef std::ptrdiff_t type;
};
template< typename T, std::size_t sz >
struct range_difference< const T[sz] >
{
typedef std::ptrdiff_t type;
};
//////////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////////
template<>
struct range_difference< char* >
{
typedef std::ptrdiff_t type;
};
template<>
struct range_difference< wchar_t* >
{
typedef std::ptrdiff_t type;
};
template<>
struct range_difference< const char* >
{
typedef std::ptrdiff_t type;
};
template<>
struct range_difference< const wchar_t* >
{
typedef std::ptrdiff_t type;
};
template<>
struct range_difference< char* const >
{
typedef std::ptrdiff_t type;
};
template<>
struct range_difference< wchar_t* const >
{
typedef std::ptrdiff_t type;
};
template<>
struct range_difference< const char* const >
{
typedef std::ptrdiff_t type;
};
template<>
struct range_difference< const wchar_t* const >
{
typedef std::ptrdiff_t type;
};
} // namespace boost
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
*/
#endif

Some files were not shown because too many files have changed in this diff Show More