feedc0de/boost_tuple
1
0
Fork 0
forked from boostorg/tuple
Code Pull Requests Activity

Remove use of obsolete BOOST_NO_TEMPLATED_STREAMS macro.

Browse Source 
It was only defined for no-longer-supported-gcc.

[SVN r86062]
This commit is contained in:
Stephen Kelly
2013-09-30 15:56:52 +00:00
parent 40e5cd5e6c
commit 2f49af7db8
1 changed files with 0 additions and 235 deletions
Download Patch File Download Diff File Expand all files Collapse all files

235
include/boost/tuple/tuple_io.hpp
View File

@ -13,21 +13,8 @@
#ifndef BOOST_TUPLE_IO_HPP #ifndef BOOST_TUPLE_IO_HPP
#define BOOST_TUPLE_IO_HPP #define BOOST_TUPLE_IO_HPP
// add to boost/config.hpp
// for now
# if defined __GNUC__
# if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97)
#define BOOST_NO_TEMPLATED_STREAMS
#endif
#endif // __GNUC__
#if defined BOOST_NO_TEMPLATED_STREAMS
#include <iostream>
#else
#include <istream> #include <istream>
#include <ostream> #include <ostream>
#endif
#include <sstream> #include <sstream>
@ -76,25 +63,6 @@ private:
public: public:
#if defined (BOOST_NO_TEMPLATED_STREAMS)
static char get_manipulator(std::ios& i, manipulator_type m) {
char c = static_cast<char>(i.iword(get_stream_index(m)));
// parentheses and space are the default manipulators
if (!c) {
switch(m) {
case detail::format_info::open : c = '('; break;
case detail::format_info::close : c = ')'; break;
case detail::format_info::delimiter : c = ' '; break;
}
}
return c;
}
static void set_manipulator(std::ios& i, manipulator_type m, char c) {
i.iword(get_stream_index(m)) = static_cast<long>(c);
}
#else
template<class CharType, class CharTrait> template<class CharType, class CharTrait>
static CharType get_manipulator(std::basic_ios<CharType, CharTrait>& i, static CharType get_manipulator(std::basic_ios<CharType, CharTrait>& i,
manipulator_type m) { manipulator_type m) {
@ -124,7 +92,6 @@ public:
// convertible long. // convertible long.
i.iword(get_stream_index(m)) = static_cast<long>(c); i.iword(get_stream_index(m)) = static_cast<long>(c);
} }
#endif // BOOST_NO_TEMPLATED_STREAMS
}; };
} // end of namespace detail } // end of namespace detail
@ -138,11 +105,6 @@ public:
const char c = 0) const char c = 0)
: mt(m), f_c(c) {} : mt(m), f_c(c) {}
#if defined (BOOST_NO_TEMPLATED_STREAMS)
void set(std::ios &io) const {
detail::format_info::set_manipulator(io, mt, f_c);
}
#else
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template<class CharType2, class CharTrait> template<class CharType2, class CharTrait>
void set(std::basic_ios<CharType2, CharTrait> &io) const { void set(std::basic_ios<CharType2, CharTrait> &io) const {
@ -154,23 +116,8 @@ public:
detail::format_info::set_manipulator(io, mt, f_c); detail::format_info::set_manipulator(io, mt, f_c);
} }
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif // BOOST_NO_TEMPLATED_STREAMS
}; };
#if defined (BOOST_NO_TEMPLATED_STREAMS)
inline std::ostream&
operator<<(std::ostream& o, const tuple_manipulator<char>& m) {
m.set(o);
return o;
}
inline std::istream&
operator>>(std::istream& i, const tuple_manipulator<char>& m) {
m.set(i);
return i;
}
#else
template<class CharType, class CharTrait> template<class CharType, class CharTrait>
inline std::basic_ostream<CharType, CharTrait>& inline std::basic_ostream<CharType, CharTrait>&
@ -186,7 +133,6 @@ operator>>(std::basic_istream<CharType, CharTrait>& i, const tuple_manipulator<C
return i; return i;
} }
#endif // BOOST_NO_TEMPLATED_STREAMS
template<class CharType> template<class CharType>
inline tuple_manipulator<CharType> set_open(const CharType c) { inline tuple_manipulator<CharType> set_open(const CharType c) {
@ -217,54 +163,6 @@ namespace detail {
// Note: The order of the print functions is critical // Note: The order of the print functions is critical
// to let a conforming compiler find and select the correct one. // to let a conforming compiler find and select the correct one.
#if defined (BOOST_NO_TEMPLATED_STREAMS)
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template<class T1>
inline std::ostream& print(std::ostream& o, const cons<T1, null_type>& t) {
return o << t.head;
}
#endif // BOOST_NO_TEMPLATED_STREAMS
inline std::ostream& print(std::ostream& o, const null_type&) { return o; }
template<class T1, class T2>
inline std::ostream&
print(std::ostream& o, const cons<T1, T2>& t) {
const char d = format_info::get_manipulator(o, format_info::delimiter);
o << t.head;
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
if (tuples::length<T2>::value == 0)
return o;
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
o << d;
return print(o, t.tail );
}
template<class T>
inline bool handle_width(std::ostream& o, const T& t) {
std::streamsize width = o.width();
if(width == 0) return false;
std::ostringstream ss;
ss.copyfmt(o);
ss.tie(0);
ss.width(0);
ss << t;
o << ss.str();
return true;
}
#else
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template<class CharType, class CharTrait, class T1> template<class CharType, class CharTrait, class T1>
@ -315,47 +213,9 @@ inline bool handle_width(std::basic_ostream<CharT, Traits>& o, const T& t) {
return true; return true;
} }
#endif // BOOST_NO_TEMPLATED_STREAMS
} // namespace detail } // namespace detail
#if defined (BOOST_NO_TEMPLATED_STREAMS)
inline std::ostream& operator<<(std::ostream& o, const null_type& t) {
if (!o.good() ) return o;
if (detail::handle_width(o, t)) return o;
const char l =
detail::format_info::get_manipulator(o, detail::format_info::open);
const char r =
detail::format_info::get_manipulator(o, detail::format_info::close);
o << l;
o << r;
return o;
}
template<class T1, class T2>
inline std::ostream& operator<<(std::ostream& o, const cons<T1, T2>& t) {
if (!o.good() ) return o;
if (detail::handle_width(o, t)) return o;
const char l =
detail::format_info::get_manipulator(o, detail::format_info::open);
const char r =
detail::format_info::get_manipulator(o, detail::format_info::close);
o << l;
detail::print(o, t);
o << r;
return o;
}
#else
template<class CharType, class CharTrait> template<class CharType, class CharTrait>
inline std::basic_ostream<CharType, CharTrait>& inline std::basic_ostream<CharType, CharTrait>&
@ -395,7 +255,6 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,
return o; return o;
} }
#endif // BOOST_NO_TEMPLATED_STREAMS
// ------------------------------------------------------------- // -------------------------------------------------------------
@ -403,99 +262,6 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,
namespace detail { namespace detail {
#if defined (BOOST_NO_TEMPLATED_STREAMS)
inline std::istream&
extract_and_check_delimiter(
std::istream& is, format_info::manipulator_type del)
{
const char d = format_info::get_manipulator(is, del);
#if defined (BOOST_NO_STD_LOCALE)
const bool is_delimiter = !isspace(d);
#else
const bool is_delimiter = (!std::isspace(d, is.getloc()) );
#endif
char c;
if (is_delimiter) {
is >> c;
if (is.good() && c!=d) {
is.setstate(std::ios::failbit);
}
} else {
is >> std::ws;
}
return is;
}
// Note: The order of the read functions is critical to let a
// (conforming?) compiler find and select the correct one.
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template<class T1>
inline std::istream &
read (std::istream &is, cons<T1, null_type>& t1) {
if (!is.good()) return is;
return is >> t1.head ;
}
#else
inline std::istream& read(std::istream& i, const null_type&) { return i; }
#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template<class T1, class T2>
inline std::istream&
read(std::istream &is, cons<T1, T2>& t1) {
if (!is.good()) return is;
is >> t1.head;
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
if (tuples::length<T2>::value == 0)
return is;
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
extract_and_check_delimiter(is, format_info::delimiter);
return read(is, t1.tail);
}
} // end namespace detail
inline std::istream&
operator>>(std::istream &is, null_type&) {
if (!is.good() ) return is;
detail::extract_and_check_delimiter(is, detail::format_info::open);
detail::extract_and_check_delimiter(is, detail::format_info::close);
return is;
}
template<class T1, class T2>
inline std::istream&
operator>>(std::istream& is, cons<T1, T2>& t1) {
if (!is.good() ) return is;
detail::extract_and_check_delimiter(is, detail::format_info::open);
detail::read(is, t1);
detail::extract_and_check_delimiter(is, detail::format_info::close);
return is;
}
#else
template<class CharType, class CharTrait> template<class CharType, class CharTrait>
inline std::basic_istream<CharType, CharTrait>& inline std::basic_istream<CharType, CharTrait>&
@ -590,7 +356,6 @@ operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {
return is; return is;
} }
#endif // BOOST_NO_TEMPLATED_STREAMS
} // end of namespace tuples } // end of namespace tuples
} // end of namespace boost } // end of namespace boost