From 158c7ef640a0d147af11044d6c62723c07a10473 Mon Sep 17 00:00:00 2001 From: Joel de Guzman Date: Sun, 13 Mar 2016 08:03:26 +0800 Subject: [PATCH] Fixes Ticket #12064 --- include/boost/tuple/detail/tuple_basic.hpp | 10 +- include/boost/tuple/tuple.hpp | 16 +-- include/boost/tuple/tuple_comparison.hpp | 16 +-- include/boost/tuple/tuple_io.hpp | 126 ++++++++++----------- 4 files changed, 82 insertions(+), 86 deletions(-) diff --git a/include/boost/tuple/detail/tuple_basic.hpp b/include/boost/tuple/detail/tuple_basic.hpp index a688309..879f0e9 100644 --- a/include/boost/tuple/detail/tuple_basic.hpp +++ b/include/boost/tuple/detail/tuple_basic.hpp @@ -35,11 +35,11 @@ #include // needed for the assignment from pair to tuple -#include "boost/type_traits/cv_traits.hpp" -#include "boost/type_traits/function_traits.hpp" -#include "boost/utility/swap.hpp" +#include +#include +#include -#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND +#include // needed for BOOST_WORKAROUND #if defined(BOOST_GCC) && (BOOST_GCC >= 40700) #pragma GCC diagnostic push @@ -985,5 +985,3 @@ inline void swap(tuple& lhs, #endif // BOOST_TUPLE_BASIC_HPP - - diff --git a/include/boost/tuple/tuple.hpp b/include/boost/tuple/tuple.hpp index 433d4b3..d71e7df 100644 --- a/include/boost/tuple/tuple.hpp +++ b/include/boost/tuple/tuple.hpp @@ -8,7 +8,7 @@ // For more information, see http://www.boost.org -// ----------------------------------------------------------------- +// ----------------------------------------------------------------- #ifndef BOOST_TUPLE_HPP #define BOOST_TUPLE_HPP @@ -20,15 +20,15 @@ namespace boost { namespace python { class tuple; }} #endif -#include "boost/config.hpp" -#include "boost/static_assert.hpp" +#include +#include // other compilers -#include "boost/ref.hpp" -#include "boost/tuple/detail/tuple_basic.hpp" +#include +#include -namespace boost { +namespace boost { using tuples::tuple; using tuples::make_tuple; @@ -47,7 +47,7 @@ inline typename tuples::access_traits< >::non_const_type get(tuples::cons& c) { return tuples::get(c); -} +} // get function for const cons-lists, returns a const reference to // the element. If the element is a reference, returns the reference // as such (that is, can return a non-const reference) @@ -60,7 +60,7 @@ get(const tuples::cons& c) { } #endif // BOOST_NO_USING_TEMPLATE - + } // end namespace boost diff --git a/include/boost/tuple/tuple_comparison.hpp b/include/boost/tuple/tuple_comparison.hpp index 73723a1..0a61952 100644 --- a/include/boost/tuple/tuple_comparison.hpp +++ b/include/boost/tuple/tuple_comparison.hpp @@ -1,31 +1,31 @@ // tuple_comparison.hpp ----------------------------------------------------- -// +// // Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) // Copyright (C) 2001 Gary Powell (gary.powell@sierra.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) -// +// // For more information, see http://www.boost.org -// +// // (The idea and first impl. of comparison operators was from Doug Gregor) -// ----------------------------------------------------------------- +// ----------------------------------------------------------------- #ifndef BOOST_TUPLE_COMPARISON_HPP #define BOOST_TUPLE_COMPARISON_HPP -#include "boost/tuple/tuple.hpp" +#include // ------------------------------------------------------------- -// equality and comparison operators +// equality and comparison operators // // == and != compare tuples elementwise // <, >, <= and >= use lexicographical ordering // // Any operator between tuples of different length fails at compile time -// No dependencies between operators are assumed +// No dependencies between operators are assumed // (i.e. !(a=b, a!=b does not imply a==b etc. // so any weirdnesses of elementary operators are respected). // @@ -46,7 +46,7 @@ inline bool operator>(const null_type&, const null_type&) { return false; } namespace detail { // comparison operators check statically the length of its operands and // delegate the comparing task to the following functions. Hence - // the static check is only made once (should help the compiler). + // the static check is only made once (should help the compiler). // These functions assume tuples to be of the same length. diff --git a/include/boost/tuple/tuple_io.hpp b/include/boost/tuple/tuple_io.hpp index 99cf36c..f21c7ed 100644 --- a/include/boost/tuple/tuple_io.hpp +++ b/include/boost/tuple/tuple_io.hpp @@ -6,7 +6,7 @@ // 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) -// For more information, see http://www.boost.org +// For more information, see http://www.boost.org // ---------------------------------------------------------------------------- @@ -18,11 +18,11 @@ #include -#include "boost/tuple/tuple.hpp" +#include // This is ugly: one should be using twoargument isspace since whitspace can // be locale dependent, in theory at least. -// not all libraries implement have the two-arg version, so we need to +// not all libraries implement have the two-arg version, so we need to // use the one-arg one, which one should get with but there seem // to be exceptions to this. @@ -30,9 +30,9 @@ #include // for two-arg isspace -#else +#else -#include // for one-arg (old) isspace +#include // for one-arg (old) isspace #include // Metrowerks does not find one-arg isspace from cctype #endif @@ -43,12 +43,12 @@ namespace tuples { namespace detail { class format_info { -public: +public: enum manipulator_type { open, close, delimiter }; BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1); private: - + static int get_stream_index (int m) { static const int stream_index[number_of_manipulators] @@ -58,19 +58,19 @@ private: } format_info(const format_info&); - format_info(); + format_info(); public: template - static CharType get_manipulator(std::basic_ios& i, + static CharType get_manipulator(std::basic_ios& i, manipulator_type m) { // The manipulators are stored as long. // A valid instanitation of basic_stream allows CharType to be any POD, - // hence, the static_cast may fail (it fails if long is not convertible + // hence, the static_cast may fail (it fails if long is not convertible // to CharType - CharType c = static_cast(i.iword(get_stream_index(m)) ); + CharType c = static_cast(i.iword(get_stream_index(m)) ); // parentheses and space are the default manipulators if (!c) { switch(m) { @@ -84,27 +84,27 @@ public: template - static void set_manipulator(std::basic_ios& i, + static void set_manipulator(std::basic_ios& i, manipulator_type m, CharType c) { // The manipulators are stored as long. // A valid instanitation of basic_stream allows CharType to be any POD, - // hence, the static_cast may fail (it fails if CharType is not + // hence, the static_cast may fail (it fails if CharType is not // convertible long. i.iword(get_stream_index(m)) = static_cast(c); } }; } // end of namespace detail - -template + +template class tuple_manipulator { const detail::format_info::manipulator_type mt; CharType f_c; public: - explicit tuple_manipulator(detail::format_info::manipulator_type m, + explicit tuple_manipulator(detail::format_info::manipulator_type m, const char c = 0) : mt(m), f_c(c) {} - + template void set(std::basic_ios &io) const { detail::format_info::set_manipulator(io, mt, f_c); @@ -126,7 +126,7 @@ operator>>(std::basic_istream& i, const tuple_manipulator inline tuple_manipulator set_open(const CharType c) { return tuple_manipulator(detail::format_info::open, c); @@ -144,38 +144,38 @@ inline tuple_manipulator set_delimiter(const CharType c) { - - + + // ------------------------------------------------------------- // printing tuples to ostream in format (a b c) // parentheses and space are defaults, but can be overriden with manipulators // set_open, set_close and set_delimiter - + 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. template -inline std::basic_ostream& +inline std::basic_ostream& print(std::basic_ostream& o, const cons& t) { return o << t.head; } - + template -inline std::basic_ostream& -print(std::basic_ostream& o, const null_type&) { - return o; +inline std::basic_ostream& +print(std::basic_ostream& o, const null_type&) { + return o; } template -inline std::basic_ostream& +inline std::basic_ostream& print(std::basic_ostream& o, const cons& t) { - + const CharType d = format_info::get_manipulator(o, format_info::delimiter); - + o << t.head; o << d; @@ -205,17 +205,17 @@ inline bool handle_width(std::basic_ostream& o, const T& t) { template -inline std::basic_ostream& -operator<<(std::basic_ostream& o, +inline std::basic_ostream& +operator<<(std::basic_ostream& o, const null_type& t) { if (!o.good() ) return o; if (detail::handle_width(o, t)) return o; - - const CharType l = + + const CharType l = detail::format_info::get_manipulator(o, detail::format_info::open); - const CharType r = + const CharType r = detail::format_info::get_manipulator(o, detail::format_info::close); - + o << l; o << r; @@ -223,27 +223,27 @@ operator<<(std::basic_ostream& o, } template -inline std::basic_ostream& -operator<<(std::basic_ostream& o, +inline std::basic_ostream& +operator<<(std::basic_ostream& o, const cons& t) { if (!o.good() ) return o; if (detail::handle_width(o, t)) return o; - - const CharType l = - detail::format_info::get_manipulator(o, detail::format_info::open); - const CharType r = - detail::format_info::get_manipulator(o, detail::format_info::close); - - o << l; - detail::print(o, t); + const CharType l = + detail::format_info::get_manipulator(o, detail::format_info::open); + const CharType r = + detail::format_info::get_manipulator(o, detail::format_info::close); + + o << l; + + detail::print(o, t); o << r; return o; } - + // ------------------------------------------------------------- // input stream operators @@ -251,7 +251,7 @@ namespace detail { template -inline std::basic_istream& +inline std::basic_istream& extract_and_check_delimiter( std::basic_istream &is, format_info::manipulator_type del) { @@ -263,13 +263,13 @@ extract_and_check_delimiter( const bool is_delimiter = !std::use_facet< std::ctype< CharType > > (is.getloc() ).is( std::ctype_base::space, d); #else - const bool is_delimiter = (!std::isspace(d, is.getloc()) ); + const bool is_delimiter = (!std::isspace(d, is.getloc()) ); #endif CharType c; - if (is_delimiter) { + if (is_delimiter) { is >> c; - if (is.good() && c!=d) { + if (is.good() && c!=d) { is.setstate(std::ios::failbit); } } else { @@ -278,22 +278,22 @@ extract_and_check_delimiter( return is; } - + template -inline std::basic_istream & +inline std::basic_istream & read (std::basic_istream &is, cons& t1) { - if (!is.good()) return is; - - return is >> t1.head; + if (!is.good()) return is; + + return is >> t1.head; } template -inline std::basic_istream& +inline std::basic_istream& read(std::basic_istream &is, cons& t1) { if (!is.good()) return is; - + is >> t1.head; @@ -306,7 +306,7 @@ read(std::basic_istream &is, cons& t1) { template -inline std::basic_istream& +inline std::basic_istream& operator>>(std::basic_istream &is, null_type&) { if (!is.good() ) return is; @@ -318,15 +318,15 @@ operator>>(std::basic_istream &is, null_type&) { } template -inline std::basic_istream& +inline std::basic_istream& operator>>(std::basic_istream& is, cons& 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; @@ -337,5 +337,3 @@ operator>>(std::basic_istream& is, cons& t1) { } // end of namespace boost #endif // BOOST_TUPLE_IO_HPP - -