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

Fixes Ticket #12064

Browse Source
This commit is contained in:
Joel de Guzman
2016-03-13 08:03:26 +08:00
parent 68eff7df4b
commit 158c7ef640
4 changed files with 82 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/boost/tuple/detail/tuple_basic.hpp
View File

@ -35,11 +35,11 @@
#include <utility> // needed for the assignment from pair to tuple #include <utility> // needed for the assignment from pair to tuple
#include "boost/type_traits/cv_traits.hpp" #include <boost/type_traits/cv_traits.hpp>
#include "boost/type_traits/function_traits.hpp" #include <boost/type_traits/function_traits.hpp>
#include "boost/utility/swap.hpp" #include <boost/utility/swap.hpp>
#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND #include <boost/detail/workaround.hpp> // needed for BOOST_WORKAROUND
#if defined(BOOST_GCC) && (BOOST_GCC >= 40700) #if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
#pragma GCC diagnostic push #pragma GCC diagnostic push
@ -985,5 +985,3 @@ inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
#endif // BOOST_TUPLE_BASIC_HPP #endif // BOOST_TUPLE_BASIC_HPP

16
include/boost/tuple/tuple.hpp
View File

@ -8,7 +8,7 @@
// For more information, see http://www.boost.org // For more information, see http://www.boost.org
// ----------------------------------------------------------------- // -----------------------------------------------------------------
#ifndef BOOST_TUPLE_HPP #ifndef BOOST_TUPLE_HPP
#define BOOST_TUPLE_HPP #define BOOST_TUPLE_HPP
@ -20,15 +20,15 @@
namespace boost { namespace python { class tuple; }} namespace boost { namespace python { class tuple; }}
#endif #endif
#include "boost/config.hpp" #include <boost/config.hpp>
#include "boost/static_assert.hpp" #include <boost/static_assert.hpp>
// other compilers // other compilers
#include "boost/ref.hpp" #include <boost/ref.hpp>
#include "boost/tuple/detail/tuple_basic.hpp" #include <boost/tuple/detail/tuple_basic.hpp>
namespace boost { namespace boost {
using tuples::tuple; using tuples::tuple;
using tuples::make_tuple; using tuples::make_tuple;
@ -47,7 +47,7 @@ inline typename tuples::access_traits<
>::non_const_type >::non_const_type
get(tuples::cons<HT, TT>& c) { get(tuples::cons<HT, TT>& c) {
return tuples::get<N,HT,TT>(c); return tuples::get<N,HT,TT>(c);
} }
// get function for const cons-lists, returns a const reference to // get function for const cons-lists, returns a const reference to
// the element. If the element is a reference, returns the reference // the element. If the element is a reference, returns the reference
// as such (that is, can return a non-const reference) // as such (that is, can return a non-const reference)
@ -60,7 +60,7 @@ get(const tuples::cons<HT, TT>& c) {
} }
#endif // BOOST_NO_USING_TEMPLATE #endif // BOOST_NO_USING_TEMPLATE
} // end namespace boost } // end namespace boost

16
include/boost/tuple/tuple_comparison.hpp
View File

@ -1,31 +1,31 @@
// tuple_comparison.hpp ----------------------------------------------------- // tuple_comparison.hpp -----------------------------------------------------
// //
// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) // Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com) // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
// //
// Distributed under the Boost Software License, Version 1.0. (See // Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at // accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt) // http://www.boost.org/LICENSE_1_0.txt)
// //
// For more information, see http://www.boost.org // For more information, see http://www.boost.org
// //
// (The idea and first impl. of comparison operators was from Doug Gregor) // (The idea and first impl. of comparison operators was from Doug Gregor)
// ----------------------------------------------------------------- // -----------------------------------------------------------------
#ifndef BOOST_TUPLE_COMPARISON_HPP #ifndef BOOST_TUPLE_COMPARISON_HPP
#define BOOST_TUPLE_COMPARISON_HPP #define BOOST_TUPLE_COMPARISON_HPP
#include "boost/tuple/tuple.hpp" #include <boost/tuple/tuple.hpp>
// ------------------------------------------------------------- // -------------------------------------------------------------
// equality and comparison operators // equality and comparison operators
// //
// == and != compare tuples elementwise // == and != compare tuples elementwise
// <, >, <= and >= use lexicographical ordering // <, >, <= and >= use lexicographical ordering
// //
// Any operator between tuples of different length fails at compile time // 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) does not imply a>=b, a!=b does not imply a==b etc. // (i.e. !(a<b) does not imply a>=b, a!=b does not imply a==b etc.
// so any weirdnesses of elementary operators are respected). // 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 { namespace detail {
// comparison operators check statically the length of its operands and // comparison operators check statically the length of its operands and
// delegate the comparing task to the following functions. Hence // 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. // These functions assume tuples to be of the same length.

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

@ -6,7 +6,7 @@
// Distributed under the Boost Software License, Version 1.0. (See // Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at // accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt) // 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 <sstream> #include <sstream>
#include "boost/tuple/tuple.hpp" #include <boost/tuple/tuple.hpp>
// This is ugly: one should be using twoargument isspace since whitspace can // This is ugly: one should be using twoargument isspace since whitspace can
// be locale dependent, in theory at least. // 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 <cctype> but there seem // use the one-arg one, which one should get with <cctype> but there seem
// to be exceptions to this. // to be exceptions to this.
@ -30,9 +30,9 @@
#include <locale> // for two-arg isspace #include <locale> // for two-arg isspace
#else #else
#include <cctype> // for one-arg (old) isspace #include <cctype> // for one-arg (old) isspace
#include <ctype.h> // Metrowerks does not find one-arg isspace from cctype #include <ctype.h> // Metrowerks does not find one-arg isspace from cctype
#endif #endif
@ -43,12 +43,12 @@ namespace tuples {
namespace detail { namespace detail {
class format_info { class format_info {
public: public:
enum manipulator_type { open, close, delimiter }; enum manipulator_type { open, close, delimiter };
BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1); BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1);
private: private:
static int get_stream_index (int m) static int get_stream_index (int m)
{ {
static const int stream_index[number_of_manipulators] static const int stream_index[number_of_manipulators]
@ -58,19 +58,19 @@ private:
} }
format_info(const format_info&); format_info(const format_info&);
format_info(); format_info();
public: public:
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) {
// The manipulators are stored as long. // The manipulators are stored as long.
// A valid instanitation of basic_stream allows CharType to be any POD, // 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 // to CharType
CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) ); CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) );
// parentheses and space are the default manipulators // parentheses and space are the default manipulators
if (!c) { if (!c) {
switch(m) { switch(m) {
@ -84,27 +84,27 @@ public:
template<class CharType, class CharTrait> template<class CharType, class CharTrait>
static void set_manipulator(std::basic_ios<CharType, CharTrait>& i, static void set_manipulator(std::basic_ios<CharType, CharTrait>& i,
manipulator_type m, CharType c) { manipulator_type m, CharType c) {
// The manipulators are stored as long. // The manipulators are stored as long.
// A valid instanitation of basic_stream allows CharType to be any POD, // 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. // convertible long.
i.iword(get_stream_index(m)) = static_cast<long>(c); i.iword(get_stream_index(m)) = static_cast<long>(c);
} }
}; };
} // end of namespace detail } // end of namespace detail
template<class CharType> template<class CharType>
class tuple_manipulator { class tuple_manipulator {
const detail::format_info::manipulator_type mt; const detail::format_info::manipulator_type mt;
CharType f_c; CharType f_c;
public: public:
explicit tuple_manipulator(detail::format_info::manipulator_type m, explicit tuple_manipulator(detail::format_info::manipulator_type m,
const char c = 0) const char c = 0)
: mt(m), f_c(c) {} : mt(m), f_c(c) {}
template<class CharTrait> template<class CharTrait>
void set(std::basic_ios<CharType, CharTrait> &io) const { void set(std::basic_ios<CharType, CharTrait> &io) const {
detail::format_info::set_manipulator(io, mt, f_c); detail::format_info::set_manipulator(io, mt, f_c);
@ -126,7 +126,7 @@ operator>>(std::basic_istream<CharType, CharTrait>& i, const tuple_manipulator<C
return i; return i;
} }
template<class CharType> template<class CharType>
inline tuple_manipulator<CharType> set_open(const CharType c) { inline tuple_manipulator<CharType> set_open(const CharType c) {
return tuple_manipulator<CharType>(detail::format_info::open, c); return tuple_manipulator<CharType>(detail::format_info::open, c);
@ -144,38 +144,38 @@ inline tuple_manipulator<CharType> set_delimiter(const CharType c) {
// ------------------------------------------------------------- // -------------------------------------------------------------
// printing tuples to ostream in format (a b c) // printing tuples to ostream in format (a b c)
// parentheses and space are defaults, but can be overriden with manipulators // parentheses and space are defaults, but can be overriden with manipulators
// set_open, set_close and set_delimiter // set_open, set_close and set_delimiter
namespace detail { 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.
template<class CharType, class CharTrait, class T1> template<class CharType, class CharTrait, class T1>
inline std::basic_ostream<CharType, CharTrait>& inline std::basic_ostream<CharType, CharTrait>&
print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, null_type>& t) { print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, null_type>& t) {
return o << t.head; return o << t.head;
} }
template<class CharType, class CharTrait> template<class CharType, class CharTrait>
inline std::basic_ostream<CharType, CharTrait>& inline std::basic_ostream<CharType, CharTrait>&
print(std::basic_ostream<CharType, CharTrait>& o, const null_type&) { print(std::basic_ostream<CharType, CharTrait>& o, const null_type&) {
return o; return o;
} }
template<class CharType, class CharTrait, class T1, class T2> template<class CharType, class CharTrait, class T1, class T2>
inline std::basic_ostream<CharType, CharTrait>& inline std::basic_ostream<CharType, CharTrait>&
print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) { print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) {
const CharType d = format_info::get_manipulator(o, format_info::delimiter); const CharType d = format_info::get_manipulator(o, format_info::delimiter);
o << t.head; o << t.head;
o << d; o << d;
@ -205,17 +205,17 @@ inline bool handle_width(std::basic_ostream<CharT, Traits>& o, const T& t) {
template<class CharType, class CharTrait> template<class CharType, class CharTrait>
inline std::basic_ostream<CharType, CharTrait>& inline std::basic_ostream<CharType, CharTrait>&
operator<<(std::basic_ostream<CharType, CharTrait>& o, operator<<(std::basic_ostream<CharType, CharTrait>& o,
const null_type& t) { const null_type& t) {
if (!o.good() ) return o; if (!o.good() ) return o;
if (detail::handle_width(o, t)) 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); 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); detail::format_info::get_manipulator(o, detail::format_info::close);
o << l; o << l;
o << r; o << r;
@ -223,27 +223,27 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,
} }
template<class CharType, class CharTrait, class T1, class T2> template<class CharType, class CharTrait, class T1, class T2>
inline std::basic_ostream<CharType, CharTrait>& inline std::basic_ostream<CharType, CharTrait>&
operator<<(std::basic_ostream<CharType, CharTrait>& o, operator<<(std::basic_ostream<CharType, CharTrait>& o,
const cons<T1, T2>& t) { const cons<T1, T2>& t) {
if (!o.good() ) return o; if (!o.good() ) return o;
if (detail::handle_width(o, t)) 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; o << r;
return o; return o;
} }
// ------------------------------------------------------------- // -------------------------------------------------------------
// input stream operators // input stream operators
@ -251,7 +251,7 @@ namespace detail {
template<class CharType, class CharTrait> template<class CharType, class CharTrait>
inline std::basic_istream<CharType, CharTrait>& inline std::basic_istream<CharType, CharTrait>&
extract_and_check_delimiter( extract_and_check_delimiter(
std::basic_istream<CharType, CharTrait> &is, format_info::manipulator_type del) std::basic_istream<CharType, CharTrait> &is, format_info::manipulator_type del)
{ {
@ -263,13 +263,13 @@ extract_and_check_delimiter(
const bool is_delimiter = !std::use_facet< std::ctype< CharType > > const bool is_delimiter = !std::use_facet< std::ctype< CharType > >
(is.getloc() ).is( std::ctype_base::space, d); (is.getloc() ).is( std::ctype_base::space, d);
#else #else
const bool is_delimiter = (!std::isspace(d, is.getloc()) ); const bool is_delimiter = (!std::isspace(d, is.getloc()) );
#endif #endif
CharType c; CharType c;
if (is_delimiter) { if (is_delimiter) {
is >> c; is >> c;
if (is.good() && c!=d) { if (is.good() && c!=d) {
is.setstate(std::ios::failbit); is.setstate(std::ios::failbit);
} }
} else { } else {
@ -278,22 +278,22 @@ extract_and_check_delimiter(
return is; return is;
} }
template<class CharType, class CharTrait, class T1> template<class CharType, class CharTrait, class T1>
inline std::basic_istream<CharType, CharTrait> & inline std::basic_istream<CharType, CharTrait> &
read (std::basic_istream<CharType, CharTrait> &is, cons<T1, null_type>& t1) { read (std::basic_istream<CharType, CharTrait> &is, cons<T1, null_type>& t1) {
if (!is.good()) return is; if (!is.good()) return is;
return is >> t1.head; return is >> t1.head;
} }
template<class CharType, class CharTrait, class T1, class T2> template<class CharType, class CharTrait, class T1, class T2>
inline std::basic_istream<CharType, CharTrait>& inline std::basic_istream<CharType, CharTrait>&
read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) { read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
if (!is.good()) return is; if (!is.good()) return is;
is >> t1.head; is >> t1.head;
@ -306,7 +306,7 @@ read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
template<class CharType, class CharTrait> template<class CharType, class CharTrait>
inline std::basic_istream<CharType, CharTrait>& inline std::basic_istream<CharType, CharTrait>&
operator>>(std::basic_istream<CharType, CharTrait> &is, null_type&) { operator>>(std::basic_istream<CharType, CharTrait> &is, null_type&) {
if (!is.good() ) return is; if (!is.good() ) return is;
@ -318,15 +318,15 @@ operator>>(std::basic_istream<CharType, CharTrait> &is, null_type&) {
} }
template<class CharType, class CharTrait, class T1, class T2> template<class CharType, class CharTrait, class T1, class T2>
inline std::basic_istream<CharType, CharTrait>& inline std::basic_istream<CharType, CharTrait>&
operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) { operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {
if (!is.good() ) return is; if (!is.good() ) return is;
detail::extract_and_check_delimiter(is, detail::format_info::open); detail::extract_and_check_delimiter(is, detail::format_info::open);
detail::read(is, t1); detail::read(is, t1);
detail::extract_and_check_delimiter(is, detail::format_info::close); detail::extract_and_check_delimiter(is, detail::format_info::close);
return is; return is;
@ -337,5 +337,3 @@ operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {
} // end of namespace boost } // end of namespace boost
#endif // BOOST_TUPLE_IO_HPP #endif // BOOST_TUPLE_IO_HPP