You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
281 lines
9.0 KiB
281 lines
9.0 KiB
// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com) |
|
// (C) Copyright 2003-2007 Jonathan Turkanis |
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying |
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.) |
|
|
|
// See http://www.boost.org/libs/iostreams for documentation. |
|
|
|
#ifndef BOOST_IOSTREAMS_DETAIL_DIRECT_ADAPTER_HPP_INCLUDED |
|
#define BOOST_IOSTREAMS_DETAIL_DIRECT_ADAPTER_HPP_INCLUDED |
|
|
|
#if defined(_MSC_VER) && (_MSC_VER >= 1020) |
|
# pragma once |
|
#endif |
|
|
|
#include <boost/config.hpp> // SFINAE, MSVC, put ptrdiff_t in std. |
|
#include <algorithm> // copy, min. |
|
#include <cstddef> // ptrdiff_t. |
|
#include <boost/detail/workaround.hpp> |
|
#include <boost/iostreams/categories.hpp> |
|
#include <boost/iostreams/detail/config/limits.hpp> // forwarding. |
|
#include <boost/iostreams/detail/config/wide_streams.hpp> // locale. |
|
#include <boost/iostreams/detail/double_object.hpp> |
|
#include <boost/iostreams/detail/error.hpp> |
|
#include <boost/iostreams/detail/ios.hpp> // openmode, seekdir, int types. |
|
#include <boost/iostreams/traits.hpp> // mode_of, is_direct. |
|
#include <boost/iostreams/operations.hpp> |
|
#include <boost/mpl/bool.hpp> |
|
#include <boost/mpl/or.hpp> |
|
#include <boost/preprocessor/iteration/local.hpp> |
|
#include <boost/preprocessor/repetition/enum_binary_params.hpp> |
|
#include <boost/preprocessor/repetition/enum_params.hpp> |
|
#include <boost/static_assert.hpp> |
|
#include <boost/throw_exception.hpp> |
|
#include <boost/type_traits/is_convertible.hpp> |
|
|
|
// Must come last. |
|
#include <boost/iostreams/detail/config/disable_warnings.hpp> // VC7.1 |
|
|
|
namespace boost { namespace iostreams { namespace detail { |
|
|
|
//------------------Definition of direct_adapter_base-------------------------// |
|
|
|
// Put all initialization in base class to faciliate forwarding. |
|
template<typename Direct> |
|
class direct_adapter_base { |
|
public: |
|
typedef typename char_type_of<Direct>::type char_type; |
|
typedef typename mode_of<Direct>::type mode_type; |
|
struct category |
|
: mode_type, |
|
device_tag, |
|
closable_tag |
|
#ifndef BOOST_IOSTREAMS_NO_LOCALE |
|
, localizable_tag |
|
#endif |
|
{ }; |
|
protected: |
|
explicit direct_adapter_base(const Direct& d); |
|
typedef is_convertible<category, two_sequence> is_double; |
|
struct pointers { |
|
char_type *beg, *ptr, *end; |
|
}; |
|
void init_input(mpl::true_); |
|
void init_input(mpl::false_) { } |
|
void init_output(mpl::true_); |
|
void init_output(mpl::false_) { } |
|
double_object<pointers, is_double> ptrs_; |
|
Direct d_; |
|
}; |
|
|
|
template<typename Direct> |
|
class direct_adapter : private direct_adapter_base<Direct> { |
|
private: |
|
typedef direct_adapter_base<Direct> base_type; |
|
typedef typename base_type::pointers pointers; |
|
typedef typename base_type::is_double is_double; |
|
using base_type::ptrs_; |
|
using base_type::d_; |
|
public: |
|
typedef typename base_type::char_type char_type; |
|
typedef typename base_type::category category; |
|
|
|
// Constructors |
|
|
|
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) |
|
direct_adapter(const Direct& d) : base_type(d) { } |
|
direct_adapter(const direct_adapter& d) : base_type(d) { } |
|
# define BOOST_PP_LOCAL_LIMITS (1, BOOST_IOSTREAMS_MAX_FORWARDING_ARITY) |
|
#else |
|
template<typename U> |
|
struct is_direct |
|
: mpl::or_< |
|
is_same<U, direct_adapter<Direct> >, |
|
is_same<U, Direct> |
|
> |
|
{ }; |
|
template<typename U> |
|
direct_adapter(const U& u) |
|
: base_type(forward(u, is_direct<U>())) |
|
{ } |
|
# define BOOST_PP_LOCAL_LIMITS (2, BOOST_IOSTREAMS_MAX_FORWARDING_ARITY) |
|
#endif |
|
|
|
#define BOOST_PP_LOCAL_MACRO(n) \ |
|
template<BOOST_PP_ENUM_PARAMS(n, typename P)> \ |
|
direct_adapter(BOOST_PP_ENUM_BINARY_PARAMS(n, const P, &p)) \ |
|
: base_type(Direct(BOOST_PP_ENUM_PARAMS(n, p))) \ |
|
{ } \ |
|
/**/ |
|
#include BOOST_PP_LOCAL_ITERATE() |
|
#undef BOOST_PP_LOCAL_MACRO |
|
|
|
// 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, BOOST_IOS::seekdir, |
|
BOOST_IOS::openmode = BOOST_IOS::in | BOOST_IOS::out ); |
|
void close(); |
|
void close(BOOST_IOS::openmode which); |
|
#ifndef BOOST_IOSTREAMS_NO_LOCALE |
|
void imbue(const std::locale&); |
|
#endif |
|
|
|
// Direct device access. |
|
|
|
Direct& operator*() { return d_; } |
|
Direct* operator->() { return &d_; } |
|
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1310) |
|
private: |
|
template<typename U> |
|
static Direct forward(const U& u, mpl::true_) { return u; } |
|
template<typename U> |
|
static Direct forward(const U& u, mpl::false_) { return Direct(u); } |
|
#endif |
|
}; |
|
|
|
//--------------Definition of wrap_direct and unwrap_direct-------------------// |
|
|
|
template<typename Device> |
|
struct wrap_direct_traits |
|
: mpl::if_< |
|
is_direct<Device>, |
|
direct_adapter<Device>, |
|
Device |
|
> |
|
{ }; |
|
|
|
template<typename Device> |
|
typename wrap_direct_traits<Device>::type |
|
inline wrap_direct(Device dev) |
|
{ |
|
typedef typename wrap_direct_traits<Device>::type type; |
|
return type(dev); |
|
} |
|
|
|
template<typename Device> |
|
inline Device& unwrap_direct(Device& d) { return d; } |
|
|
|
template<typename Device> |
|
inline Device& unwrap_direct(direct_adapter<Device>& d) { return *d; } |
|
|
|
//--------------Implementation of direct_adapter_base-------------------------// |
|
|
|
template<typename Direct> |
|
direct_adapter_base<Direct>::direct_adapter_base(const Direct& d) : d_(d) |
|
{ |
|
init_input(is_convertible<category, input>()); |
|
init_output(is_convertible<category, output>()); |
|
} |
|
|
|
template<typename Direct> |
|
void direct_adapter_base<Direct>::init_input(mpl::true_) |
|
{ |
|
std::pair<char_type*, char_type*> seq = iostreams::input_sequence(d_); |
|
ptrs_.first().beg = seq.first; |
|
ptrs_.first().ptr = seq.first; |
|
ptrs_.first().end = seq.second; |
|
} |
|
|
|
template<typename Direct> |
|
void direct_adapter_base<Direct>::init_output(mpl::true_) |
|
{ |
|
std::pair<char_type*, char_type*> seq = iostreams::output_sequence(d_); |
|
ptrs_.second().beg = seq.first; |
|
ptrs_.second().ptr = seq.first; |
|
ptrs_.second().end = seq.second; |
|
} |
|
|
|
//--------------Implementation of direct_adapter------------------------------// |
|
|
|
template<typename Direct> |
|
inline std::streamsize direct_adapter<Direct>::read |
|
(char_type* s, std::streamsize n) |
|
{ |
|
using namespace std; |
|
pointers& get = ptrs_.first(); |
|
std::streamsize avail = |
|
static_cast<std::streamsize>(get.end - get.ptr); |
|
std::streamsize result = (std::min)(n, avail); |
|
std::copy(get.ptr, get.ptr + result, s); |
|
get.ptr += result; |
|
return result != 0 ? result : -1; |
|
} |
|
|
|
template<typename Direct> |
|
inline std::streamsize direct_adapter<Direct>::write |
|
(const char_type* s, std::streamsize n) |
|
{ |
|
using namespace std; |
|
pointers& put = ptrs_.second(); |
|
if (n > static_cast<std::streamsize>(put.end - put.ptr)) |
|
boost::throw_exception(write_area_exhausted()); |
|
std::copy(s, s + n, put.ptr); |
|
put.ptr += n; |
|
return n; |
|
} |
|
|
|
template<typename Direct> |
|
inline std::streampos direct_adapter<Direct>::seek |
|
( stream_offset off, BOOST_IOS::seekdir way, |
|
BOOST_IOS::openmode which ) |
|
{ |
|
using namespace std; |
|
pointers& get = ptrs_.first(); |
|
pointers& put = ptrs_.second(); |
|
if (way == BOOST_IOS::cur && get.ptr != put.ptr) |
|
boost::throw_exception(bad_seek()); |
|
ptrdiff_t next = 0; |
|
if ((which & BOOST_IOS::in) || !is_double::value) { |
|
if (way == BOOST_IOS::beg) |
|
next = off; |
|
else if (way == BOOST_IOS::cur) |
|
next = get.ptr - get.beg + off; |
|
else |
|
next = get.end - get.beg + off; |
|
if (next >= 0 && next <= get.end - get.beg) |
|
get.ptr = get.beg + next; |
|
else |
|
boost::throw_exception(bad_seek()); |
|
} |
|
if ((which & BOOST_IOS::out) && is_double::value) { |
|
if (way == BOOST_IOS::beg) |
|
next = off; |
|
else if (way == BOOST_IOS::cur) |
|
next = put.ptr - put.beg + off; |
|
else |
|
next = put.end - put.beg + off; |
|
if (next >= 0 && next <= put.end - put.beg) |
|
put.ptr = put.beg + next; |
|
else |
|
boost::throw_exception(bad_seek()); |
|
} |
|
return offset_to_position(next); |
|
} |
|
|
|
template<typename Direct> |
|
void direct_adapter<Direct>::close() |
|
{ |
|
BOOST_STATIC_ASSERT((!is_convertible<category, two_sequence>::value)); |
|
detail::close_all(d_); |
|
} |
|
|
|
template<typename Direct> |
|
void direct_adapter<Direct>::close(BOOST_IOS::openmode which) |
|
{ |
|
BOOST_STATIC_ASSERT((is_convertible<category, two_sequence>::value)); |
|
boost::iostreams::close(d_, which); |
|
} |
|
|
|
#ifndef BOOST_IOSTREAMS_NO_LOCALE |
|
template<typename Direct> |
|
void direct_adapter<Direct>::imbue(const std::locale& loc) |
|
{ boost::iostreams::imbue(d_, loc); } |
|
#endif |
|
|
|
} } } // End namespaces detail, iostreams, boost. |
|
|
|
#include <boost/iostreams/detail/config/enable_warnings.hpp> |
|
|
|
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_DIRECT_ADAPTER_HPP_INCLUDED
|
|
|