[Boost-commit] svn:boost r83070 - in sandbox/tuple-move: . boost/tuple boost/tuple/detail detail

Subject: [Boost-commit] svn:boost r83070 - in sandbox/tuple-move: . boost/tuple boost/tuple/detail detail
From: adam.wulkiewicz_at_[hidden]
Date: 2013-02-21 16:26:27

Author: awulkiew
Date: 2013-02-21 16:26:26 EST (Thu, 21 Feb 2013)
New Revision: 83070
URL: http://svn.boost.org/trac/boost/changeset/83070

Log:
experimental tuple move code moved to sandbox/tuple-move/boost/tuple
Added:
   sandbox/tuple-move/boost/tuple/detail/   (props changed)
      - copied from r83069, /sandbox/tuple-move/detail/
   sandbox/tuple-move/boost/tuple/tuple.hpp   (props changed)
      - copied unchanged from r83069, /sandbox/tuple-move/tuple.hpp
   sandbox/tuple-move/boost/tuple/tuple_comparison.hpp   (props changed)
      - copied unchanged from r83069, /sandbox/tuple-move/tuple_comparison.hpp
   sandbox/tuple-move/boost/tuple/tuple_io.hpp   (props changed)
      - copied unchanged from r83069, /sandbox/tuple-move/tuple_io.hpp
Removed:
   sandbox/tuple-move/detail/
   sandbox/tuple-move/tuple.hpp
   sandbox/tuple-move/tuple_comparison.hpp
   sandbox/tuple-move/tuple_io.hpp

Deleted: sandbox/tuple-move/tuple.hpp
==============================================================================
--- sandbox/tuple-move/tuple.hpp	2013-02-21 16:26:26 EST (Thu, 21 Feb 2013)
+++ (empty file)
@@ -1,90 +0,0 @@
-//  tuple.hpp - Boost Tuple Library --------------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi_at_[hidden])
-//
-// 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
-
-// ----------------------------------------------------------------- 
-
-#ifndef BOOST_TUPLE_HPP
-#define BOOST_TUPLE_HPP
-
-#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
-// Work around a compiler bug.
-// boost::python::tuple has to be seen by the compiler before the
-// boost::tuple class template.
-namespace boost { namespace python { class tuple; }}
-#endif
-
-#include "boost/config.hpp"
-#include "boost/static_assert.hpp"
-
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-// The MSVC version
-#include "boost/tuple/detail/tuple_basic_no_partial_spec.hpp"
-
-#else
-// other compilers
-#include "boost/ref.hpp"
-#include "boost/tuple/detail/tuple_basic.hpp"
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-namespace boost {    
-
-using tuples::tuple;
-using tuples::make_tuple;
-using tuples::tie;
-#if !defined(BOOST_NO_USING_TEMPLATE)
-using tuples::get;
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-//
-// The "using tuples::get" statement causes the
-// Borland compiler to ICE, use forwarding
-// functions instead:
-//
-template<int N, class HT, class TT>
-inline typename tuples::access_traits<
-                  typename tuples::element<N, tuples::cons<HT, TT> >::type
-                >::non_const_type
-get(tuples::cons<HT, TT>& c) {
-  return tuples::get<N,HT,TT>(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)
-template<int N, class HT, class TT>
-inline typename tuples::access_traits<
-                  typename tuples::element<N, tuples::cons<HT, TT> >::type
-                >::const_type
-get(const tuples::cons<HT, TT>& c) {
-  return tuples::get<N,HT,TT>(c);
-}
-#else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-//
-// MSVC, using declarations don't mix with templates well,
-// so use forwarding functions instead:
-//
-template<int N, typename Head, typename Tail>
-typename tuples::detail::element_ref<N, tuples::cons<Head, Tail> >::RET
-get(tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
-{
-   return tuples::detail::get_class<N>::get(t);
-}
-
-template<int N, typename Head, typename Tail>
-typename tuples::detail::element_const_ref<N, tuples::cons<Head, Tail> >::RET
-get(const tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
-{
-   return tuples::detail::get_class<N>::get(t);
-}
-#endif // BOOST_NO_USING_TEMPLATE
-   
-} // end namespace boost
-
-
-#endif // BOOST_TUPLE_HPP

Deleted: sandbox/tuple-move/tuple_comparison.hpp
==============================================================================
--- sandbox/tuple-move/tuple_comparison.hpp	2013-02-21 16:26:26 EST (Thu, 21 Feb 2013)
+++ (empty file)
@@ -1,175 +0,0 @@
-// tuple_comparison.hpp -----------------------------------------------------
-//  
-// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi_at_[hidden])
-// Copyright (C) 2001 Gary Powell (gary.powell_at_[hidden])
-//
-// 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"
-
-// -------------------------------------------------------------
-// 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 
-// (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).
-//
-// -------------------------------------------------------------
-
-
-namespace boost {
-namespace tuples {
-
-inline bool operator==(const null_type&, const null_type&) { return true; }
-inline bool operator>=(const null_type&, const null_type&) { return true; }
-inline bool operator<=(const null_type&, const null_type&) { return true; }
-inline bool operator!=(const null_type&, const null_type&) { return false; }
-inline bool operator<(const null_type&, const null_type&) { return false; }
-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).  
-  // These functions assume tuples to be of the same length.
-
-
-template<class T1, class T2>
-inline bool eq(const T1& lhs, const T2& rhs) {
-  return lhs.get_head() == rhs.get_head() &&
-         eq(lhs.get_tail(), rhs.get_tail());
-}
-template<>
-inline bool eq<null_type,null_type>(const null_type&, const null_type&) { return true; }
-
-template<class T1, class T2>
-inline bool neq(const T1& lhs, const T2& rhs) {
-  return lhs.get_head() != rhs.get_head()  ||
-         neq(lhs.get_tail(), rhs.get_tail());
-}
-template<>
-inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; }
-
-template<class T1, class T2>
-inline bool lt(const T1& lhs, const T2& rhs) {
-  return lhs.get_head() < rhs.get_head()  ||
-          ( !(rhs.get_head() < lhs.get_head()) &&
-            lt(lhs.get_tail(), rhs.get_tail()));
-}
-template<>
-inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return false; }
-
-template<class T1, class T2>
-inline bool gt(const T1& lhs, const T2& rhs) {
-  return lhs.get_head() > rhs.get_head()  ||
-          ( !(rhs.get_head() > lhs.get_head()) &&
-            gt(lhs.get_tail(), rhs.get_tail()));
-}
-template<>
-inline bool gt<null_type,null_type>(const null_type&, const null_type&) { return false; }
-
-template<class T1, class T2>
-inline bool lte(const T1& lhs, const T2& rhs) {
-  return lhs.get_head() <= rhs.get_head()  &&
-          ( !(rhs.get_head() <= lhs.get_head()) ||
-            lte(lhs.get_tail(), rhs.get_tail()));
-}
-template<>
-inline bool lte<null_type,null_type>(const null_type&, const null_type&) { return true; }
-
-template<class T1, class T2>
-inline bool gte(const T1& lhs, const T2& rhs) {
-  return lhs.get_head() >= rhs.get_head()  &&
-          ( !(rhs.get_head() >= lhs.get_head()) ||
-            gte(lhs.get_tail(), rhs.get_tail()));
-}
-template<>
-inline bool gte<null_type,null_type>(const null_type&, const null_type&) { return true; }
-
-} // end of namespace detail
-
-
-// equal ----
-
-template<class T1, class T2, class S1, class S2>
-inline bool operator==(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
-{
-  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-
-  return  detail::eq(lhs, rhs);
-}
-
-// not equal -----
-
-template<class T1, class T2, class S1, class S2>
-inline bool operator!=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
-{
-
-  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-
-  return detail::neq(lhs, rhs);
-}
-
-// <
-template<class T1, class T2, class S1, class S2>
-inline bool operator<(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
-{
-  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-
-  return detail::lt(lhs, rhs);
-}
-
-// >
-template<class T1, class T2, class S1, class S2>
-inline bool operator>(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
-{
-  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-
-  return detail::gt(lhs, rhs);
-}
-
-// <=
-template<class T1, class T2, class S1, class S2>
-inline bool operator<=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
-{
-  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-
-  return detail::lte(lhs, rhs);
-}
-
-// >=
-template<class T1, class T2, class S1, class S2>
-inline bool operator>=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
-{
-  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-
-  return detail::gte(lhs, rhs);
-}
-
-} // end of namespace tuples
-} // end of namespace boost
-
-
-#endif // BOOST_TUPLE_COMPARISON_HPP

Deleted: sandbox/tuple-move/tuple_io.hpp
==============================================================================
--- sandbox/tuple-move/tuple_io.hpp	2013-02-21 16:26:26 EST (Thu, 21 Feb 2013)
+++ (empty file)
@@ -1,600 +0,0 @@
-// tuple_io.hpp --------------------------------------------------------------
-
-// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi_at_[hidden])
-//               2001 Gary Powell (gary.powell_at_[hidden])
-//
-// 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 
-
-// ----------------------------------------------------------------------------
-
-#ifndef 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 <ostream>
-#endif  
-
-#include <sstream>
-
-#include "boost/tuple/tuple.hpp"
-
-// 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 
-// use the one-arg one, which one should get with <cctype> but there seem
-// to be exceptions to this.
-
-#if !defined (BOOST_NO_STD_LOCALE)
-
-#include <locale> // for two-arg isspace
-
-#else 
-
-#include <cctype> // for one-arg (old) isspace 
-#include <ctype.h> // Metrowerks does not find one-arg isspace from cctype
-
-#endif
-
-namespace boost {
-namespace tuples {
-
-namespace detail {
-
-class format_info {
-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]
-        = { std::ios::xalloc(), std::ios::xalloc(), std::ios::xalloc() };
-
-     return stream_index[m];
-   }
-
-   format_info(const format_info&);
-   format_info();   
-
-
-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>
-   static CharType get_manipulator(std::basic_ios<CharType, CharTrait>& 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 
-     // to CharType
-     CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) ); 
-     // parentheses and space are the default manipulators
-     if (!c) {
-       switch(m) {
-         case detail::format_info::open :  c = i.widen('('); break;
-         case detail::format_info::close : c = i.widen(')'); break;
-         case detail::format_info::delimiter : c = i.widen(' '); break;
-       }
-     }
-     return c;
-   }
-
-
-   template<class CharType, class CharTrait>
-   static void set_manipulator(std::basic_ios<CharType, CharTrait>& 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 
-     // convertible long.
-      i.iword(get_stream_index(m)) = static_cast<long>(c);
-   }
-#endif // BOOST_NO_TEMPLATED_STREAMS
-};
-
-} // end of namespace detail
- 
-template<class CharType>    
-class tuple_manipulator {
-  const detail::format_info::manipulator_type mt;
-  CharType f_c;
-public:
-  explicit tuple_manipulator(detail::format_info::manipulator_type m, 
-                             const char c = 0)
-     : 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)
-   template<class CharType2, class CharTrait>
-  void set(std::basic_ios<CharType2, CharTrait> &io) const {
-     detail::format_info::set_manipulator(io, mt, f_c);
-  }
-#else
-   template<class CharTrait>
-  void set(std::basic_ios<CharType, CharTrait> &io) const {
-     detail::format_info::set_manipulator(io, mt, f_c);
-  }
-#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>
-inline std::basic_ostream<CharType, CharTrait>&
-operator<<(std::basic_ostream<CharType, CharTrait>& o, const tuple_manipulator<CharType>& m) {
-  m.set(o);
-  return o;
-}
-
-template<class CharType, class CharTrait>
-inline std::basic_istream<CharType, CharTrait>&
-operator>>(std::basic_istream<CharType, CharTrait>& i, const tuple_manipulator<CharType>& m) {
-  m.set(i);
-  return i;
-}
-
-#endif   // BOOST_NO_TEMPLATED_STREAMS
-   
-template<class CharType>
-inline tuple_manipulator<CharType> set_open(const CharType c) {
-   return tuple_manipulator<CharType>(detail::format_info::open, c);
-}
-
-template<class CharType>
-inline tuple_manipulator<CharType> set_close(const CharType c) {
-   return tuple_manipulator<CharType>(detail::format_info::close, c);
-}
-
-template<class CharType>
-inline tuple_manipulator<CharType> set_delimiter(const CharType c) {
-   return tuple_manipulator<CharType>(detail::format_info::delimiter, 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 
-// 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)
-template<class CharType, class CharTrait, class T1>
-inline std::basic_ostream<CharType, CharTrait>& 
-print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, null_type>& t) {
-  return o << t.head;
-}
-#endif  // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
- 
-template<class CharType, class CharTrait>
-inline std::basic_ostream<CharType, CharTrait>& 
-print(std::basic_ostream<CharType, CharTrait>& o, const null_type&) { 
-  return o; 
-}
-
-template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_ostream<CharType, CharTrait>& 
-print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) {
-  
-  const CharType 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 CharT, class Traits, class T>
-inline bool handle_width(std::basic_ostream<CharT, Traits>& o, const T& t) {
-    std::streamsize width = o.width();
-    if(width == 0) return false;
-
-    std::basic_ostringstream<CharT, Traits> ss;
-
-    ss.copyfmt(o);
-    ss.tie(0);
-    ss.width(0);
-
-    ss << t;
-    o << ss.str();
-
-    return true;
-}
-
-#endif  // BOOST_NO_TEMPLATED_STREAMS
-
-} // 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>
-inline std::basic_ostream<CharType, CharTrait>& 
-operator<<(std::basic_ostream<CharType, CharTrait>& o, 
-           const null_type& 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;
-  o << r;
-
-  return o;
-}
-
-template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_ostream<CharType, CharTrait>& 
-operator<<(std::basic_ostream<CharType, CharTrait>& o, 
-           const cons<T1, T2>& 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);  
-
-  o << r;
-
-  return o;
-}
-#endif // BOOST_NO_TEMPLATED_STREAMS
-
-   
-// -------------------------------------------------------------
-// input stream operators
-
-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>
-inline std::basic_istream<CharType, CharTrait>& 
-extract_and_check_delimiter(
-  std::basic_istream<CharType, CharTrait> &is, format_info::manipulator_type del)
-{
-  const CharType d = format_info::get_manipulator(is, del);
-
-#if defined (BOOST_NO_STD_LOCALE)
-  const bool is_delimiter = !isspace(d);
-#elif defined ( __BORLANDC__ )
-  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()) );            
-#endif
-
-  CharType c;
-  if (is_delimiter) { 
-    is >> c;
-    if (is.good() && c!=d) { 
-      is.setstate(std::ios::failbit);
-    }
-  } else {
-    is >> std::ws;
-  }
-  return is;
-}
-
-   
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-template<class CharType, class CharTrait, class T1>
-inline  std::basic_istream<CharType, CharTrait> & 
-read (std::basic_istream<CharType, CharTrait> &is, cons<T1, null_type>& t1) {
-
-  if (!is.good()) return is;   
-   
-  return is >> t1.head; 
-}
-#else
-template<class CharType, class CharTrait>
-inline std::basic_istream<CharType, CharTrait>& 
-read(std::basic_istream<CharType, CharTrait>& i, const null_type&) { return i; }
-
-#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_istream<CharType, CharTrait>& 
-read(std::basic_istream<CharType, CharTrait> &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
-
-
-template<class CharType, class CharTrait>
-inline std::basic_istream<CharType, CharTrait>& 
-operator>>(std::basic_istream<CharType, CharTrait> &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 CharType, class CharTrait, class T1, class T2>
-inline std::basic_istream<CharType, CharTrait>& 
-operator>>(std::basic_istream<CharType, CharTrait>& 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;
-}
-
-#endif // BOOST_NO_TEMPLATED_STREAMS
-
-} // end of namespace tuples
-} // end of namespace boost
-
-#endif // BOOST_TUPLE_IO_HPP
-
-