239 lines
6.9 KiB
C++
239 lines
6.9 KiB
C++
// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
|
|
// (C) Copyright 2005-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.
|
|
|
|
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)
|
|
{
|
|
typedef typename detail::unwrapped_type<T>::type unwrapped;
|
|
return detail::read_device_impl<T>::inner<unwrapped>::get(detail::unwrap(t));
|
|
}
|
|
|
|
template<typename T>
|
|
inline std::streamsize
|
|
read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
|
|
{
|
|
typedef typename detail::unwrapped_type<T>::type unwrapped;
|
|
return detail::read_device_impl<T>::inner<unwrapped>::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)
|
|
{
|
|
typedef typename detail::unwrapped_type<T>::type unwrapped;
|
|
return detail::read_filter_impl<T>::inner<unwrapped>::read(detail::unwrap(t), src, s, n);
|
|
}
|
|
|
|
template<typename T>
|
|
bool putback(T& t, typename char_type_of<T>::type c)
|
|
{
|
|
typedef typename detail::unwrapped_type<T>::type unwrapped;
|
|
return detail::read_device_impl<T>::inner<unwrapped>::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>
|
|
struct inner {
|
|
static typename int_type_of<T>::type get(T& t)
|
|
{ return t.get(); }
|
|
|
|
static std::streamsize
|
|
read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
|
|
{ return check_eof(t.rdbuf()->sgetn(s, n)); }
|
|
|
|
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>
|
|
struct inner {
|
|
static typename int_type_of<T>::type
|
|
get(T& t)
|
|
{
|
|
typedef typename char_type_of<T>::type char_type;
|
|
typedef 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();
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
static bool putback(T& t, typename char_type_of<T>::type c)
|
|
{
|
|
typedef typename char_type_of<T>::type char_type;
|
|
typedef char_traits<char_type> traits_type;
|
|
return !traits_type::is_eof(t.sputbackc(c));
|
|
}
|
|
};
|
|
};
|
|
|
|
template<>
|
|
struct read_device_impl<input> {
|
|
template<typename T>
|
|
struct inner {
|
|
static typename int_type_of<T>::type
|
|
get(T& t)
|
|
{
|
|
typedef typename char_type_of<T>::type char_type;
|
|
typedef 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>
|
|
struct inner {
|
|
template<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>
|
|
struct inner {
|
|
template<typename Source>
|
|
static std::streamsize read
|
|
( T& t, Source& src, typename char_type_of<T>::type* s,
|
|
std::streamsize n )
|
|
{
|
|
typedef typename char_type_of<T>::type char_type;
|
|
typedef 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.
|