Squashed 'third_party/boostorg/utility/' content from commit ebe4429
Change-Id: I8e6ee78273db31df18f99d29034f855ccc064551
git-subtree-dir: third_party/boostorg/utility
git-subtree-split: ebe44296ca698e333a09e8268ea8ccedb3886c4d
diff --git a/include/boost/call_traits.hpp b/include/boost/call_traits.hpp
new file mode 100644
index 0000000..2c1328e
--- /dev/null
+++ b/include/boost/call_traits.hpp
@@ -0,0 +1,20 @@
+// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+// Use, modification and distribution are subject to 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/utility for most recent version including documentation.
+
+// See boost/detail/call_traits.hpp
+// for full copyright notices.
+
+#ifndef BOOST_CALL_TRAITS_HPP
+#define BOOST_CALL_TRAITS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#include <boost/config.hpp>
+#endif
+
+#include <boost/detail/call_traits.hpp>
+
+#endif // BOOST_CALL_TRAITS_HPP
diff --git a/include/boost/compressed_pair.hpp b/include/boost/compressed_pair.hpp
new file mode 100644
index 0000000..a7be0f2
--- /dev/null
+++ b/include/boost/compressed_pair.hpp
@@ -0,0 +1,20 @@
+// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+// Use, modification and distribution are subject to 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/utility for most recent version including documentation.
+
+// See boost/detail/compressed_pair.hpp
+// for full copyright notices.
+
+#ifndef BOOST_COMPRESSED_PAIR_HPP
+#define BOOST_COMPRESSED_PAIR_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#include <boost/config.hpp>
+#endif
+
+#include <boost/detail/compressed_pair.hpp>
+
+#endif // BOOST_COMPRESSED_PAIR_HPP
diff --git a/include/boost/detail/call_traits.hpp b/include/boost/detail/call_traits.hpp
new file mode 100644
index 0000000..36dea00
--- /dev/null
+++ b/include/boost/detail/call_traits.hpp
@@ -0,0 +1,172 @@
+// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+// Use, modification and distribution are subject to 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/utility for most recent version including documentation.
+
+// call_traits: defines typedefs for function usage
+// (see libs/utility/call_traits.htm)
+
+/* Release notes:
+ 23rd July 2000:
+ Fixed array specialization. (JM)
+ Added Borland specific fixes for reference types
+ (issue raised by Steve Cleary).
+*/
+
+#ifndef BOOST_DETAIL_CALL_TRAITS_HPP
+#define BOOST_DETAIL_CALL_TRAITS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#include <boost/config.hpp>
+#endif
+#include <cstddef>
+
+#include <boost/type_traits/is_arithmetic.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/detail/workaround.hpp>
+
+namespace boost{
+
+namespace detail{
+
+template <typename T, bool small_>
+struct ct_imp2
+{
+ typedef const T& param_type;
+};
+
+template <typename T>
+struct ct_imp2<T, true>
+{
+ typedef const T param_type;
+};
+
+template <typename T, bool isp, bool b1, bool b2>
+struct ct_imp
+{
+ typedef const T& param_type;
+};
+
+template <typename T, bool isp, bool b2>
+struct ct_imp<T, isp, true, b2>
+{
+ typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
+};
+
+template <typename T, bool isp, bool b1>
+struct ct_imp<T, isp, b1, true>
+{
+ typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
+};
+
+template <typename T, bool b1, bool b2>
+struct ct_imp<T, true, b1, b2>
+{
+ typedef const T param_type;
+};
+
+}
+
+template <typename T>
+struct call_traits
+{
+public:
+ typedef T value_type;
+ typedef T& reference;
+ typedef const T& const_reference;
+ //
+ // C++ Builder workaround: we should be able to define a compile time
+ // constant and pass that as a single template parameter to ct_imp<T,bool>,
+ // however compiler bugs prevent this - instead pass three bool's to
+ // ct_imp<T,bool,bool,bool> and add an extra partial specialisation
+ // of ct_imp to handle the logic. (JM)
+ typedef typename boost::detail::ct_imp<
+ T,
+ ::boost::is_pointer<T>::value,
+ ::boost::is_arithmetic<T>::value,
+ ::boost::is_enum<T>::value
+ >::param_type param_type;
+};
+
+template <typename T>
+struct call_traits<T&>
+{
+ typedef T& value_type;
+ typedef T& reference;
+ typedef const T& const_reference;
+ typedef T& param_type; // hh removed const
+};
+
+#if BOOST_WORKAROUND( __BORLANDC__, < 0x5A0 )
+// these are illegal specialisations; cv-qualifies applied to
+// references have no effect according to [8.3.2p1],
+// C++ Builder requires them though as it treats cv-qualified
+// references as distinct types...
+template <typename T>
+struct call_traits<T&const>
+{
+ typedef T& value_type;
+ typedef T& reference;
+ typedef const T& const_reference;
+ typedef T& param_type; // hh removed const
+};
+template <typename T>
+struct call_traits<T&volatile>
+{
+ typedef T& value_type;
+ typedef T& reference;
+ typedef const T& const_reference;
+ typedef T& param_type; // hh removed const
+};
+template <typename T>
+struct call_traits<T&const volatile>
+{
+ typedef T& value_type;
+ typedef T& reference;
+ typedef const T& const_reference;
+ typedef T& param_type; // hh removed const
+};
+
+template <typename T>
+struct call_traits< T * >
+{
+ typedef T * value_type;
+ typedef T * & reference;
+ typedef T * const & const_reference;
+ typedef T * const param_type; // hh removed const
+};
+#endif
+#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
+template <typename T, std::size_t N>
+struct call_traits<T [N]>
+{
+private:
+ typedef T array_type[N];
+public:
+ // degrades array to pointer:
+ typedef const T* value_type;
+ typedef array_type& reference;
+ typedef const array_type& const_reference;
+ typedef const T* const param_type;
+};
+
+template <typename T, std::size_t N>
+struct call_traits<const T [N]>
+{
+private:
+ typedef const T array_type[N];
+public:
+ // degrades array to pointer:
+ typedef const T* value_type;
+ typedef array_type& reference;
+ typedef const array_type& const_reference;
+ typedef const T* const param_type;
+};
+#endif
+
+}
+
+#endif // BOOST_DETAIL_CALL_TRAITS_HPP
diff --git a/include/boost/detail/compressed_pair.hpp b/include/boost/detail/compressed_pair.hpp
new file mode 100644
index 0000000..5dc21e2
--- /dev/null
+++ b/include/boost/detail/compressed_pair.hpp
@@ -0,0 +1,443 @@
+// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+// Use, modification and distribution are subject to 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/utility for most recent version including documentation.
+
+// compressed_pair: pair that "compresses" empty members
+// (see libs/utility/doc/html/compressed_pair.html)
+//
+// JM changes 25 Jan 2004:
+// For the case where T1 == T2 and both are empty, then first() and second()
+// should return different objects.
+// JM changes 25 Jan 2000:
+// Removed default arguments from compressed_pair_switch to get
+// C++ Builder 4 to accept them
+// rewriten swap to get gcc and C++ builder to compile.
+// added partial specialisations for case T1 == T2 to avoid duplicate constructor defs.
+
+#ifndef BOOST_DETAIL_COMPRESSED_PAIR_HPP
+#define BOOST_DETAIL_COMPRESSED_PAIR_HPP
+
+#include <algorithm>
+
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/is_empty.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/call_traits.hpp>
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable:4512)
+#endif
+namespace boost
+{
+
+template <class T1, class T2>
+class compressed_pair;
+
+
+// compressed_pair
+
+namespace details
+{
+ // JM altered 26 Jan 2000:
+ template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty>
+ struct compressed_pair_switch;
+
+ template <class T1, class T2>
+ struct compressed_pair_switch<T1, T2, false, false, false>
+ {static const int value = 0;};
+
+ template <class T1, class T2>
+ struct compressed_pair_switch<T1, T2, false, true, true>
+ {static const int value = 3;};
+
+ template <class T1, class T2>
+ struct compressed_pair_switch<T1, T2, false, true, false>
+ {static const int value = 1;};
+
+ template <class T1, class T2>
+ struct compressed_pair_switch<T1, T2, false, false, true>
+ {static const int value = 2;};
+
+ template <class T1, class T2>
+ struct compressed_pair_switch<T1, T2, true, true, true>
+ {static const int value = 4;};
+
+ template <class T1, class T2>
+ struct compressed_pair_switch<T1, T2, true, false, false>
+ {static const int value = 5;};
+
+ template <class T1, class T2, int Version> class compressed_pair_imp;
+
+#ifdef __GNUC__
+ // workaround for GCC (JM):
+ using std::swap;
+#endif
+ //
+ // can't call unqualified swap from within classname::swap
+ // as Koenig lookup rules will find only the classname::swap
+ // member function not the global declaration, so use cp_swap
+ // as a forwarding function (JM):
+ template <typename T>
+ inline void cp_swap(T& t1, T& t2)
+ {
+#ifndef __GNUC__
+ using std::swap;
+#endif
+ swap(t1, t2);
+ }
+
+ // 0 derive from neither
+
+ template <class T1, class T2>
+ class compressed_pair_imp<T1, T2, 0>
+ {
+ public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair_imp() {}
+
+ compressed_pair_imp(first_param_type x, second_param_type y)
+ : first_(x), second_(y) {}
+
+ compressed_pair_imp(first_param_type x)
+ : first_(x) {}
+
+ compressed_pair_imp(second_param_type y)
+ : second_(y) {}
+
+ first_reference first() {return first_;}
+ first_const_reference first() const {return first_;}
+
+ second_reference second() {return second_;}
+ second_const_reference second() const {return second_;}
+
+ void swap(::boost::compressed_pair<T1, T2>& y)
+ {
+ cp_swap(first_, y.first());
+ cp_swap(second_, y.second());
+ }
+ private:
+ first_type first_;
+ second_type second_;
+ };
+
+ // 1 derive from T1
+
+ template <class T1, class T2>
+ class compressed_pair_imp<T1, T2, 1>
+ : protected ::boost::remove_cv<T1>::type
+ {
+ public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair_imp() {}
+
+ compressed_pair_imp(first_param_type x, second_param_type y)
+ : first_type(x), second_(y) {}
+
+ compressed_pair_imp(first_param_type x)
+ : first_type(x) {}
+
+ compressed_pair_imp(second_param_type y)
+ : second_(y) {}
+
+ first_reference first() {return *this;}
+ first_const_reference first() const {return *this;}
+
+ second_reference second() {return second_;}
+ second_const_reference second() const {return second_;}
+
+ void swap(::boost::compressed_pair<T1,T2>& y)
+ {
+ // no need to swap empty base class:
+ cp_swap(second_, y.second());
+ }
+ private:
+ second_type second_;
+ };
+
+ // 2 derive from T2
+
+ template <class T1, class T2>
+ class compressed_pair_imp<T1, T2, 2>
+ : protected ::boost::remove_cv<T2>::type
+ {
+ public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair_imp() {}
+
+ compressed_pair_imp(first_param_type x, second_param_type y)
+ : second_type(y), first_(x) {}
+
+ compressed_pair_imp(first_param_type x)
+ : first_(x) {}
+
+ compressed_pair_imp(second_param_type y)
+ : second_type(y) {}
+
+ first_reference first() {return first_;}
+ first_const_reference first() const {return first_;}
+
+ second_reference second() {return *this;}
+ second_const_reference second() const {return *this;}
+
+ void swap(::boost::compressed_pair<T1,T2>& y)
+ {
+ // no need to swap empty base class:
+ cp_swap(first_, y.first());
+ }
+
+ private:
+ first_type first_;
+ };
+
+ // 3 derive from T1 and T2
+
+ template <class T1, class T2>
+ class compressed_pair_imp<T1, T2, 3>
+ : protected ::boost::remove_cv<T1>::type,
+ protected ::boost::remove_cv<T2>::type
+ {
+ public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair_imp() {}
+
+ compressed_pair_imp(first_param_type x, second_param_type y)
+ : first_type(x), second_type(y) {}
+
+ compressed_pair_imp(first_param_type x)
+ : first_type(x) {}
+
+ compressed_pair_imp(second_param_type y)
+ : second_type(y) {}
+
+ first_reference first() {return *this;}
+ first_const_reference first() const {return *this;}
+
+ second_reference second() {return *this;}
+ second_const_reference second() const {return *this;}
+ //
+ // no need to swap empty bases:
+ void swap(::boost::compressed_pair<T1,T2>&) {}
+ };
+
+ // JM
+ // 4 T1 == T2, T1 and T2 both empty
+ // Originally this did not store an instance of T2 at all
+ // but that led to problems beause it meant &x.first() == &x.second()
+ // which is not true for any other kind of pair, so now we store an instance
+ // of T2 just in case the user is relying on first() and second() returning
+ // different objects (albeit both empty).
+ template <class T1, class T2>
+ class compressed_pair_imp<T1, T2, 4>
+ : protected ::boost::remove_cv<T1>::type
+ {
+ public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair_imp() {}
+
+ compressed_pair_imp(first_param_type x, second_param_type y)
+ : first_type(x), m_second(y) {}
+
+ compressed_pair_imp(first_param_type x)
+ : first_type(x), m_second(x) {}
+
+ first_reference first() {return *this;}
+ first_const_reference first() const {return *this;}
+
+ second_reference second() {return m_second;}
+ second_const_reference second() const {return m_second;}
+
+ void swap(::boost::compressed_pair<T1,T2>&) {}
+ private:
+ T2 m_second;
+ };
+
+ // 5 T1 == T2 and are not empty: //JM
+
+ template <class T1, class T2>
+ class compressed_pair_imp<T1, T2, 5>
+ {
+ public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair_imp() {}
+
+ compressed_pair_imp(first_param_type x, second_param_type y)
+ : first_(x), second_(y) {}
+
+ compressed_pair_imp(first_param_type x)
+ : first_(x), second_(x) {}
+
+ first_reference first() {return first_;}
+ first_const_reference first() const {return first_;}
+
+ second_reference second() {return second_;}
+ second_const_reference second() const {return second_;}
+
+ void swap(::boost::compressed_pair<T1, T2>& y)
+ {
+ cp_swap(first_, y.first());
+ cp_swap(second_, y.second());
+ }
+ private:
+ first_type first_;
+ second_type second_;
+ };
+
+} // details
+
+template <class T1, class T2>
+class compressed_pair
+ : private ::boost::details::compressed_pair_imp<T1, T2,
+ ::boost::details::compressed_pair_switch<
+ T1,
+ T2,
+ ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
+ ::boost::is_empty<T1>::value,
+ ::boost::is_empty<T2>::value>::value>
+{
+private:
+ typedef details::compressed_pair_imp<T1, T2,
+ ::boost::details::compressed_pair_switch<
+ T1,
+ T2,
+ ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
+ ::boost::is_empty<T1>::value,
+ ::boost::is_empty<T2>::value>::value> base;
+public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair() : base() {}
+ compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
+ explicit compressed_pair(first_param_type x) : base(x) {}
+ explicit compressed_pair(second_param_type y) : base(y) {}
+
+ first_reference first() {return base::first();}
+ first_const_reference first() const {return base::first();}
+
+ second_reference second() {return base::second();}
+ second_const_reference second() const {return base::second();}
+
+ void swap(compressed_pair& y) { base::swap(y); }
+};
+
+// JM
+// Partial specialisation for case where T1 == T2:
+//
+template <class T>
+class compressed_pair<T, T>
+ : private details::compressed_pair_imp<T, T,
+ ::boost::details::compressed_pair_switch<
+ T,
+ T,
+ ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
+ ::boost::is_empty<T>::value,
+ ::boost::is_empty<T>::value>::value>
+{
+private:
+ typedef details::compressed_pair_imp<T, T,
+ ::boost::details::compressed_pair_switch<
+ T,
+ T,
+ ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
+ ::boost::is_empty<T>::value,
+ ::boost::is_empty<T>::value>::value> base;
+public:
+ typedef T first_type;
+ typedef T second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair() : base() {}
+ compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
+#if !(defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530))
+ explicit
+#endif
+ compressed_pair(first_param_type x) : base(x) {}
+
+ first_reference first() {return base::first();}
+ first_const_reference first() const {return base::first();}
+
+ second_reference second() {return base::second();}
+ second_const_reference second() const {return base::second();}
+
+ void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); }
+};
+
+template <class T1, class T2>
+inline
+void
+swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
+{
+ x.swap(y);
+}
+
+} // boost
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+#endif // BOOST_DETAIL_COMPRESSED_PAIR_HPP
+
diff --git a/include/boost/detail/ob_compressed_pair.hpp b/include/boost/detail/ob_compressed_pair.hpp
new file mode 100644
index 0000000..326e454
--- /dev/null
+++ b/include/boost/detail/ob_compressed_pair.hpp
@@ -0,0 +1,499 @@
+// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+// Use, modification and distribution are subject to 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/utility for most recent version including documentation.
+// see libs/utility/compressed_pair.hpp
+//
+/* Release notes:
+ 20 Jan 2001:
+ Fixed obvious bugs (David Abrahams)
+ 07 Oct 2000:
+ Added better single argument constructor support.
+ 03 Oct 2000:
+ Added VC6 support (JM).
+ 23rd July 2000:
+ Additional comments added. (JM)
+ Jan 2000:
+ Original version: this version crippled for use with crippled compilers
+ - John Maddock Jan 2000.
+*/
+
+
+#ifndef BOOST_OB_COMPRESSED_PAIR_HPP
+#define BOOST_OB_COMPRESSED_PAIR_HPP
+
+#include <algorithm>
+#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP
+#include <boost/type_traits/object_traits.hpp>
+#endif
+#ifndef BOOST_SAME_TRAITS_HPP
+#include <boost/type_traits/same_traits.hpp>
+#endif
+#ifndef BOOST_CALL_TRAITS_HPP
+#include <boost/call_traits.hpp>
+#endif
+
+namespace boost
+{
+#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
+//
+// use member templates to emulate
+// partial specialisation. Note that due to
+// problems with overload resolution with VC6
+// each of the compressed_pair versions that follow
+// have one template single-argument constructor
+// in place of two specific constructors:
+//
+
+template <class T1, class T2>
+class compressed_pair;
+
+namespace detail{
+
+template <class A, class T1, class T2>
+struct best_conversion_traits
+{
+ typedef char one;
+ typedef char (&two)[2];
+ static A a;
+ static one test(T1);
+ static two test(T2);
+
+ enum { value = sizeof(test(a)) };
+};
+
+template <int>
+struct init_one;
+
+template <>
+struct init_one<1>
+{
+ template <class A, class T1, class T2>
+ static void init(const A& a, T1* p1, T2*)
+ {
+ *p1 = a;
+ }
+};
+
+template <>
+struct init_one<2>
+{
+ template <class A, class T1, class T2>
+ static void init(const A& a, T1*, T2* p2)
+ {
+ *p2 = a;
+ }
+};
+
+
+// T1 != T2, both non-empty
+template <class T1, class T2>
+class compressed_pair_0
+{
+private:
+ T1 _first;
+ T2 _second;
+public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair_0() : _first(), _second() {}
+ compressed_pair_0(first_param_type x, second_param_type y) : _first(x), _second(y) {}
+ template <class A>
+ explicit compressed_pair_0(const A& val)
+ {
+ init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, &_second);
+ }
+ compressed_pair_0(const ::boost::compressed_pair<T1,T2>& x)
+ : _first(x.first()), _second(x.second()) {}
+
+#if 0
+ compressed_pair_0& operator=(const compressed_pair_0& x) {
+ cout << "assigning compressed pair 0" << endl;
+ _first = x._first;
+ _second = x._second;
+ cout << "finished assigning compressed pair 0" << endl;
+ return *this;
+ }
+#endif
+
+ first_reference first() { return _first; }
+ first_const_reference first() const { return _first; }
+
+ second_reference second() { return _second; }
+ second_const_reference second() const { return _second; }
+
+ void swap(compressed_pair_0& y)
+ {
+ using std::swap;
+ swap(_first, y._first);
+ swap(_second, y._second);
+ }
+};
+
+// T1 != T2, T2 empty
+template <class T1, class T2>
+class compressed_pair_1 : T2
+{
+private:
+ T1 _first;
+public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair_1() : T2(), _first() {}
+ compressed_pair_1(first_param_type x, second_param_type y) : T2(y), _first(x) {}
+
+ template <class A>
+ explicit compressed_pair_1(const A& val)
+ {
+ init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, static_cast<T2*>(this));
+ }
+
+ compressed_pair_1(const ::boost::compressed_pair<T1,T2>& x)
+ : T2(x.second()), _first(x.first()) {}
+
+ first_reference first() { return _first; }
+ first_const_reference first() const { return _first; }
+
+ second_reference second() { return *this; }
+ second_const_reference second() const { return *this; }
+
+ void swap(compressed_pair_1& y)
+ {
+ // no need to swap empty base class:
+ using std::swap;
+ swap(_first, y._first);
+ }
+};
+
+// T1 != T2, T1 empty
+template <class T1, class T2>
+class compressed_pair_2 : T1
+{
+private:
+ T2 _second;
+public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair_2() : T1(), _second() {}
+ compressed_pair_2(first_param_type x, second_param_type y) : T1(x), _second(y) {}
+ template <class A>
+ explicit compressed_pair_2(const A& val)
+ {
+ init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), &_second);
+ }
+ compressed_pair_2(const ::boost::compressed_pair<T1,T2>& x)
+ : T1(x.first()), _second(x.second()) {}
+
+#if 0
+ compressed_pair_2& operator=(const compressed_pair_2& x) {
+ cout << "assigning compressed pair 2" << endl;
+ T1::operator=(x);
+ _second = x._second;
+ cout << "finished assigning compressed pair 2" << endl;
+ return *this;
+ }
+#endif
+ first_reference first() { return *this; }
+ first_const_reference first() const { return *this; }
+
+ second_reference second() { return _second; }
+ second_const_reference second() const { return _second; }
+
+ void swap(compressed_pair_2& y)
+ {
+ // no need to swap empty base class:
+ using std::swap;
+ swap(_second, y._second);
+ }
+};
+
+// T1 != T2, both empty
+template <class T1, class T2>
+class compressed_pair_3 : T1, T2
+{
+public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair_3() : T1(), T2() {}
+ compressed_pair_3(first_param_type x, second_param_type y) : T1(x), T2(y) {}
+ template <class A>
+ explicit compressed_pair_3(const A& val)
+ {
+ init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), static_cast<T2*>(this));
+ }
+ compressed_pair_3(const ::boost::compressed_pair<T1,T2>& x)
+ : T1(x.first()), T2(x.second()) {}
+
+ first_reference first() { return *this; }
+ first_const_reference first() const { return *this; }
+
+ second_reference second() { return *this; }
+ second_const_reference second() const { return *this; }
+
+ void swap(compressed_pair_3& y)
+ {
+ // no need to swap empty base classes:
+ }
+};
+
+// T1 == T2, and empty
+template <class T1, class T2>
+class compressed_pair_4 : T1
+{
+public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair_4() : T1() {}
+ compressed_pair_4(first_param_type x, second_param_type y) : T1(x), m_second(y) {}
+ // only one single argument constructor since T1 == T2
+ explicit compressed_pair_4(first_param_type x) : T1(x), m_second(x) {}
+ compressed_pair_4(const ::boost::compressed_pair<T1,T2>& x)
+ : T1(x.first()), m_second(x.second()) {}
+
+ first_reference first() { return *this; }
+ first_const_reference first() const { return *this; }
+
+ second_reference second() { return m_second; }
+ second_const_reference second() const { return m_second; }
+
+ void swap(compressed_pair_4& y)
+ {
+ // no need to swap empty base classes:
+ }
+private:
+ T2 m_second;
+};
+
+// T1 == T2, not empty
+template <class T1, class T2>
+class compressed_pair_5
+{
+private:
+ T1 _first;
+ T2 _second;
+public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair_5() : _first(), _second() {}
+ compressed_pair_5(first_param_type x, second_param_type y) : _first(x), _second(y) {}
+ // only one single argument constructor since T1 == T2
+ explicit compressed_pair_5(first_param_type x) : _first(x), _second(x) {}
+ compressed_pair_5(const ::boost::compressed_pair<T1,T2>& c)
+ : _first(c.first()), _second(c.second()) {}
+
+ first_reference first() { return _first; }
+ first_const_reference first() const { return _first; }
+
+ second_reference second() { return _second; }
+ second_const_reference second() const { return _second; }
+
+ void swap(compressed_pair_5& y)
+ {
+ using std::swap;
+ swap(_first, y._first);
+ swap(_second, y._second);
+ }
+};
+
+template <bool e1, bool e2, bool same>
+struct compressed_pair_chooser
+{
+ template <class T1, class T2>
+ struct rebind
+ {
+ typedef compressed_pair_0<T1, T2> type;
+ };
+};
+
+template <>
+struct compressed_pair_chooser<false, true, false>
+{
+ template <class T1, class T2>
+ struct rebind
+ {
+ typedef compressed_pair_1<T1, T2> type;
+ };
+};
+
+template <>
+struct compressed_pair_chooser<true, false, false>
+{
+ template <class T1, class T2>
+ struct rebind
+ {
+ typedef compressed_pair_2<T1, T2> type;
+ };
+};
+
+template <>
+struct compressed_pair_chooser<true, true, false>
+{
+ template <class T1, class T2>
+ struct rebind
+ {
+ typedef compressed_pair_3<T1, T2> type;
+ };
+};
+
+template <>
+struct compressed_pair_chooser<true, true, true>
+{
+ template <class T1, class T2>
+ struct rebind
+ {
+ typedef compressed_pair_4<T1, T2> type;
+ };
+};
+
+template <>
+struct compressed_pair_chooser<false, false, true>
+{
+ template <class T1, class T2>
+ struct rebind
+ {
+ typedef compressed_pair_5<T1, T2> type;
+ };
+};
+
+template <class T1, class T2>
+struct compressed_pair_traits
+{
+private:
+ typedef compressed_pair_chooser<is_empty<T1>::value, is_empty<T2>::value, is_same<T1,T2>::value> chooser;
+ typedef typename chooser::template rebind<T1, T2> bound_type;
+public:
+ typedef typename bound_type::type type;
+};
+
+} // namespace detail
+
+template <class T1, class T2>
+class compressed_pair : public detail::compressed_pair_traits<T1, T2>::type
+{
+private:
+ typedef typename detail::compressed_pair_traits<T1, T2>::type base_type;
+public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair() : base_type() {}
+ compressed_pair(first_param_type x, second_param_type y) : base_type(x, y) {}
+ template <class A>
+ explicit compressed_pair(const A& x) : base_type(x){}
+
+ first_reference first() { return base_type::first(); }
+ first_const_reference first() const { return base_type::first(); }
+
+ second_reference second() { return base_type::second(); }
+ second_const_reference second() const { return base_type::second(); }
+};
+
+template <class T1, class T2>
+inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
+{
+ x.swap(y);
+}
+
+#else
+// no partial specialisation, no member templates:
+
+template <class T1, class T2>
+class compressed_pair
+{
+private:
+ T1 _first;
+ T2 _second;
+public:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ typedef typename call_traits<first_type>::reference first_reference;
+ typedef typename call_traits<second_type>::reference second_reference;
+ typedef typename call_traits<first_type>::const_reference first_const_reference;
+ typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+ compressed_pair() : _first(), _second() {}
+ compressed_pair(first_param_type x, second_param_type y) : _first(x), _second(y) {}
+ explicit compressed_pair(first_param_type x) : _first(x), _second() {}
+ // can't define this in case T1 == T2:
+ // explicit compressed_pair(second_param_type y) : _first(), _second(y) {}
+
+ first_reference first() { return _first; }
+ first_const_reference first() const { return _first; }
+
+ second_reference second() { return _second; }
+ second_const_reference second() const { return _second; }
+
+ void swap(compressed_pair& y)
+ {
+ using std::swap;
+ swap(_first, y._first);
+ swap(_second, y._second);
+ }
+};
+
+template <class T1, class T2>
+inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
+{
+ x.swap(y);
+}
+
+#endif
+
+} // boost
+
+#endif // BOOST_OB_COMPRESSED_PAIR_HPP
+
+
+
diff --git a/include/boost/operators.hpp b/include/boost/operators.hpp
new file mode 100644
index 0000000..156571c
--- /dev/null
+++ b/include/boost/operators.hpp
@@ -0,0 +1,911 @@
+// Boost operators.hpp header file ----------------------------------------//
+
+// (C) Copyright David Abrahams, Jeremy Siek, Daryle Walker 1999-2001.
+// (C) Copyright Daniel Frey 2002-2017.
+// 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/utility/operators.htm for documentation.
+
+// Revision History
+// 23 Nov 17 Protect dereferenceable<> from overloaded operator&.
+// 15 Oct 17 Adapted to C++17, replace std::iterator<> with manual
+// implementation.
+// 22 Feb 16 Added ADL protection, preserve old work-arounds in
+// operators_v1.hpp and clean up this file. (Daniel Frey)
+// 16 Dec 10 Limit warning suppression for 4284 to older versions of VC++
+// (Matthew Bradbury, fixes #4432)
+// 07 Aug 08 Added "euclidean" spelling. (Daniel Frey)
+// 03 Apr 08 Make sure "convertible to bool" is sufficient
+// for T::operator<, etc. (Daniel Frey)
+// 24 May 07 Changed empty_base to depend on T, see
+// http://svn.boost.org/trac/boost/ticket/979
+// 21 Oct 02 Modified implementation of operators to allow compilers with a
+// correct named return value optimization (NRVO) to produce optimal
+// code. (Daniel Frey)
+// 02 Dec 01 Bug fixed in random_access_iteratable. (Helmut Zeisel)
+// 28 Sep 01 Factored out iterator operator groups. (Daryle Walker)
+// 27 Aug 01 'left' form for non commutative operators added;
+// additional classes for groups of related operators added;
+// workaround for empty base class optimization
+// bug of GCC 3.0 (Helmut Zeisel)
+// 25 Jun 01 output_iterator_helper changes: removed default template
+// parameters, added support for self-proxying, additional
+// documentation and tests (Aleksey Gurtovoy)
+// 29 May 01 Added operator classes for << and >>. Added input and output
+// iterator helper classes. Added classes to connect equality and
+// relational operators. Added classes for groups of related
+// operators. Reimplemented example operator and iterator helper
+// classes in terms of the new groups. (Daryle Walker, with help
+// from Alexy Gurtovoy)
+// 11 Feb 01 Fixed bugs in the iterator helpers which prevented explicitly
+// supplied arguments from actually being used (Dave Abrahams)
+// 04 Jul 00 Fixed NO_OPERATORS_IN_NAMESPACE bugs, major cleanup and
+// refactoring of compiler workarounds, additional documentation
+// (Alexy Gurtovoy and Mark Rodgers with some help and prompting from
+// Dave Abrahams)
+// 28 Jun 00 General cleanup and integration of bugfixes from Mark Rodgers and
+// Jeremy Siek (Dave Abrahams)
+// 20 Jun 00 Changes to accommodate Borland C++Builder 4 and Borland C++ 5.5
+// (Mark Rodgers)
+// 20 Jun 00 Minor fixes to the prior revision (Aleksey Gurtovoy)
+// 10 Jun 00 Support for the base class chaining technique was added
+// (Aleksey Gurtovoy). See documentation and the comments below
+// for the details.
+// 12 Dec 99 Initial version with iterator operators (Jeremy Siek)
+// 18 Nov 99 Change name "divideable" to "dividable", remove unnecessary
+// specializations of dividable, subtractable, modable (Ed Brey)
+// 17 Nov 99 Add comments (Beman Dawes)
+// Remove unnecessary specialization of operators<> (Ed Brey)
+// 15 Nov 99 Fix less_than_comparable<T,U> second operand type for first two
+// operators.(Beman Dawes)
+// 12 Nov 99 Add operators templates (Ed Brey)
+// 11 Nov 99 Add single template parameter version for compilers without
+// partial specialization (Beman Dawes)
+// 10 Nov 99 Initial version
+
+// 10 Jun 00:
+// An additional optional template parameter was added to most of
+// operator templates to support the base class chaining technique (see
+// documentation for the details). Unfortunately, a straightforward
+// implementation of this change would have broken compatibility with the
+// previous version of the library by making it impossible to use the same
+// template name (e.g. 'addable') for both the 1- and 2-argument versions of
+// an operator template. This implementation solves the backward-compatibility
+// issue at the cost of some simplicity.
+//
+// One of the complications is an existence of special auxiliary class template
+// 'is_chained_base<>' (see 'operators_detail' namespace below), which is used
+// to determine whether its template parameter is a library's operator template
+// or not. You have to specialize 'is_chained_base<>' for each new
+// operator template you add to the library.
+//
+// However, most of the non-trivial implementation details are hidden behind
+// several local macros defined below, and as soon as you understand them,
+// you understand the whole library implementation.
+
+#ifndef BOOST_OPERATORS_HPP
+#define BOOST_OPERATORS_HPP
+
+// If old work-arounds are needed, refer to the preserved version without
+// ADL protection.
+#if defined(BOOST_NO_OPERATORS_IN_NAMESPACE) || defined(BOOST_USE_OPERATORS_V1)
+#include "operators_v1.hpp"
+#else
+
+#include <cstddef>
+#include <iterator>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/core/addressof.hpp>
+
+#if defined(__sgi) && !defined(__GNUC__)
+# pragma set woff 1234
+#endif
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1600)
+# pragma warning( disable : 4284 ) // complaint about return type of
+#endif // operator-> not begin a UDT
+
+// In this section we supply the xxxx1 and xxxx2 forms of the operator
+// templates, which are explicitly targeted at the 1-type-argument and
+// 2-type-argument operator forms, respectively.
+
+namespace boost
+{
+namespace operators_impl
+{
+namespace operators_detail
+{
+
+template <typename T> class empty_base {};
+
+} // namespace operators_detail
+
+// Basic operator classes (contributed by Dave Abrahams) ------------------//
+
+// Note that friend functions defined in a class are implicitly inline.
+// See the C++ std, 11.4 [class.friend] paragraph 5
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct less_than_comparable2 : B
+{
+ friend bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
+ friend bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
+ friend bool operator>(const U& x, const T& y) { return y < x; }
+ friend bool operator<(const U& x, const T& y) { return y > x; }
+ friend bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
+ friend bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); }
+};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct less_than_comparable1 : B
+{
+ friend bool operator>(const T& x, const T& y) { return y < x; }
+ friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
+ friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
+};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct equality_comparable2 : B
+{
+ friend bool operator==(const U& y, const T& x) { return x == y; }
+ friend bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
+ friend bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
+};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct equality_comparable1 : B
+{
+ friend bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
+};
+
+// A macro which produces "name_2left" from "name".
+#define BOOST_OPERATOR2_LEFT(name) name##2##_##left
+
+// NRVO-friendly implementation (contributed by Daniel Frey) ---------------//
+
+#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+// This is the optimal implementation for ISO/ANSI C++,
+// but it requires the compiler to implement the NRVO.
+// If the compiler has no NRVO, this is the best symmetric
+// implementation available.
+
+#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP ) \
+template <class T, class U, class B = operators_detail::empty_base<T> > \
+struct NAME##2 : B \
+{ \
+ friend T operator OP( const T& lhs, const U& rhs ) \
+ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
+ friend T operator OP( const U& lhs, const T& rhs ) \
+ { T nrv( rhs ); nrv OP##= lhs; return nrv; } \
+}; \
+ \
+template <class T, class B = operators_detail::empty_base<T> > \
+struct NAME##1 : B \
+{ \
+ friend T operator OP( const T& lhs, const T& rhs ) \
+ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
+};
+
+#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP ) \
+template <class T, class U, class B = operators_detail::empty_base<T> > \
+struct NAME##2 : B \
+{ \
+ friend T operator OP( const T& lhs, const U& rhs ) \
+ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
+}; \
+ \
+template <class T, class U, class B = operators_detail::empty_base<T> > \
+struct BOOST_OPERATOR2_LEFT(NAME) : B \
+{ \
+ friend T operator OP( const U& lhs, const T& rhs ) \
+ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
+}; \
+ \
+template <class T, class B = operators_detail::empty_base<T> > \
+struct NAME##1 : B \
+{ \
+ friend T operator OP( const T& lhs, const T& rhs ) \
+ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
+};
+
+#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+// For compilers without NRVO the following code is optimal, but not
+// symmetric! Note that the implementation of
+// BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide
+// optimization opportunities to the compiler :)
+
+#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP ) \
+template <class T, class U, class B = operators_detail::empty_base<T> > \
+struct NAME##2 : B \
+{ \
+ friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
+ friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; } \
+}; \
+ \
+template <class T, class B = operators_detail::empty_base<T> > \
+struct NAME##1 : B \
+{ \
+ friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
+};
+
+#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP ) \
+template <class T, class U, class B = operators_detail::empty_base<T> > \
+struct NAME##2 : B \
+{ \
+ friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
+}; \
+ \
+template <class T, class U, class B = operators_detail::empty_base<T> > \
+struct BOOST_OPERATOR2_LEFT(NAME) : B \
+{ \
+ friend T operator OP( const U& lhs, const T& rhs ) \
+ { return T( lhs ) OP##= rhs; } \
+}; \
+ \
+template <class T, class B = operators_detail::empty_base<T> > \
+struct NAME##1 : B \
+{ \
+ friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
+};
+
+#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+BOOST_BINARY_OPERATOR_COMMUTATIVE( multipliable, * )
+BOOST_BINARY_OPERATOR_COMMUTATIVE( addable, + )
+BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( subtractable, - )
+BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( dividable, / )
+BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( modable, % )
+BOOST_BINARY_OPERATOR_COMMUTATIVE( xorable, ^ )
+BOOST_BINARY_OPERATOR_COMMUTATIVE( andable, & )
+BOOST_BINARY_OPERATOR_COMMUTATIVE( orable, | )
+
+#undef BOOST_BINARY_OPERATOR_COMMUTATIVE
+#undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
+#undef BOOST_OPERATOR2_LEFT
+
+// incrementable and decrementable contributed by Jeremy Siek
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct incrementable : B
+{
+ friend T operator++(T& x, int)
+ {
+ incrementable_type nrv(x);
+ ++x;
+ return nrv;
+ }
+private: // The use of this typedef works around a Borland bug
+ typedef T incrementable_type;
+};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct decrementable : B
+{
+ friend T operator--(T& x, int)
+ {
+ decrementable_type nrv(x);
+ --x;
+ return nrv;
+ }
+private: // The use of this typedef works around a Borland bug
+ typedef T decrementable_type;
+};
+
+// Iterator operator classes (contributed by Jeremy Siek) ------------------//
+
+template <class T, class P, class B = operators_detail::empty_base<T> >
+struct dereferenceable : B
+{
+ P operator->() const
+ {
+ return ::boost::addressof(*static_cast<const T&>(*this));
+ }
+};
+
+template <class T, class I, class R, class B = operators_detail::empty_base<T> >
+struct indexable : B
+{
+ R operator[](I n) const
+ {
+ return *(static_cast<const T&>(*this) + n);
+ }
+};
+
+// More operator classes (contributed by Daryle Walker) --------------------//
+// (NRVO-friendly implementation contributed by Daniel Frey) ---------------//
+
+#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+#define BOOST_BINARY_OPERATOR( NAME, OP ) \
+template <class T, class U, class B = operators_detail::empty_base<T> > \
+struct NAME##2 : B \
+{ \
+ friend T operator OP( const T& lhs, const U& rhs ) \
+ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
+}; \
+ \
+template <class T, class B = operators_detail::empty_base<T> > \
+struct NAME##1 : B \
+{ \
+ friend T operator OP( const T& lhs, const T& rhs ) \
+ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
+};
+
+#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+#define BOOST_BINARY_OPERATOR( NAME, OP ) \
+template <class T, class U, class B = operators_detail::empty_base<T> > \
+struct NAME##2 : B \
+{ \
+ friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
+}; \
+ \
+template <class T, class B = operators_detail::empty_base<T> > \
+struct NAME##1 : B \
+{ \
+ friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
+};
+
+#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+BOOST_BINARY_OPERATOR( left_shiftable, << )
+BOOST_BINARY_OPERATOR( right_shiftable, >> )
+
+#undef BOOST_BINARY_OPERATOR
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct equivalent2 : B
+{
+ friend bool operator==(const T& x, const U& y)
+ {
+ return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
+ }
+};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct equivalent1 : B
+{
+ friend bool operator==(const T&x, const T&y)
+ {
+ return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
+ }
+};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct partially_ordered2 : B
+{
+ friend bool operator<=(const T& x, const U& y)
+ { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
+ friend bool operator>=(const T& x, const U& y)
+ { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
+ friend bool operator>(const U& x, const T& y)
+ { return y < x; }
+ friend bool operator<(const U& x, const T& y)
+ { return y > x; }
+ friend bool operator<=(const U& x, const T& y)
+ { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
+ friend bool operator>=(const U& x, const T& y)
+ { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
+};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct partially_ordered1 : B
+{
+ friend bool operator>(const T& x, const T& y)
+ { return y < x; }
+ friend bool operator<=(const T& x, const T& y)
+ { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
+ friend bool operator>=(const T& x, const T& y)
+ { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
+};
+
+// Combined operator classes (contributed by Daryle Walker) ----------------//
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct totally_ordered2
+ : less_than_comparable2<T, U
+ , equality_comparable2<T, U, B
+ > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct totally_ordered1
+ : less_than_comparable1<T
+ , equality_comparable1<T, B
+ > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct additive2
+ : addable2<T, U
+ , subtractable2<T, U, B
+ > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct additive1
+ : addable1<T
+ , subtractable1<T, B
+ > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct multiplicative2
+ : multipliable2<T, U
+ , dividable2<T, U, B
+ > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct multiplicative1
+ : multipliable1<T
+ , dividable1<T, B
+ > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct integer_multiplicative2
+ : multiplicative2<T, U
+ , modable2<T, U, B
+ > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct integer_multiplicative1
+ : multiplicative1<T
+ , modable1<T, B
+ > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct arithmetic2
+ : additive2<T, U
+ , multiplicative2<T, U, B
+ > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct arithmetic1
+ : additive1<T
+ , multiplicative1<T, B
+ > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct integer_arithmetic2
+ : additive2<T, U
+ , integer_multiplicative2<T, U, B
+ > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct integer_arithmetic1
+ : additive1<T
+ , integer_multiplicative1<T, B
+ > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct bitwise2
+ : xorable2<T, U
+ , andable2<T, U
+ , orable2<T, U, B
+ > > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct bitwise1
+ : xorable1<T
+ , andable1<T
+ , orable1<T, B
+ > > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct unit_steppable
+ : incrementable<T
+ , decrementable<T, B
+ > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct shiftable2
+ : left_shiftable2<T, U
+ , right_shiftable2<T, U, B
+ > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct shiftable1
+ : left_shiftable1<T
+ , right_shiftable1<T, B
+ > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct ring_operators2
+ : additive2<T, U
+ , subtractable2_left<T, U
+ , multipliable2<T, U, B
+ > > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct ring_operators1
+ : additive1<T
+ , multipliable1<T, B
+ > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct ordered_ring_operators2
+ : ring_operators2<T, U
+ , totally_ordered2<T, U, B
+ > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct ordered_ring_operators1
+ : ring_operators1<T
+ , totally_ordered1<T, B
+ > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct field_operators2
+ : ring_operators2<T, U
+ , dividable2<T, U
+ , dividable2_left<T, U, B
+ > > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct field_operators1
+ : ring_operators1<T
+ , dividable1<T, B
+ > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct ordered_field_operators2
+ : field_operators2<T, U
+ , totally_ordered2<T, U, B
+ > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct ordered_field_operators1
+ : field_operators1<T
+ , totally_ordered1<T, B
+ > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct euclidian_ring_operators2
+ : ring_operators2<T, U
+ , dividable2<T, U
+ , dividable2_left<T, U
+ , modable2<T, U
+ , modable2_left<T, U, B
+ > > > > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct euclidian_ring_operators1
+ : ring_operators1<T
+ , dividable1<T
+ , modable1<T, B
+ > > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct ordered_euclidian_ring_operators2
+ : totally_ordered2<T, U
+ , euclidian_ring_operators2<T, U, B
+ > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct ordered_euclidian_ring_operators1
+ : totally_ordered1<T
+ , euclidian_ring_operators1<T, B
+ > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct euclidean_ring_operators2
+ : ring_operators2<T, U
+ , dividable2<T, U
+ , dividable2_left<T, U
+ , modable2<T, U
+ , modable2_left<T, U, B
+ > > > > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct euclidean_ring_operators1
+ : ring_operators1<T
+ , dividable1<T
+ , modable1<T, B
+ > > > {};
+
+template <class T, class U, class B = operators_detail::empty_base<T> >
+struct ordered_euclidean_ring_operators2
+ : totally_ordered2<T, U
+ , euclidean_ring_operators2<T, U, B
+ > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct ordered_euclidean_ring_operators1
+ : totally_ordered1<T
+ , euclidean_ring_operators1<T, B
+ > > {};
+
+template <class T, class P, class B = operators_detail::empty_base<T> >
+struct input_iteratable
+ : equality_comparable1<T
+ , incrementable<T
+ , dereferenceable<T, P, B
+ > > > {};
+
+template <class T, class B = operators_detail::empty_base<T> >
+struct output_iteratable
+ : incrementable<T, B
+ > {};
+
+template <class T, class P, class B = operators_detail::empty_base<T> >
+struct forward_iteratable
+ : input_iteratable<T, P, B
+ > {};
+
+template <class T, class P, class B = operators_detail::empty_base<T> >
+struct bidirectional_iteratable
+ : forward_iteratable<T, P
+ , decrementable<T, B
+ > > {};
+
+// To avoid repeated derivation from equality_comparable,
+// which is an indirect base class of bidirectional_iterable,
+// random_access_iteratable must not be derived from totally_ordered1
+// but from less_than_comparable1 only. (Helmut Zeisel, 02-Dec-2001)
+template <class T, class P, class D, class R, class B = operators_detail::empty_base<T> >
+struct random_access_iteratable
+ : bidirectional_iteratable<T, P
+ , less_than_comparable1<T
+ , additive2<T, D
+ , indexable<T, D, R, B
+ > > > > {};
+
+
+//
+// Here's where we put it all together, defining the xxxx forms of the templates.
+// We also define specializations of is_chained_base<> for
+// the xxxx, xxxx1, and xxxx2 templates.
+//
+
+namespace operators_detail
+{
+
+// A type parameter is used instead of a plain bool because Borland's compiler
+// didn't cope well with the more obvious non-type template parameter.
+struct true_t {};
+struct false_t {};
+
+} // namespace operators_detail
+
+// is_chained_base<> - a traits class used to distinguish whether an operator
+// template argument is being used for base class chaining, or is specifying a
+// 2nd argument type.
+
+// Unspecialized version assumes that most types are not being used for base
+// class chaining. We specialize for the operator templates defined in this
+// library.
+template<class T> struct is_chained_base {
+ typedef operators_detail::false_t value;
+};
+
+// Provide a specialization of 'is_chained_base<>'
+// for a 4-type-argument operator template.
+# define BOOST_OPERATOR_TEMPLATE4(template_name4) \
+ template<class T, class U, class V, class W, class B> \
+ struct is_chained_base< template_name4<T, U, V, W, B> > { \
+ typedef operators_detail::true_t value; \
+ };
+
+// Provide a specialization of 'is_chained_base<>'
+// for a 3-type-argument operator template.
+# define BOOST_OPERATOR_TEMPLATE3(template_name3) \
+ template<class T, class U, class V, class B> \
+ struct is_chained_base< template_name3<T, U, V, B> > { \
+ typedef operators_detail::true_t value; \
+ };
+
+// Provide a specialization of 'is_chained_base<>'
+// for a 2-type-argument operator template.
+# define BOOST_OPERATOR_TEMPLATE2(template_name2) \
+ template<class T, class U, class B> \
+ struct is_chained_base< template_name2<T, U, B> > { \
+ typedef operators_detail::true_t value; \
+ };
+
+// Provide a specialization of 'is_chained_base<>'
+// for a 1-type-argument operator template.
+# define BOOST_OPERATOR_TEMPLATE1(template_name1) \
+ template<class T, class B> \
+ struct is_chained_base< template_name1<T, B> > { \
+ typedef operators_detail::true_t value; \
+ };
+
+// BOOST_OPERATOR_TEMPLATE(template_name) defines template_name<> such that it
+// can be used for specifying both 1-argument and 2-argument forms. Requires the
+// existence of two previously defined class templates named '<template_name>1'
+// and '<template_name>2' which must implement the corresponding 1- and 2-
+// argument forms.
+//
+// The template type parameter O == is_chained_base<U>::value is used to
+// distinguish whether the 2nd argument to <template_name> is being used for
+// base class chaining from another boost operator template or is describing a
+// 2nd operand type. O == true_t only when U is actually an another operator
+// template from the library. Partial specialization is used to select an
+// implementation in terms of either '<template_name>1' or '<template_name>2'.
+//
+
+# define BOOST_OPERATOR_TEMPLATE(template_name) \
+template <class T \
+ ,class U = T \
+ ,class B = operators_detail::empty_base<T> \
+ ,class O = typename is_chained_base<U>::value \
+ > \
+struct template_name; \
+ \
+template<class T, class U, class B> \
+struct template_name<T, U, B, operators_detail::false_t> \
+ : template_name##2<T, U, B> {}; \
+ \
+template<class T, class U> \
+struct template_name<T, U, operators_detail::empty_base<T>, operators_detail::true_t> \
+ : template_name##1<T, U> {}; \
+ \
+template <class T, class B> \
+struct template_name<T, T, B, operators_detail::false_t> \
+ : template_name##1<T, B> {}; \
+ \
+template<class T, class U, class B, class O> \
+struct is_chained_base< template_name<T, U, B, O> > { \
+ typedef operators_detail::true_t value; \
+}; \
+ \
+BOOST_OPERATOR_TEMPLATE2(template_name##2) \
+BOOST_OPERATOR_TEMPLATE1(template_name##1)
+
+BOOST_OPERATOR_TEMPLATE(less_than_comparable)
+BOOST_OPERATOR_TEMPLATE(equality_comparable)
+BOOST_OPERATOR_TEMPLATE(multipliable)
+BOOST_OPERATOR_TEMPLATE(addable)
+BOOST_OPERATOR_TEMPLATE(subtractable)
+BOOST_OPERATOR_TEMPLATE2(subtractable2_left)
+BOOST_OPERATOR_TEMPLATE(dividable)
+BOOST_OPERATOR_TEMPLATE2(dividable2_left)
+BOOST_OPERATOR_TEMPLATE(modable)
+BOOST_OPERATOR_TEMPLATE2(modable2_left)
+BOOST_OPERATOR_TEMPLATE(xorable)
+BOOST_OPERATOR_TEMPLATE(andable)
+BOOST_OPERATOR_TEMPLATE(orable)
+
+BOOST_OPERATOR_TEMPLATE1(incrementable)
+BOOST_OPERATOR_TEMPLATE1(decrementable)
+
+BOOST_OPERATOR_TEMPLATE2(dereferenceable)
+BOOST_OPERATOR_TEMPLATE3(indexable)
+
+BOOST_OPERATOR_TEMPLATE(left_shiftable)
+BOOST_OPERATOR_TEMPLATE(right_shiftable)
+BOOST_OPERATOR_TEMPLATE(equivalent)
+BOOST_OPERATOR_TEMPLATE(partially_ordered)
+
+BOOST_OPERATOR_TEMPLATE(totally_ordered)
+BOOST_OPERATOR_TEMPLATE(additive)
+BOOST_OPERATOR_TEMPLATE(multiplicative)
+BOOST_OPERATOR_TEMPLATE(integer_multiplicative)
+BOOST_OPERATOR_TEMPLATE(arithmetic)
+BOOST_OPERATOR_TEMPLATE(integer_arithmetic)
+BOOST_OPERATOR_TEMPLATE(bitwise)
+BOOST_OPERATOR_TEMPLATE1(unit_steppable)
+BOOST_OPERATOR_TEMPLATE(shiftable)
+BOOST_OPERATOR_TEMPLATE(ring_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_ring_operators)
+BOOST_OPERATOR_TEMPLATE(field_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_field_operators)
+BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators)
+BOOST_OPERATOR_TEMPLATE(euclidean_ring_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_euclidean_ring_operators)
+BOOST_OPERATOR_TEMPLATE2(input_iteratable)
+BOOST_OPERATOR_TEMPLATE1(output_iteratable)
+BOOST_OPERATOR_TEMPLATE2(forward_iteratable)
+BOOST_OPERATOR_TEMPLATE2(bidirectional_iteratable)
+BOOST_OPERATOR_TEMPLATE4(random_access_iteratable)
+
+#undef BOOST_OPERATOR_TEMPLATE
+#undef BOOST_OPERATOR_TEMPLATE4
+#undef BOOST_OPERATOR_TEMPLATE3
+#undef BOOST_OPERATOR_TEMPLATE2
+#undef BOOST_OPERATOR_TEMPLATE1
+
+template <class T, class U>
+struct operators2
+ : totally_ordered2<T,U
+ , integer_arithmetic2<T,U
+ , bitwise2<T,U
+ > > > {};
+
+template <class T, class U = T>
+struct operators : operators2<T, U> {};
+
+template <class T> struct operators<T, T>
+ : totally_ordered<T
+ , integer_arithmetic<T
+ , bitwise<T
+ , unit_steppable<T
+ > > > > {};
+
+// Iterator helper classes (contributed by Jeremy Siek) -------------------//
+// (Input and output iterator helpers contributed by Daryle Walker) -------//
+// (Changed to use combined operator classes by Daryle Walker) ------------//
+// (Adapted to C++17 by Daniel Frey) --------------------------------------//
+template <class Category,
+ class T,
+ class Distance = std::ptrdiff_t,
+ class Pointer = T*,
+ class Reference = T&>
+struct iterator_helper
+{
+ typedef Category iterator_category;
+ typedef T value_type;
+ typedef Distance difference_type;
+ typedef Pointer pointer;
+ typedef Reference reference;
+};
+
+template <class T,
+ class V,
+ class D = std::ptrdiff_t,
+ class P = V const *,
+ class R = V const &>
+struct input_iterator_helper
+ : input_iteratable<T, P
+ , iterator_helper<std::input_iterator_tag, V, D, P, R
+ > > {};
+
+template<class T>
+struct output_iterator_helper
+ : output_iteratable<T
+ , iterator_helper<std::output_iterator_tag, void, void, void, void
+ > >
+{
+ T& operator*() { return static_cast<T&>(*this); }
+ T& operator++() { return static_cast<T&>(*this); }
+};
+
+template <class T,
+ class V,
+ class D = std::ptrdiff_t,
+ class P = V*,
+ class R = V&>
+struct forward_iterator_helper
+ : forward_iteratable<T, P
+ , iterator_helper<std::forward_iterator_tag, V, D, P, R
+ > > {};
+
+template <class T,
+ class V,
+ class D = std::ptrdiff_t,
+ class P = V*,
+ class R = V&>
+struct bidirectional_iterator_helper
+ : bidirectional_iteratable<T, P
+ , iterator_helper<std::bidirectional_iterator_tag, V, D, P, R
+ > > {};
+
+template <class T,
+ class V,
+ class D = std::ptrdiff_t,
+ class P = V*,
+ class R = V&>
+struct random_access_iterator_helper
+ : random_access_iteratable<T, P, D, R
+ , iterator_helper<std::random_access_iterator_tag, V, D, P, R
+ > >
+{
+ friend D requires_difference_operator(const T& x, const T& y) {
+ return x - y;
+ }
+}; // random_access_iterator_helper
+
+} // namespace operators_impl
+using namespace operators_impl;
+
+} // namespace boost
+
+#if defined(__sgi) && !defined(__GNUC__)
+#pragma reset woff 1234
+#endif
+
+#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
+#endif // BOOST_OPERATORS_HPP
diff --git a/include/boost/operators_v1.hpp b/include/boost/operators_v1.hpp
new file mode 100644
index 0000000..e1c53e8
--- /dev/null
+++ b/include/boost/operators_v1.hpp
@@ -0,0 +1,951 @@
+// Boost operators.hpp header file ----------------------------------------//
+
+// (C) Copyright David Abrahams, Jeremy Siek, Daryle Walker 1999-2001.
+// 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/utility/operators.htm for documentation.
+
+// Revision History
+// 22 Feb 16 Preserve old work-arounds. (Daniel Frey)
+// 16 Dec 10 Limit warning suppression for 4284 to older versions of VC++
+// (Matthew Bradbury, fixes #4432)
+// 07 Aug 08 Added "euclidean" spelling. (Daniel Frey)
+// 03 Apr 08 Make sure "convertible to bool" is sufficient
+// for T::operator<, etc. (Daniel Frey)
+// 24 May 07 Changed empty_base to depend on T, see
+// http://svn.boost.org/trac/boost/ticket/979
+// 21 Oct 02 Modified implementation of operators to allow compilers with a
+// correct named return value optimization (NRVO) to produce optimal
+// code. (Daniel Frey)
+// 02 Dec 01 Bug fixed in random_access_iteratable. (Helmut Zeisel)
+// 28 Sep 01 Factored out iterator operator groups. (Daryle Walker)
+// 27 Aug 01 'left' form for non commutative operators added;
+// additional classes for groups of related operators added;
+// workaround for empty base class optimization
+// bug of GCC 3.0 (Helmut Zeisel)
+// 25 Jun 01 output_iterator_helper changes: removed default template
+// parameters, added support for self-proxying, additional
+// documentation and tests (Aleksey Gurtovoy)
+// 29 May 01 Added operator classes for << and >>. Added input and output
+// iterator helper classes. Added classes to connect equality and
+// relational operators. Added classes for groups of related
+// operators. Reimplemented example operator and iterator helper
+// classes in terms of the new groups. (Daryle Walker, with help
+// from Alexy Gurtovoy)
+// 11 Feb 01 Fixed bugs in the iterator helpers which prevented explicitly
+// supplied arguments from actually being used (Dave Abrahams)
+// 04 Jul 00 Fixed NO_OPERATORS_IN_NAMESPACE bugs, major cleanup and
+// refactoring of compiler workarounds, additional documentation
+// (Alexy Gurtovoy and Mark Rodgers with some help and prompting from
+// Dave Abrahams)
+// 28 Jun 00 General cleanup and integration of bugfixes from Mark Rodgers and
+// Jeremy Siek (Dave Abrahams)
+// 20 Jun 00 Changes to accommodate Borland C++Builder 4 and Borland C++ 5.5
+// (Mark Rodgers)
+// 20 Jun 00 Minor fixes to the prior revision (Aleksey Gurtovoy)
+// 10 Jun 00 Support for the base class chaining technique was added
+// (Aleksey Gurtovoy). See documentation and the comments below
+// for the details.
+// 12 Dec 99 Initial version with iterator operators (Jeremy Siek)
+// 18 Nov 99 Change name "divideable" to "dividable", remove unnecessary
+// specializations of dividable, subtractable, modable (Ed Brey)
+// 17 Nov 99 Add comments (Beman Dawes)
+// Remove unnecessary specialization of operators<> (Ed Brey)
+// 15 Nov 99 Fix less_than_comparable<T,U> second operand type for first two
+// operators.(Beman Dawes)
+// 12 Nov 99 Add operators templates (Ed Brey)
+// 11 Nov 99 Add single template parameter version for compilers without
+// partial specialization (Beman Dawes)
+// 10 Nov 99 Initial version
+
+// 10 Jun 00:
+// An additional optional template parameter was added to most of
+// operator templates to support the base class chaining technique (see
+// documentation for the details). Unfortunately, a straightforward
+// implementation of this change would have broken compatibility with the
+// previous version of the library by making it impossible to use the same
+// template name (e.g. 'addable') for both the 1- and 2-argument versions of
+// an operator template. This implementation solves the backward-compatibility
+// issue at the cost of some simplicity.
+//
+// One of the complications is an existence of special auxiliary class template
+// 'is_chained_base<>' (see 'detail' namespace below), which is used
+// to determine whether its template parameter is a library's operator template
+// or not. You have to specialize 'is_chained_base<>' for each new
+// operator template you add to the library.
+//
+// However, most of the non-trivial implementation details are hidden behind
+// several local macros defined below, and as soon as you understand them,
+// you understand the whole library implementation.
+
+#ifndef BOOST_OPERATORS_V1_HPP
+#define BOOST_OPERATORS_V1_HPP
+
+#include <cstddef>
+#include <iterator>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if defined(__sgi) && !defined(__GNUC__)
+# pragma set woff 1234
+#endif
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1600)
+# pragma warning( disable : 4284 ) // complaint about return type of
+#endif // operator-> not begin a UDT
+
+namespace boost {
+namespace detail {
+
+template <typename T> class empty_base {};
+
+} // namespace detail
+} // namespace boost
+
+// In this section we supply the xxxx1 and xxxx2 forms of the operator
+// templates, which are explicitly targeted at the 1-type-argument and
+// 2-type-argument operator forms, respectively. Some compilers get confused
+// when inline friend functions are overloaded in namespaces other than the
+// global namespace. When BOOST_NO_OPERATORS_IN_NAMESPACE is defined, all of
+// these templates must go in the global namespace.
+
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+namespace boost
+{
+#endif
+
+// Basic operator classes (contributed by Dave Abrahams) ------------------//
+
+// Note that friend functions defined in a class are implicitly inline.
+// See the C++ std, 11.4 [class.friend] paragraph 5
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct less_than_comparable2 : B
+{
+ friend bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
+ friend bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
+ friend bool operator>(const U& x, const T& y) { return y < x; }
+ friend bool operator<(const U& x, const T& y) { return y > x; }
+ friend bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
+ friend bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); }
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct less_than_comparable1 : B
+{
+ friend bool operator>(const T& x, const T& y) { return y < x; }
+ friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
+ friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
+};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct equality_comparable2 : B
+{
+ friend bool operator==(const U& y, const T& x) { return x == y; }
+ friend bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
+ friend bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct equality_comparable1 : B
+{
+ friend bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
+};
+
+// A macro which produces "name_2left" from "name".
+#define BOOST_OPERATOR2_LEFT(name) name##2##_##left
+
+// NRVO-friendly implementation (contributed by Daniel Frey) ---------------//
+
+#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+// This is the optimal implementation for ISO/ANSI C++,
+// but it requires the compiler to implement the NRVO.
+// If the compiler has no NRVO, this is the best symmetric
+// implementation available.
+
+#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP ) \
+template <class T, class U, class B = ::boost::detail::empty_base<T> > \
+struct NAME##2 : B \
+{ \
+ friend T operator OP( const T& lhs, const U& rhs ) \
+ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
+ friend T operator OP( const U& lhs, const T& rhs ) \
+ { T nrv( rhs ); nrv OP##= lhs; return nrv; } \
+}; \
+ \
+template <class T, class B = ::boost::detail::empty_base<T> > \
+struct NAME##1 : B \
+{ \
+ friend T operator OP( const T& lhs, const T& rhs ) \
+ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
+};
+
+#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP ) \
+template <class T, class U, class B = ::boost::detail::empty_base<T> > \
+struct NAME##2 : B \
+{ \
+ friend T operator OP( const T& lhs, const U& rhs ) \
+ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
+}; \
+ \
+template <class T, class U, class B = ::boost::detail::empty_base<T> > \
+struct BOOST_OPERATOR2_LEFT(NAME) : B \
+{ \
+ friend T operator OP( const U& lhs, const T& rhs ) \
+ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
+}; \
+ \
+template <class T, class B = ::boost::detail::empty_base<T> > \
+struct NAME##1 : B \
+{ \
+ friend T operator OP( const T& lhs, const T& rhs ) \
+ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
+};
+
+#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+// For compilers without NRVO the following code is optimal, but not
+// symmetric! Note that the implementation of
+// BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide
+// optimization opportunities to the compiler :)
+
+#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP ) \
+template <class T, class U, class B = ::boost::detail::empty_base<T> > \
+struct NAME##2 : B \
+{ \
+ friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
+ friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; } \
+}; \
+ \
+template <class T, class B = ::boost::detail::empty_base<T> > \
+struct NAME##1 : B \
+{ \
+ friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
+};
+
+#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP ) \
+template <class T, class U, class B = ::boost::detail::empty_base<T> > \
+struct NAME##2 : B \
+{ \
+ friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
+}; \
+ \
+template <class T, class U, class B = ::boost::detail::empty_base<T> > \
+struct BOOST_OPERATOR2_LEFT(NAME) : B \
+{ \
+ friend T operator OP( const U& lhs, const T& rhs ) \
+ { return T( lhs ) OP##= rhs; } \
+}; \
+ \
+template <class T, class B = ::boost::detail::empty_base<T> > \
+struct NAME##1 : B \
+{ \
+ friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
+};
+
+#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+BOOST_BINARY_OPERATOR_COMMUTATIVE( multipliable, * )
+BOOST_BINARY_OPERATOR_COMMUTATIVE( addable, + )
+BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( subtractable, - )
+BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( dividable, / )
+BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( modable, % )
+BOOST_BINARY_OPERATOR_COMMUTATIVE( xorable, ^ )
+BOOST_BINARY_OPERATOR_COMMUTATIVE( andable, & )
+BOOST_BINARY_OPERATOR_COMMUTATIVE( orable, | )
+
+#undef BOOST_BINARY_OPERATOR_COMMUTATIVE
+#undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
+#undef BOOST_OPERATOR2_LEFT
+
+// incrementable and decrementable contributed by Jeremy Siek
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct incrementable : B
+{
+ friend T operator++(T& x, int)
+ {
+ incrementable_type nrv(x);
+ ++x;
+ return nrv;
+ }
+private: // The use of this typedef works around a Borland bug
+ typedef T incrementable_type;
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct decrementable : B
+{
+ friend T operator--(T& x, int)
+ {
+ decrementable_type nrv(x);
+ --x;
+ return nrv;
+ }
+private: // The use of this typedef works around a Borland bug
+ typedef T decrementable_type;
+};
+
+// Iterator operator classes (contributed by Jeremy Siek) ------------------//
+
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
+struct dereferenceable : B
+{
+ P operator->() const
+ {
+ return &*static_cast<const T&>(*this);
+ }
+};
+
+template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
+struct indexable : B
+{
+ R operator[](I n) const
+ {
+ return *(static_cast<const T&>(*this) + n);
+ }
+};
+
+// More operator classes (contributed by Daryle Walker) --------------------//
+// (NRVO-friendly implementation contributed by Daniel Frey) ---------------//
+
+#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+#define BOOST_BINARY_OPERATOR( NAME, OP ) \
+template <class T, class U, class B = ::boost::detail::empty_base<T> > \
+struct NAME##2 : B \
+{ \
+ friend T operator OP( const T& lhs, const U& rhs ) \
+ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
+}; \
+ \
+template <class T, class B = ::boost::detail::empty_base<T> > \
+struct NAME##1 : B \
+{ \
+ friend T operator OP( const T& lhs, const T& rhs ) \
+ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
+};
+
+#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+#define BOOST_BINARY_OPERATOR( NAME, OP ) \
+template <class T, class U, class B = ::boost::detail::empty_base<T> > \
+struct NAME##2 : B \
+{ \
+ friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
+}; \
+ \
+template <class T, class B = ::boost::detail::empty_base<T> > \
+struct NAME##1 : B \
+{ \
+ friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
+};
+
+#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+BOOST_BINARY_OPERATOR( left_shiftable, << )
+BOOST_BINARY_OPERATOR( right_shiftable, >> )
+
+#undef BOOST_BINARY_OPERATOR
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct equivalent2 : B
+{
+ friend bool operator==(const T& x, const U& y)
+ {
+ return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
+ }
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct equivalent1 : B
+{
+ friend bool operator==(const T&x, const T&y)
+ {
+ return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
+ }
+};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct partially_ordered2 : B
+{
+ friend bool operator<=(const T& x, const U& y)
+ { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
+ friend bool operator>=(const T& x, const U& y)
+ { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
+ friend bool operator>(const U& x, const T& y)
+ { return y < x; }
+ friend bool operator<(const U& x, const T& y)
+ { return y > x; }
+ friend bool operator<=(const U& x, const T& y)
+ { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
+ friend bool operator>=(const U& x, const T& y)
+ { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct partially_ordered1 : B
+{
+ friend bool operator>(const T& x, const T& y)
+ { return y < x; }
+ friend bool operator<=(const T& x, const T& y)
+ { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
+ friend bool operator>=(const T& x, const T& y)
+ { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
+};
+
+// Combined operator classes (contributed by Daryle Walker) ----------------//
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct totally_ordered2
+ : less_than_comparable2<T, U
+ , equality_comparable2<T, U, B
+ > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct totally_ordered1
+ : less_than_comparable1<T
+ , equality_comparable1<T, B
+ > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct additive2
+ : addable2<T, U
+ , subtractable2<T, U, B
+ > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct additive1
+ : addable1<T
+ , subtractable1<T, B
+ > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct multiplicative2
+ : multipliable2<T, U
+ , dividable2<T, U, B
+ > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct multiplicative1
+ : multipliable1<T
+ , dividable1<T, B
+ > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct integer_multiplicative2
+ : multiplicative2<T, U
+ , modable2<T, U, B
+ > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct integer_multiplicative1
+ : multiplicative1<T
+ , modable1<T, B
+ > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct arithmetic2
+ : additive2<T, U
+ , multiplicative2<T, U, B
+ > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct arithmetic1
+ : additive1<T
+ , multiplicative1<T, B
+ > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct integer_arithmetic2
+ : additive2<T, U
+ , integer_multiplicative2<T, U, B
+ > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct integer_arithmetic1
+ : additive1<T
+ , integer_multiplicative1<T, B
+ > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct bitwise2
+ : xorable2<T, U
+ , andable2<T, U
+ , orable2<T, U, B
+ > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct bitwise1
+ : xorable1<T
+ , andable1<T
+ , orable1<T, B
+ > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct unit_steppable
+ : incrementable<T
+ , decrementable<T, B
+ > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct shiftable2
+ : left_shiftable2<T, U
+ , right_shiftable2<T, U, B
+ > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct shiftable1
+ : left_shiftable1<T
+ , right_shiftable1<T, B
+ > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ring_operators2
+ : additive2<T, U
+ , subtractable2_left<T, U
+ , multipliable2<T, U, B
+ > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ring_operators1
+ : additive1<T
+ , multipliable1<T, B
+ > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ordered_ring_operators2
+ : ring_operators2<T, U
+ , totally_ordered2<T, U, B
+ > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ordered_ring_operators1
+ : ring_operators1<T
+ , totally_ordered1<T, B
+ > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct field_operators2
+ : ring_operators2<T, U
+ , dividable2<T, U
+ , dividable2_left<T, U, B
+ > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct field_operators1
+ : ring_operators1<T
+ , dividable1<T, B
+ > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ordered_field_operators2
+ : field_operators2<T, U
+ , totally_ordered2<T, U, B
+ > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ordered_field_operators1
+ : field_operators1<T
+ , totally_ordered1<T, B
+ > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct euclidian_ring_operators2
+ : ring_operators2<T, U
+ , dividable2<T, U
+ , dividable2_left<T, U
+ , modable2<T, U
+ , modable2_left<T, U, B
+ > > > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct euclidian_ring_operators1
+ : ring_operators1<T
+ , dividable1<T
+ , modable1<T, B
+ > > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ordered_euclidian_ring_operators2
+ : totally_ordered2<T, U
+ , euclidian_ring_operators2<T, U, B
+ > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ordered_euclidian_ring_operators1
+ : totally_ordered1<T
+ , euclidian_ring_operators1<T, B
+ > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct euclidean_ring_operators2
+ : ring_operators2<T, U
+ , dividable2<T, U
+ , dividable2_left<T, U
+ , modable2<T, U
+ , modable2_left<T, U, B
+ > > > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct euclidean_ring_operators1
+ : ring_operators1<T
+ , dividable1<T
+ , modable1<T, B
+ > > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ordered_euclidean_ring_operators2
+ : totally_ordered2<T, U
+ , euclidean_ring_operators2<T, U, B
+ > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ordered_euclidean_ring_operators1
+ : totally_ordered1<T
+ , euclidean_ring_operators1<T, B
+ > > {};
+
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
+struct input_iteratable
+ : equality_comparable1<T
+ , incrementable<T
+ , dereferenceable<T, P, B
+ > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct output_iteratable
+ : incrementable<T, B
+ > {};
+
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
+struct forward_iteratable
+ : input_iteratable<T, P, B
+ > {};
+
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
+struct bidirectional_iteratable
+ : forward_iteratable<T, P
+ , decrementable<T, B
+ > > {};
+
+// To avoid repeated derivation from equality_comparable,
+// which is an indirect base class of bidirectional_iterable,
+// random_access_iteratable must not be derived from totally_ordered1
+// but from less_than_comparable1 only. (Helmut Zeisel, 02-Dec-2001)
+template <class T, class P, class D, class R, class B = ::boost::detail::empty_base<T> >
+struct random_access_iteratable
+ : bidirectional_iteratable<T, P
+ , less_than_comparable1<T
+ , additive2<T, D
+ , indexable<T, D, R, B
+ > > > > {};
+
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+} // namespace boost
+#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
+
+
+// BOOST_IMPORT_TEMPLATE1 .. BOOST_IMPORT_TEMPLATE4 -
+//
+// When BOOST_NO_OPERATORS_IN_NAMESPACE is defined we need a way to import an
+// operator template into the boost namespace. BOOST_IMPORT_TEMPLATE1 is used
+// for one-argument forms of operator templates; BOOST_IMPORT_TEMPLATE2 for
+// two-argument forms. Note that these macros expect to be invoked from within
+// boost.
+
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+
+ // The template is already in boost so we have nothing to do.
+# define BOOST_IMPORT_TEMPLATE4(template_name)
+# define BOOST_IMPORT_TEMPLATE3(template_name)
+# define BOOST_IMPORT_TEMPLATE2(template_name)
+# define BOOST_IMPORT_TEMPLATE1(template_name)
+
+#else // BOOST_NO_OPERATORS_IN_NAMESPACE
+
+# ifndef BOOST_NO_USING_TEMPLATE
+
+ // Bring the names in with a using-declaration
+ // to avoid stressing the compiler.
+# define BOOST_IMPORT_TEMPLATE4(template_name) using ::template_name;
+# define BOOST_IMPORT_TEMPLATE3(template_name) using ::template_name;
+# define BOOST_IMPORT_TEMPLATE2(template_name) using ::template_name;
+# define BOOST_IMPORT_TEMPLATE1(template_name) using ::template_name;
+
+# else
+
+ // Otherwise, because a Borland C++ 5.5 bug prevents a using declaration
+ // from working, we are forced to use inheritance for that compiler.
+# define BOOST_IMPORT_TEMPLATE4(template_name) \
+ template <class T, class U, class V, class W, class B = ::boost::detail::empty_base<T> > \
+ struct template_name : ::template_name<T, U, V, W, B> {};
+
+# define BOOST_IMPORT_TEMPLATE3(template_name) \
+ template <class T, class U, class V, class B = ::boost::detail::empty_base<T> > \
+ struct template_name : ::template_name<T, U, V, B> {};
+
+# define BOOST_IMPORT_TEMPLATE2(template_name) \
+ template <class T, class U, class B = ::boost::detail::empty_base<T> > \
+ struct template_name : ::template_name<T, U, B> {};
+
+# define BOOST_IMPORT_TEMPLATE1(template_name) \
+ template <class T, class B = ::boost::detail::empty_base<T> > \
+ struct template_name : ::template_name<T, B> {};
+
+# endif // BOOST_NO_USING_TEMPLATE
+
+#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
+
+//
+// Here's where we put it all together, defining the xxxx forms of the templates
+// in namespace boost. We also define specializations of is_chained_base<> for
+// the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as
+// necessary.
+//
+
+// is_chained_base<> - a traits class used to distinguish whether an operator
+// template argument is being used for base class chaining, or is specifying a
+// 2nd argument type.
+
+namespace boost {
+// A type parameter is used instead of a plain bool because Borland's compiler
+// didn't cope well with the more obvious non-type template parameter.
+namespace detail {
+ struct true_t {};
+ struct false_t {};
+} // namespace detail
+
+// Unspecialized version assumes that most types are not being used for base
+// class chaining. We specialize for the operator templates defined in this
+// library.
+template<class T> struct is_chained_base {
+ typedef ::boost::detail::false_t value;
+};
+
+} // namespace boost
+
+// Import a 4-type-argument operator template into boost (if necessary) and
+// provide a specialization of 'is_chained_base<>' for it.
+# define BOOST_OPERATOR_TEMPLATE4(template_name4) \
+ BOOST_IMPORT_TEMPLATE4(template_name4) \
+ template<class T, class U, class V, class W, class B> \
+ struct is_chained_base< ::boost::template_name4<T, U, V, W, B> > { \
+ typedef ::boost::detail::true_t value; \
+ };
+
+// Import a 3-type-argument operator template into boost (if necessary) and
+// provide a specialization of 'is_chained_base<>' for it.
+# define BOOST_OPERATOR_TEMPLATE3(template_name3) \
+ BOOST_IMPORT_TEMPLATE3(template_name3) \
+ template<class T, class U, class V, class B> \
+ struct is_chained_base< ::boost::template_name3<T, U, V, B> > { \
+ typedef ::boost::detail::true_t value; \
+ };
+
+// Import a 2-type-argument operator template into boost (if necessary) and
+// provide a specialization of 'is_chained_base<>' for it.
+# define BOOST_OPERATOR_TEMPLATE2(template_name2) \
+ BOOST_IMPORT_TEMPLATE2(template_name2) \
+ template<class T, class U, class B> \
+ struct is_chained_base< ::boost::template_name2<T, U, B> > { \
+ typedef ::boost::detail::true_t value; \
+ };
+
+// Import a 1-type-argument operator template into boost (if necessary) and
+// provide a specialization of 'is_chained_base<>' for it.
+# define BOOST_OPERATOR_TEMPLATE1(template_name1) \
+ BOOST_IMPORT_TEMPLATE1(template_name1) \
+ template<class T, class B> \
+ struct is_chained_base< ::boost::template_name1<T, B> > { \
+ typedef ::boost::detail::true_t value; \
+ };
+
+// BOOST_OPERATOR_TEMPLATE(template_name) defines template_name<> such that it
+// can be used for specifying both 1-argument and 2-argument forms. Requires the
+// existence of two previously defined class templates named '<template_name>1'
+// and '<template_name>2' which must implement the corresponding 1- and 2-
+// argument forms.
+//
+// The template type parameter O == is_chained_base<U>::value is used to
+// distinguish whether the 2nd argument to <template_name> is being used for
+// base class chaining from another boost operator template or is describing a
+// 2nd operand type. O == true_t only when U is actually an another operator
+// template from the library. Partial specialization is used to select an
+// implementation in terms of either '<template_name>1' or '<template_name>2'.
+//
+
+# define BOOST_OPERATOR_TEMPLATE(template_name) \
+template <class T \
+ ,class U = T \
+ ,class B = ::boost::detail::empty_base<T> \
+ ,class O = typename is_chained_base<U>::value \
+ > \
+struct template_name : template_name##2<T, U, B> {}; \
+ \
+template<class T, class U, class B> \
+struct template_name<T, U, B, ::boost::detail::true_t> \
+ : template_name##1<T, U> {}; \
+ \
+template <class T, class B> \
+struct template_name<T, T, B, ::boost::detail::false_t> \
+ : template_name##1<T, B> {}; \
+ \
+template<class T, class U, class B, class O> \
+struct is_chained_base< ::boost::template_name<T, U, B, O> > { \
+ typedef ::boost::detail::true_t value; \
+}; \
+ \
+BOOST_OPERATOR_TEMPLATE2(template_name##2) \
+BOOST_OPERATOR_TEMPLATE1(template_name##1)
+
+
+
+namespace boost {
+
+BOOST_OPERATOR_TEMPLATE(less_than_comparable)
+BOOST_OPERATOR_TEMPLATE(equality_comparable)
+BOOST_OPERATOR_TEMPLATE(multipliable)
+BOOST_OPERATOR_TEMPLATE(addable)
+BOOST_OPERATOR_TEMPLATE(subtractable)
+BOOST_OPERATOR_TEMPLATE2(subtractable2_left)
+BOOST_OPERATOR_TEMPLATE(dividable)
+BOOST_OPERATOR_TEMPLATE2(dividable2_left)
+BOOST_OPERATOR_TEMPLATE(modable)
+BOOST_OPERATOR_TEMPLATE2(modable2_left)
+BOOST_OPERATOR_TEMPLATE(xorable)
+BOOST_OPERATOR_TEMPLATE(andable)
+BOOST_OPERATOR_TEMPLATE(orable)
+
+BOOST_OPERATOR_TEMPLATE1(incrementable)
+BOOST_OPERATOR_TEMPLATE1(decrementable)
+
+BOOST_OPERATOR_TEMPLATE2(dereferenceable)
+BOOST_OPERATOR_TEMPLATE3(indexable)
+
+BOOST_OPERATOR_TEMPLATE(left_shiftable)
+BOOST_OPERATOR_TEMPLATE(right_shiftable)
+BOOST_OPERATOR_TEMPLATE(equivalent)
+BOOST_OPERATOR_TEMPLATE(partially_ordered)
+
+BOOST_OPERATOR_TEMPLATE(totally_ordered)
+BOOST_OPERATOR_TEMPLATE(additive)
+BOOST_OPERATOR_TEMPLATE(multiplicative)
+BOOST_OPERATOR_TEMPLATE(integer_multiplicative)
+BOOST_OPERATOR_TEMPLATE(arithmetic)
+BOOST_OPERATOR_TEMPLATE(integer_arithmetic)
+BOOST_OPERATOR_TEMPLATE(bitwise)
+BOOST_OPERATOR_TEMPLATE1(unit_steppable)
+BOOST_OPERATOR_TEMPLATE(shiftable)
+BOOST_OPERATOR_TEMPLATE(ring_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_ring_operators)
+BOOST_OPERATOR_TEMPLATE(field_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_field_operators)
+BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators)
+BOOST_OPERATOR_TEMPLATE(euclidean_ring_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_euclidean_ring_operators)
+BOOST_OPERATOR_TEMPLATE2(input_iteratable)
+BOOST_OPERATOR_TEMPLATE1(output_iteratable)
+BOOST_OPERATOR_TEMPLATE2(forward_iteratable)
+BOOST_OPERATOR_TEMPLATE2(bidirectional_iteratable)
+BOOST_OPERATOR_TEMPLATE4(random_access_iteratable)
+
+#undef BOOST_OPERATOR_TEMPLATE
+#undef BOOST_OPERATOR_TEMPLATE4
+#undef BOOST_OPERATOR_TEMPLATE3
+#undef BOOST_OPERATOR_TEMPLATE2
+#undef BOOST_OPERATOR_TEMPLATE1
+#undef BOOST_IMPORT_TEMPLATE1
+#undef BOOST_IMPORT_TEMPLATE2
+#undef BOOST_IMPORT_TEMPLATE3
+#undef BOOST_IMPORT_TEMPLATE4
+
+// The following 'operators' classes can only be used portably if the derived class
+// declares ALL of the required member operators.
+template <class T, class U>
+struct operators2
+ : totally_ordered2<T,U
+ , integer_arithmetic2<T,U
+ , bitwise2<T,U
+ > > > {};
+
+template <class T, class U = T>
+struct operators : operators2<T, U> {};
+
+template <class T> struct operators<T, T>
+ : totally_ordered<T
+ , integer_arithmetic<T
+ , bitwise<T
+ , unit_steppable<T
+ > > > > {};
+
+// Iterator helper classes (contributed by Jeremy Siek) -------------------//
+// (Input and output iterator helpers contributed by Daryle Walker) -------//
+// (Changed to use combined operator classes by Daryle Walker) ------------//
+template <class T,
+ class V,
+ class D = std::ptrdiff_t,
+ class P = V const *,
+ class R = V const &>
+struct input_iterator_helper
+ : input_iteratable<T, P
+ , std::iterator<std::input_iterator_tag, V, D, P, R
+ > > {};
+
+template<class T>
+struct output_iterator_helper
+ : output_iteratable<T
+ , std::iterator<std::output_iterator_tag, void, void, void, void
+ > >
+{
+ T& operator*() { return static_cast<T&>(*this); }
+ T& operator++() { return static_cast<T&>(*this); }
+};
+
+template <class T,
+ class V,
+ class D = std::ptrdiff_t,
+ class P = V*,
+ class R = V&>
+struct forward_iterator_helper
+ : forward_iteratable<T, P
+ , std::iterator<std::forward_iterator_tag, V, D, P, R
+ > > {};
+
+template <class T,
+ class V,
+ class D = std::ptrdiff_t,
+ class P = V*,
+ class R = V&>
+struct bidirectional_iterator_helper
+ : bidirectional_iteratable<T, P
+ , std::iterator<std::bidirectional_iterator_tag, V, D, P, R
+ > > {};
+
+template <class T,
+ class V,
+ class D = std::ptrdiff_t,
+ class P = V*,
+ class R = V&>
+struct random_access_iterator_helper
+ : random_access_iteratable<T, P, D, R
+ , std::iterator<std::random_access_iterator_tag, V, D, P, R
+ > >
+{
+ friend D requires_difference_operator(const T& x, const T& y) {
+ return x - y;
+ }
+}; // random_access_iterator_helper
+
+} // namespace boost
+
+#if defined(__sgi) && !defined(__GNUC__)
+#pragma reset woff 1234
+#endif
+
+#endif // BOOST_OPERATORS_V1_HPP
diff --git a/include/boost/utility.hpp b/include/boost/utility.hpp
new file mode 100644
index 0000000..5ac9ecb
--- /dev/null
+++ b/include/boost/utility.hpp
@@ -0,0 +1,24 @@
+// Boost utility.hpp header file -------------------------------------------//
+
+// Copyright 1999-2003 Aleksey Gurtovoy. Use, modification, and distribution are
+// subject to the Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+// See <http://www.boost.org/libs/utility/> for the library's home page.
+
+#ifndef BOOST_UTILITY_HPP
+#define BOOST_UTILITY_HPP
+
+// Use of this header is discouraged and it will be deprecated.
+// Please include one or more of the headers below instead.
+
+#include <boost/utility/base_from_member.hpp>
+#include <boost/utility/binary.hpp>
+#include <boost/utility/identity_type.hpp>
+
+#include <boost/core/addressof.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/core/checked_delete.hpp>
+#include <boost/core/noncopyable.hpp>
+
+#endif // BOOST_UTILITY_HPP
diff --git a/include/boost/utility/base_from_member.hpp b/include/boost/utility/base_from_member.hpp
new file mode 100644
index 0000000..604541d
--- /dev/null
+++ b/include/boost/utility/base_from_member.hpp
@@ -0,0 +1,172 @@
+// boost utility/base_from_member.hpp header file --------------------------//
+
+// Copyright 2001, 2003, 2004, 2012 Daryle Walker. Use, modification, and
+// distribution are subject to the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or a copy at
+// <http://www.boost.org/LICENSE_1_0.txt>.)
+
+// See <http://www.boost.org/libs/utility/> for the library's home page.
+
+#ifndef BOOST_UTILITY_BASE_FROM_MEMBER_HPP
+#define BOOST_UTILITY_BASE_FROM_MEMBER_HPP
+
+#include <boost/config.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/utility/enable_if.hpp>
+
+
+// Base-from-member arity configuration macro ------------------------------//
+
+// The following macro determines how many arguments will be in the largest
+// constructor template of base_from_member. Constructor templates will be
+// generated from one argument to this maximum. Code from other files can read
+// this number if they need to always match the exact maximum base_from_member
+// uses. The maximum constructor length can be changed by overriding the
+// #defined constant. Make sure to apply the override, if any, for all source
+// files during project compiling for consistency.
+
+// Contributed by Jonathan Turkanis
+
+#ifndef BOOST_BASE_FROM_MEMBER_MAX_ARITY
+#define BOOST_BASE_FROM_MEMBER_MAX_ARITY 10
+#endif
+
+
+// An iteration of a constructor template for base_from_member -------------//
+
+// A macro that should expand to:
+// template < typename T1, ..., typename Tn >
+// base_from_member( T1 x1, ..., Tn xn )
+// : member( x1, ..., xn )
+// {}
+// This macro should only persist within this file.
+
+#define BOOST_PRIVATE_CTR_DEF( z, n, data ) \
+ template < BOOST_PP_ENUM_PARAMS(n, typename T) > \
+ base_from_member( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) ) \
+ : member( BOOST_PP_ENUM_PARAMS(n, x) ) \
+ {} \
+ /**/
+
+
+namespace boost
+{
+
+namespace detail
+{
+
+// Type-unmarking class template -------------------------------------------//
+
+// Type-trait to get the raw type, i.e. the type without top-level reference nor
+// cv-qualification, from a type expression. Mainly for function arguments, any
+// reference part is stripped first.
+
+// Contributed by Daryle Walker
+
+template < typename T >
+struct remove_cv_ref
+{
+ typedef typename ::boost::remove_cv<typename
+ ::boost::remove_reference<T>::type>::type type;
+
+}; // boost::detail::remove_cv_ref
+
+// Unmarked-type comparison class template ---------------------------------//
+
+// Type-trait to check if two type expressions have the same raw type.
+
+// Contributed by Daryle Walker, based on a work-around by Luc Danton
+
+template < typename T, typename U >
+struct is_related
+ : public ::boost::is_same<
+ typename ::boost::detail::remove_cv_ref<T>::type,
+ typename ::boost::detail::remove_cv_ref<U>::type >
+{};
+
+// Enable-if-on-unidentical-unmarked-type class template -------------------//
+
+// Enable-if on the first two type expressions NOT having the same raw type.
+
+// Contributed by Daryle Walker, based on a work-around by Luc Danton
+
+#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+template<typename ...T>
+struct enable_if_unrelated
+ : public ::boost::enable_if_c<true>
+{};
+
+template<typename T, typename U, typename ...U2>
+struct enable_if_unrelated<T, U, U2...>
+ : public ::boost::disable_if< ::boost::detail::is_related<T, U> >
+{};
+#endif
+
+} // namespace boost::detail
+
+
+// Base-from-member class template -----------------------------------------//
+
+// Helper to initialize a base object so a derived class can use this
+// object in the initialization of another base class. Used by
+// Dietmar Kuehl from ideas by Ron Klatcho to solve the problem of a
+// base class needing to be initialized by a member.
+
+// Contributed by Daryle Walker
+
+template < typename MemberType, int UniqueID = 0 >
+class base_from_member
+{
+protected:
+ MemberType member;
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
+ !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
+ !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && \
+ !(defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 4))
+ template <typename ...T, typename EnableIf = typename
+ ::boost::detail::enable_if_unrelated<base_from_member, T...>::type>
+ explicit BOOST_CONSTEXPR base_from_member( T&& ...x )
+ BOOST_NOEXCEPT_IF( BOOST_NOEXCEPT_EXPR(::new ((void*) 0) MemberType(
+ static_cast<T&&>(x)... )) ) // no std::is_nothrow_constructible...
+ : member( static_cast<T&&>(x)... ) // ...nor std::forward needed
+ {}
+#else
+ base_from_member()
+ : member()
+ {}
+
+ template < typename T0 > explicit base_from_member( T0 x0 ) : member( x0 ) {}
+ BOOST_PP_REPEAT_FROM_TO( 2, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY),
+ BOOST_PRIVATE_CTR_DEF, _ )
+#endif
+
+}; // boost::base_from_member
+
+template < typename MemberType, int UniqueID >
+class base_from_member<MemberType&, UniqueID>
+{
+protected:
+ MemberType& member;
+
+ explicit BOOST_CONSTEXPR base_from_member( MemberType& x )
+ BOOST_NOEXCEPT
+ : member( x )
+ {}
+
+}; // boost::base_from_member
+
+} // namespace boost
+
+
+// Undo any private macros
+#undef BOOST_PRIVATE_CTR_DEF
+
+
+#endif // BOOST_UTILITY_BASE_FROM_MEMBER_HPP
diff --git a/include/boost/utility/binary.hpp b/include/boost/utility/binary.hpp
new file mode 100644
index 0000000..8cef146
--- /dev/null
+++ b/include/boost/utility/binary.hpp
@@ -0,0 +1,708 @@
+/*=============================================================================
+ Copyright (c) 2005 Matthew Calabrese
+
+ Use, modification and distribution is subject to 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)
+==============================================================================*/
+
+#ifndef BOOST_UTILITY_BINARY_HPP
+#define BOOST_UTILITY_BINARY_HPP
+
+/*=============================================================================
+
+ Binary Literal Utility
+ ______________________
+
+
+ The following code works by converting the input bit pattern into a
+ Boost.Preprocessor sequence, then converting groupings of 3 bits each into
+ the corresponding octal digit, and finally concatenating all of the digits
+ together along with a leading zero. This yields a standard octal literal
+ with the desired value as specified in bits.
+
+==============================================================================*/
+
+#include <boost/preprocessor/control/deduce_d.hpp>
+#include <boost/preprocessor/facilities/identity.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/seq/cat.hpp>
+#include <boost/preprocessor/seq/transform.hpp>
+#include <boost/preprocessor/arithmetic/mod.hpp>
+#include <boost/preprocessor/seq/size.hpp>
+#include <boost/preprocessor/facilities/empty.hpp>
+#include <boost/preprocessor/control/while.hpp>
+
+#define BOOST_BINARY( bit_groupings ) \
+ BOOST_BINARY_LITERAL_D( BOOST_PP_DEDUCE_D(), bit_groupings )
+
+#define BOOST_BINARY_U( bit_groupings ) \
+ BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, U )
+
+#define BOOST_BINARY_L( bit_groupings ) \
+ BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, L )
+
+#define BOOST_BINARY_UL( bit_groupings ) \
+ BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, UL )
+
+#define BOOST_BINARY_LU( bit_groupings ) \
+ BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LU )
+
+#define BOOST_BINARY_LL( bit_groupings ) \
+ BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LL )
+
+#define BOOST_BINARY_ULL( bit_groupings ) \
+ BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, ULL )
+
+#define BOOST_BINARY_LLU( bit_groupings ) \
+ BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LLU )
+
+#define BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, suffix ) \
+ BOOST_SUFFIXED_BINARY_LITERAL_D( BOOST_PP_DEDUCE_D(), bit_groupings, suffix )
+
+#define BOOST_SUFFIXED_BINARY_LITERAL_D( d, bit_groupings, suffix ) \
+ BOOST_PP_CAT( BOOST_BINARY_LITERAL_D( d, bit_groupings ), suffix )
+
+#define BOOST_BINARY_LITERAL_D( d, bit_groupings ) \
+ BOOST_PP_SEQ_CAT \
+ ( (0) BOOST_DETAIL_CREATE_BINARY_LITERAL_OCTAL_SEQUENCE( d, bit_groupings ) \
+ )
+
+#define BOOST_DETAIL_CREATE_BINARY_LITERAL_OCTAL_SEQUENCE( d, bit_groupings ) \
+ BOOST_PP_SEQ_TRANSFORM \
+ ( BOOST_DETAIL_TRIPLE_TO_OCTAL_OPERATION \
+ , BOOST_PP_NIL \
+ , BOOST_PP_IDENTITY( BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_TRIPLE_SEQUENCE )()\
+ ( BOOST_DETAIL_COMPLETE_TRIPLE_SEQUENCE \
+ ( \
+ d \
+ , BOOST_DETAIL_CREATE_BINARY_LITERAL_BIT_SEQUENCE( d, bit_groupings ) \
+ ) \
+ ) \
+ )
+
+#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_TRIPLE_SEQUENCE( bit_sequence ) \
+ BOOST_PP_CAT \
+ ( BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1 bit_sequence \
+ , END_BIT \
+ )
+
+#define BOOST_DETAIL_BITS_PER_OCTIT 3
+
+#define BOOST_DETAIL_COMPLETE_TRIPLE_SEQUENCE( d, incomplete_nibble_sequence ) \
+ BOOST_PP_CAT \
+ ( BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_ \
+ , BOOST_PP_MOD_D( d \
+ , BOOST_PP_SEQ_SIZE( incomplete_nibble_sequence ) \
+ , BOOST_DETAIL_BITS_PER_OCTIT \
+ ) \
+ ) \
+ incomplete_nibble_sequence
+
+#define BOOST_DETAIL_FIXED_COMPL( bit ) \
+ BOOST_PP_CAT( BOOST_DETAIL_FIXED_COMPL_, bit )
+
+#define BOOST_DETAIL_FIXED_COMPL_0 1
+
+#define BOOST_DETAIL_FIXED_COMPL_1 0
+
+#define BOOST_DETAIL_CREATE_BINARY_LITERAL_BIT_SEQUENCE( d, bit_groupings ) \
+ BOOST_PP_EMPTY \
+ BOOST_PP_CAT( BOOST_PP_WHILE_, d ) \
+ ( BOOST_DETAIL_BINARY_LITERAL_PREDICATE \
+ , BOOST_DETAIL_BINARY_LITERAL_OPERATION \
+ , bit_groupings () \
+ )
+
+#define BOOST_DETAIL_BINARY_LITERAL_PREDICATE( d, state ) \
+ BOOST_DETAIL_FIXED_COMPL( BOOST_DETAIL_IS_NULLARY_ARGS( state ) )
+
+#define BOOST_DETAIL_BINARY_LITERAL_OPERATION( d, state ) \
+ BOOST_DETAIL_SPLIT_AND_SWAP \
+ ( BOOST_PP_CAT( BOOST_DETAIL_BINARY_LITERAL_ELEMENT_, state ) )
+
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_OPERATION( s, dummy_param, tuple ) \
+ BOOST_DETAIL_TERNARY_TRIPLE_TO_OCTAL tuple
+
+#define BOOST_DETAIL_TERNARY_TRIPLE_TO_OCTAL( bit2, bit1, bit0 ) \
+ BOOST_DETAIL_TRIPLE_TO_OCTAL_ ## bit2 ## bit1 ## bit0
+
+#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_1 (0)(0)
+#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_2 (0)
+#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_0
+
+#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1END_BIT
+
+#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1( bit ) \
+ ( ( bit, BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_2
+
+#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_2( bit ) \
+ bit, BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_3
+
+#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_3( bit ) \
+ bit ) ) BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1
+
+#define BOOST_DETAIL_SPLIT_AND_SWAP( params ) \
+ BOOST_PP_IDENTITY( BOOST_DETAIL_SPLIT_AND_SWAP_PARAMS )()( params )
+
+#define BOOST_DETAIL_SPLIT_AND_SWAP_PARAMS( first_param, second_param ) \
+ second_param first_param
+
+#define BOOST_DETAIL_LEFT_OF_COMMA( params ) \
+ BOOST_PP_IDENTITY( BOOST_DETAIL_FIRST_MACRO_PARAM )()( params )
+
+#define BOOST_DETAIL_FIRST_MACRO_PARAM( first_param, second_param ) \
+ first_param
+
+/* Begin derived concepts from Chaos by Paul Mensonides */
+
+#define BOOST_DETAIL_IS_NULLARY_ARGS( param ) \
+ BOOST_DETAIL_LEFT_OF_COMMA \
+ ( BOOST_PP_CAT( BOOST_DETAIL_IS_NULLARY_ARGS_R_ \
+ , BOOST_DETAIL_IS_NULLARY_ARGS_C param \
+ ) \
+ )
+
+#define BOOST_DETAIL_IS_NULLARY_ARGS_C() \
+ 1
+
+#define BOOST_DETAIL_IS_NULLARY_ARGS_R_1 \
+ 1, BOOST_PP_NIL
+
+#define BOOST_DETAIL_IS_NULLARY_ARGS_R_BOOST_DETAIL_IS_NULLARY_ARGS_C \
+ 0, BOOST_PP_NIL
+
+/* End derived concepts from Chaos by Paul Mensonides */
+
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_000 0
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_001 1
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_010 2
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_011 3
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_100 4
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_101 5
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_110 6
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_111 7
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0 (0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1 (1),
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00 (0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01 (0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10 (1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11 (1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00 (0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01 (0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10 (1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11 (1)(1),
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000 (0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001 (0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010 (0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011 (0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100 (1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101 (1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110 (1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111 (1)(1)(1),
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000 (0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001 (0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010 (0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011 (0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100 (0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101 (0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110 (0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111 (0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000 (1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001 (1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010 (1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011 (1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100 (1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101 (1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110 (1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111 (1)(1)(1)(1),
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000 (0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001 (0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010 (0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011 (0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100 (0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101 (0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110 (0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111 (0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000 (0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001 (0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010 (0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011 (0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100 (0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101 (0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110 (0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111 (0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000 (1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001 (1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010 (1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011 (1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100 (1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101 (1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110 (1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111 (1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000 (1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001 (1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010 (1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011 (1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100 (1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101 (1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110 (1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111 (1)(1)(1)(1)(1),
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000000 (0)(0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000001 (0)(0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000010 (0)(0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000011 (0)(0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000100 (0)(0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000101 (0)(0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000110 (0)(0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000111 (0)(0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001000 (0)(0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001001 (0)(0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001010 (0)(0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001011 (0)(0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001100 (0)(0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001101 (0)(0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001110 (0)(0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001111 (0)(0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010000 (0)(1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010001 (0)(1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010010 (0)(1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010011 (0)(1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010100 (0)(1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010101 (0)(1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010110 (0)(1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010111 (0)(1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011000 (0)(1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011001 (0)(1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011010 (0)(1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011011 (0)(1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011100 (0)(1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011101 (0)(1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011110 (0)(1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011111 (0)(1)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100000 (1)(0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100001 (1)(0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100010 (1)(0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100011 (1)(0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100100 (1)(0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100101 (1)(0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100110 (1)(0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100111 (1)(0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101000 (1)(0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101001 (1)(0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101010 (1)(0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101011 (1)(0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101100 (1)(0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101101 (1)(0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101110 (1)(0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101111 (1)(0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110000 (1)(1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110001 (1)(1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110010 (1)(1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110011 (1)(1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110100 (1)(1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110101 (1)(1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110110 (1)(1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110111 (1)(1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111000 (1)(1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111001 (1)(1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111010 (1)(1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111011 (1)(1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111100 (1)(1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111101 (1)(1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111110 (1)(1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111111 (1)(1)(1)(1)(1)(1),
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000000 (0)(0)(0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000001 (0)(0)(0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000010 (0)(0)(0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000011 (0)(0)(0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000100 (0)(0)(0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000101 (0)(0)(0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000110 (0)(0)(0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000111 (0)(0)(0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001000 (0)(0)(0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001001 (0)(0)(0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001010 (0)(0)(0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001011 (0)(0)(0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001100 (0)(0)(0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001101 (0)(0)(0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001110 (0)(0)(0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001111 (0)(0)(0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010000 (0)(0)(1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010001 (0)(0)(1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010010 (0)(0)(1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010011 (0)(0)(1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010100 (0)(0)(1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010101 (0)(0)(1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010110 (0)(0)(1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010111 (0)(0)(1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011000 (0)(0)(1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011001 (0)(0)(1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011010 (0)(0)(1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011011 (0)(0)(1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011100 (0)(0)(1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011101 (0)(0)(1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011110 (0)(0)(1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011111 (0)(0)(1)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100000 (0)(1)(0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100001 (0)(1)(0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100010 (0)(1)(0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100011 (0)(1)(0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100100 (0)(1)(0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100101 (0)(1)(0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100110 (0)(1)(0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100111 (0)(1)(0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101000 (0)(1)(0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101001 (0)(1)(0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101010 (0)(1)(0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101011 (0)(1)(0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101100 (0)(1)(0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101101 (0)(1)(0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101110 (0)(1)(0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101111 (0)(1)(0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110000 (0)(1)(1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110001 (0)(1)(1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110010 (0)(1)(1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110011 (0)(1)(1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110100 (0)(1)(1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110101 (0)(1)(1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110110 (0)(1)(1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110111 (0)(1)(1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111000 (0)(1)(1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111001 (0)(1)(1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111010 (0)(1)(1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111011 (0)(1)(1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111100 (0)(1)(1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111101 (0)(1)(1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111110 (0)(1)(1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111111 (0)(1)(1)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000000 (1)(0)(0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000001 (1)(0)(0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000010 (1)(0)(0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000011 (1)(0)(0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000100 (1)(0)(0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000101 (1)(0)(0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000110 (1)(0)(0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000111 (1)(0)(0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001000 (1)(0)(0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001001 (1)(0)(0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001010 (1)(0)(0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001011 (1)(0)(0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001100 (1)(0)(0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001101 (1)(0)(0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001110 (1)(0)(0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001111 (1)(0)(0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010000 (1)(0)(1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010001 (1)(0)(1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010010 (1)(0)(1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010011 (1)(0)(1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010100 (1)(0)(1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010101 (1)(0)(1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010110 (1)(0)(1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010111 (1)(0)(1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011000 (1)(0)(1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011001 (1)(0)(1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011010 (1)(0)(1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011011 (1)(0)(1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011100 (1)(0)(1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011101 (1)(0)(1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011110 (1)(0)(1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011111 (1)(0)(1)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100000 (1)(1)(0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100001 (1)(1)(0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100010 (1)(1)(0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100011 (1)(1)(0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100100 (1)(1)(0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100101 (1)(1)(0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100110 (1)(1)(0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100111 (1)(1)(0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101000 (1)(1)(0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101001 (1)(1)(0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101010 (1)(1)(0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101011 (1)(1)(0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101100 (1)(1)(0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101101 (1)(1)(0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101110 (1)(1)(0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101111 (1)(1)(0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110000 (1)(1)(1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110001 (1)(1)(1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110010 (1)(1)(1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110011 (1)(1)(1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110100 (1)(1)(1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110101 (1)(1)(1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110110 (1)(1)(1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110111 (1)(1)(1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111000 (1)(1)(1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111001 (1)(1)(1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111010 (1)(1)(1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111011 (1)(1)(1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111100 (1)(1)(1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111101 (1)(1)(1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111110 (1)(1)(1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111111 (1)(1)(1)(1)(1)(1)(1),
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000000 (0)(0)(0)(0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000001 (0)(0)(0)(0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000010 (0)(0)(0)(0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000011 (0)(0)(0)(0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000100 (0)(0)(0)(0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000101 (0)(0)(0)(0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000110 (0)(0)(0)(0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000111 (0)(0)(0)(0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001000 (0)(0)(0)(0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001001 (0)(0)(0)(0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001010 (0)(0)(0)(0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001011 (0)(0)(0)(0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001100 (0)(0)(0)(0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001101 (0)(0)(0)(0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001110 (0)(0)(0)(0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001111 (0)(0)(0)(0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010000 (0)(0)(0)(1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010001 (0)(0)(0)(1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010010 (0)(0)(0)(1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010011 (0)(0)(0)(1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010100 (0)(0)(0)(1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010101 (0)(0)(0)(1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010110 (0)(0)(0)(1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010111 (0)(0)(0)(1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011000 (0)(0)(0)(1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011001 (0)(0)(0)(1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011010 (0)(0)(0)(1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011011 (0)(0)(0)(1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011100 (0)(0)(0)(1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011101 (0)(0)(0)(1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011110 (0)(0)(0)(1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011111 (0)(0)(0)(1)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100000 (0)(0)(1)(0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100001 (0)(0)(1)(0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100010 (0)(0)(1)(0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100011 (0)(0)(1)(0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100100 (0)(0)(1)(0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100101 (0)(0)(1)(0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100110 (0)(0)(1)(0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100111 (0)(0)(1)(0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101000 (0)(0)(1)(0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101001 (0)(0)(1)(0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101010 (0)(0)(1)(0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101011 (0)(0)(1)(0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101100 (0)(0)(1)(0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101101 (0)(0)(1)(0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101110 (0)(0)(1)(0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101111 (0)(0)(1)(0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110000 (0)(0)(1)(1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110001 (0)(0)(1)(1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110010 (0)(0)(1)(1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110011 (0)(0)(1)(1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110100 (0)(0)(1)(1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110101 (0)(0)(1)(1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110110 (0)(0)(1)(1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110111 (0)(0)(1)(1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111000 (0)(0)(1)(1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111001 (0)(0)(1)(1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111010 (0)(0)(1)(1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111011 (0)(0)(1)(1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111100 (0)(0)(1)(1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111101 (0)(0)(1)(1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111110 (0)(0)(1)(1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111111 (0)(0)(1)(1)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000000 (0)(1)(0)(0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000001 (0)(1)(0)(0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000010 (0)(1)(0)(0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000011 (0)(1)(0)(0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000100 (0)(1)(0)(0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000101 (0)(1)(0)(0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000110 (0)(1)(0)(0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000111 (0)(1)(0)(0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001000 (0)(1)(0)(0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001001 (0)(1)(0)(0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001010 (0)(1)(0)(0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001011 (0)(1)(0)(0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001100 (0)(1)(0)(0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001101 (0)(1)(0)(0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001110 (0)(1)(0)(0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001111 (0)(1)(0)(0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010000 (0)(1)(0)(1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010001 (0)(1)(0)(1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010010 (0)(1)(0)(1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010011 (0)(1)(0)(1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010100 (0)(1)(0)(1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010101 (0)(1)(0)(1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010110 (0)(1)(0)(1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010111 (0)(1)(0)(1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011000 (0)(1)(0)(1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011001 (0)(1)(0)(1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011010 (0)(1)(0)(1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011011 (0)(1)(0)(1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011100 (0)(1)(0)(1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011101 (0)(1)(0)(1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011110 (0)(1)(0)(1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011111 (0)(1)(0)(1)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100000 (0)(1)(1)(0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100001 (0)(1)(1)(0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100010 (0)(1)(1)(0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100011 (0)(1)(1)(0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100100 (0)(1)(1)(0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100101 (0)(1)(1)(0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100110 (0)(1)(1)(0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100111 (0)(1)(1)(0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101000 (0)(1)(1)(0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101001 (0)(1)(1)(0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101010 (0)(1)(1)(0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101011 (0)(1)(1)(0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101100 (0)(1)(1)(0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101101 (0)(1)(1)(0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101110 (0)(1)(1)(0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101111 (0)(1)(1)(0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110000 (0)(1)(1)(1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110001 (0)(1)(1)(1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110010 (0)(1)(1)(1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110011 (0)(1)(1)(1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110100 (0)(1)(1)(1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110101 (0)(1)(1)(1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110110 (0)(1)(1)(1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110111 (0)(1)(1)(1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111000 (0)(1)(1)(1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111001 (0)(1)(1)(1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111010 (0)(1)(1)(1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111011 (0)(1)(1)(1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111100 (0)(1)(1)(1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111101 (0)(1)(1)(1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111110 (0)(1)(1)(1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111111 (0)(1)(1)(1)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000000 (1)(0)(0)(0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000001 (1)(0)(0)(0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000010 (1)(0)(0)(0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000011 (1)(0)(0)(0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000100 (1)(0)(0)(0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000101 (1)(0)(0)(0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000110 (1)(0)(0)(0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000111 (1)(0)(0)(0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001000 (1)(0)(0)(0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001001 (1)(0)(0)(0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001010 (1)(0)(0)(0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001011 (1)(0)(0)(0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001100 (1)(0)(0)(0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001101 (1)(0)(0)(0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001110 (1)(0)(0)(0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001111 (1)(0)(0)(0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010000 (1)(0)(0)(1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010001 (1)(0)(0)(1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010010 (1)(0)(0)(1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010011 (1)(0)(0)(1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010100 (1)(0)(0)(1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010101 (1)(0)(0)(1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010110 (1)(0)(0)(1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010111 (1)(0)(0)(1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011000 (1)(0)(0)(1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011001 (1)(0)(0)(1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011010 (1)(0)(0)(1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011011 (1)(0)(0)(1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011100 (1)(0)(0)(1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011101 (1)(0)(0)(1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011110 (1)(0)(0)(1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011111 (1)(0)(0)(1)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100000 (1)(0)(1)(0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100001 (1)(0)(1)(0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100010 (1)(0)(1)(0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100011 (1)(0)(1)(0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100100 (1)(0)(1)(0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100101 (1)(0)(1)(0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100110 (1)(0)(1)(0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100111 (1)(0)(1)(0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101000 (1)(0)(1)(0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101001 (1)(0)(1)(0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101010 (1)(0)(1)(0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101011 (1)(0)(1)(0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101100 (1)(0)(1)(0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101101 (1)(0)(1)(0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101110 (1)(0)(1)(0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101111 (1)(0)(1)(0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110000 (1)(0)(1)(1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110001 (1)(0)(1)(1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110010 (1)(0)(1)(1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110011 (1)(0)(1)(1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110100 (1)(0)(1)(1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110101 (1)(0)(1)(1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110110 (1)(0)(1)(1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110111 (1)(0)(1)(1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111000 (1)(0)(1)(1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111001 (1)(0)(1)(1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111010 (1)(0)(1)(1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111011 (1)(0)(1)(1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111100 (1)(0)(1)(1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111101 (1)(0)(1)(1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111110 (1)(0)(1)(1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111111 (1)(0)(1)(1)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000000 (1)(1)(0)(0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000001 (1)(1)(0)(0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000010 (1)(1)(0)(0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000011 (1)(1)(0)(0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000100 (1)(1)(0)(0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000101 (1)(1)(0)(0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000110 (1)(1)(0)(0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000111 (1)(1)(0)(0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001000 (1)(1)(0)(0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001001 (1)(1)(0)(0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001010 (1)(1)(0)(0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001011 (1)(1)(0)(0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001100 (1)(1)(0)(0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001101 (1)(1)(0)(0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001110 (1)(1)(0)(0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001111 (1)(1)(0)(0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010000 (1)(1)(0)(1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010001 (1)(1)(0)(1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010010 (1)(1)(0)(1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010011 (1)(1)(0)(1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010100 (1)(1)(0)(1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010101 (1)(1)(0)(1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010110 (1)(1)(0)(1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010111 (1)(1)(0)(1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011000 (1)(1)(0)(1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011001 (1)(1)(0)(1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011010 (1)(1)(0)(1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011011 (1)(1)(0)(1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011100 (1)(1)(0)(1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011101 (1)(1)(0)(1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011110 (1)(1)(0)(1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011111 (1)(1)(0)(1)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100000 (1)(1)(1)(0)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100001 (1)(1)(1)(0)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100010 (1)(1)(1)(0)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100011 (1)(1)(1)(0)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100100 (1)(1)(1)(0)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100101 (1)(1)(1)(0)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100110 (1)(1)(1)(0)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100111 (1)(1)(1)(0)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101000 (1)(1)(1)(0)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101001 (1)(1)(1)(0)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101010 (1)(1)(1)(0)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101011 (1)(1)(1)(0)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101100 (1)(1)(1)(0)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101101 (1)(1)(1)(0)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101110 (1)(1)(1)(0)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101111 (1)(1)(1)(0)(1)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110000 (1)(1)(1)(1)(0)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110001 (1)(1)(1)(1)(0)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110010 (1)(1)(1)(1)(0)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110011 (1)(1)(1)(1)(0)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110100 (1)(1)(1)(1)(0)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110101 (1)(1)(1)(1)(0)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110110 (1)(1)(1)(1)(0)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110111 (1)(1)(1)(1)(0)(1)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111000 (1)(1)(1)(1)(1)(0)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111001 (1)(1)(1)(1)(1)(0)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111010 (1)(1)(1)(1)(1)(0)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111011 (1)(1)(1)(1)(1)(0)(1)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111100 (1)(1)(1)(1)(1)(1)(0)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111101 (1)(1)(1)(1)(1)(1)(0)(1),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111110 (1)(1)(1)(1)(1)(1)(1)(0),
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111111 (1)(1)(1)(1)(1)(1)(1)(1),
+
+#endif
diff --git a/include/boost/utility/compare_pointees.hpp b/include/boost/utility/compare_pointees.hpp
new file mode 100644
index 0000000..5ab21cd
--- /dev/null
+++ b/include/boost/utility/compare_pointees.hpp
@@ -0,0 +1,76 @@
+// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+//
+// Use, modification, and distribution is subject to 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/optional for documentation.
+//
+// You are welcome to contact the author at:
+// fernando_cacciola@hotmail.com
+//
+#ifndef BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP
+#define BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP
+
+#include<functional>
+
+namespace boost {
+
+// template<class OP> bool equal_pointees(OP const& x, OP const& y);
+// template<class OP> struct equal_pointees_t;
+//
+// Being OP a model of OptionalPointee (either a pointer or an optional):
+//
+// If both x and y have valid pointees, returns the result of (*x == *y)
+// If only one has a valid pointee, returns false.
+// If none have valid pointees, returns true.
+// No-throw
+template<class OptionalPointee>
+inline
+bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
+{
+ return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ;
+}
+
+template<class OptionalPointee>
+struct equal_pointees_t
+{
+ typedef bool result_type;
+ typedef OptionalPointee first_argument_type;
+ typedef OptionalPointee second_argument_type;
+
+ bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
+ { return equal_pointees(x,y) ; }
+} ;
+
+// template<class OP> bool less_pointees(OP const& x, OP const& y);
+// template<class OP> struct less_pointees_t;
+//
+// Being OP a model of OptionalPointee (either a pointer or an optional):
+//
+// If y has not a valid pointee, returns false.
+// ElseIf x has not a valid pointee, returns true.
+// ElseIf both x and y have valid pointees, returns the result of (*x < *y)
+// No-throw
+template<class OptionalPointee>
+inline
+bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y )
+{
+ return !y ? false : ( !x ? true : (*x) < (*y) ) ;
+}
+
+template<class OptionalPointee>
+struct less_pointees_t
+{
+ typedef bool result_type;
+ typedef OptionalPointee first_argument_type;
+ typedef OptionalPointee second_argument_type;
+
+ bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
+ { return less_pointees(x,y) ; }
+} ;
+
+} // namespace boost
+
+#endif
+
diff --git a/include/boost/utility/detail/in_place_factory_prefix.hpp b/include/boost/utility/detail/in_place_factory_prefix.hpp
new file mode 100644
index 0000000..afd76b5
--- /dev/null
+++ b/include/boost/utility/detail/in_place_factory_prefix.hpp
@@ -0,0 +1,36 @@
+// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2007, Tobias Schwinger.
+//
+// Use, modification, and distribution is subject to 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/optional for documentation.
+//
+// You are welcome to contact the author at:
+// fernando_cacciola@hotmail.com
+//
+#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP
+#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP
+
+#include <new>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/punctuation/paren.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+
+#define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT(z,n,_) BOOST_PP_CAT(m_a,n) BOOST_PP_LPAREN() BOOST_PP_CAT(a,n) BOOST_PP_RPAREN()
+#define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL(z,n,_) BOOST_PP_CAT(A,n) const& BOOST_PP_CAT(m_a,n);
+
+#define BOOST_MAX_INPLACE_FACTORY_ARITY 10
+
+#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP
+
+#endif
+
diff --git a/include/boost/utility/detail/in_place_factory_suffix.hpp b/include/boost/utility/detail/in_place_factory_suffix.hpp
new file mode 100644
index 0000000..58f48c7
--- /dev/null
+++ b/include/boost/utility/detail/in_place_factory_suffix.hpp
@@ -0,0 +1,23 @@
+// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2007, Tobias Schwinger.
+//
+// Use, modification, and distribution is subject to 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/optional for documentation.
+//
+// You are welcome to contact the author at:
+// fernando_cacciola@hotmail.com
+//
+#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP
+#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP
+
+#undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT
+#undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL
+#undef BOOST_MAX_INPLACE_FACTORY_ARITY
+
+#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP
+
+#endif
+
diff --git a/include/boost/utility/detail/minstd_rand.hpp b/include/boost/utility/detail/minstd_rand.hpp
new file mode 100644
index 0000000..95efb21
--- /dev/null
+++ b/include/boost/utility/detail/minstd_rand.hpp
@@ -0,0 +1,58 @@
+#ifndef BOOST_UTILITY_DETAIL_MINSTD_RAND_HPP_INCLUDED
+#define BOOST_UTILITY_DETAIL_MINSTD_RAND_HPP_INCLUDED
+
+// Copyright 2017 Peter Dimov
+//
+// 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
+//
+// An implementation of minstd_rand that does not require
+// the Random library
+
+#include <boost/cstdint.hpp>
+
+namespace boost
+{
+namespace detail
+{
+
+class minstd_rand
+{
+private:
+
+ boost::uint_least32_t x_;
+
+ enum { a = 48271, m = 2147483647 };
+
+public:
+
+ minstd_rand(): x_( 1 )
+ {
+ }
+
+ explicit minstd_rand( boost::uint_least32_t x ): x_( x % m )
+ {
+ if( x_ == 0 )
+ {
+ x_ = 1;
+ }
+ }
+
+ boost::uint_least32_t operator()()
+ {
+ boost::uint_least64_t y = x_;
+
+ y = ( a * y ) % m;
+
+ x_ = static_cast<boost::uint_least32_t>( y );
+
+ return x_;
+ }
+};
+
+} // namespace detail
+} // namespace boost
+
+#endif // #ifndef BOOST_UTILITY_DETAIL_MINSTD_RAND_HPP_INCLUDED
diff --git a/include/boost/utility/detail/result_of_iterate.hpp b/include/boost/utility/detail/result_of_iterate.hpp
new file mode 100644
index 0000000..d653844
--- /dev/null
+++ b/include/boost/utility/detail/result_of_iterate.hpp
@@ -0,0 +1,218 @@
+// Boost result_of library
+
+// Copyright Douglas Gregor 2004. Use, modification and
+// distribution is subject to 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)
+
+// Copyright Daniel Walker, Eric Niebler, Michel Morin 2008-2012.
+// Use, modification and distribution is subject to 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/libs/utility
+#if !defined(BOOST_PP_IS_ITERATING)
+# error Boost result_of - do not include this file!
+#endif
+
+// CWPro8 requires an argument in a function type specialization
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3002)) && BOOST_PP_ITERATION() == 0
+# define BOOST_RESULT_OF_ARGS void
+#else
+# define BOOST_RESULT_OF_ARGS BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)
+#endif
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct tr1_result_of<F(BOOST_RESULT_OF_ARGS)>
+ : conditional<
+ is_pointer<F>::value || is_member_function_pointer<F>::value
+ , boost::detail::tr1_result_of_impl<
+ typename remove_cv<F>::type,
+ typename remove_cv<F>::type(BOOST_RESULT_OF_ARGS),
+ (boost::detail::result_of_has_result_type<F>::value)>
+ , boost::detail::tr1_result_of_impl<
+ F,
+ F(BOOST_RESULT_OF_ARGS),
+ (boost::detail::result_of_has_result_type<F>::value)> >::type { };
+#endif
+
+#ifdef BOOST_RESULT_OF_USE_DECLTYPE
+template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct result_of<F(BOOST_RESULT_OF_ARGS)>
+ : detail::cpp0x_result_of<F(BOOST_RESULT_OF_ARGS)> { };
+#endif // BOOST_RESULT_OF_USE_DECLTYPE
+
+#ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
+template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct result_of<F(BOOST_RESULT_OF_ARGS)>
+ : conditional<detail::result_of_has_result_type<F>::value || detail::result_of_has_result<F>::value,
+ tr1_result_of<F(BOOST_RESULT_OF_ARGS)>,
+ detail::cpp0x_result_of<F(BOOST_RESULT_OF_ARGS)> >::type { };
+#endif // BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
+
+#if defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
+
+namespace detail {
+
+template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct cpp0x_result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
+ : conditional<
+ is_member_function_pointer<F>::value
+ , detail::tr1_result_of_impl<
+ typename remove_cv<F>::type,
+ typename remove_cv<F>::type(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false
+ >
+ , detail::cpp0x_result_of_impl<
+ F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))
+ >
+ >::type
+{};
+
+#ifdef BOOST_NO_SFINAE_EXPR
+
+template<typename F>
+struct BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION());
+
+template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename T)>
+struct BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<R(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), T))> {
+ R operator()(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), T)) const;
+ typedef result_of_private_type const &(*pfn_t)(...);
+ operator pfn_t() const volatile;
+};
+
+template<typename F>
+struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())
+ : BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<F>
+{};
+
+template<typename F>
+struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<F *>
+ : BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<F>
+{};
+
+template<typename F>
+struct BOOST_PP_CAT(result_of_select_call_wrapper_type_, BOOST_PP_ITERATION())
+ : conditional<
+ is_class<typename remove_reference<F>::type>::value,
+ result_of_wrap_callable_class<F>,
+ type_identity<BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<typename remove_cv<typename remove_reference<F>::type>::type> >
+ >::type
+{};
+
+template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename T)>
+struct BOOST_PP_CAT(result_of_is_callable_, BOOST_PP_ITERATION()) {
+ typedef typename BOOST_PP_CAT(result_of_select_call_wrapper_type_, BOOST_PP_ITERATION())<F>::type wrapper_t;
+ static const bool value = (
+ sizeof(result_of_no_type) == sizeof(detail::result_of_is_private_type(
+ (boost::declval<wrapper_t>()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)), result_of_weird_type())
+ ))
+ );
+ typedef integral_constant<bool, value> type;
+};
+
+template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), true>
+ : lazy_enable_if<
+ BOOST_PP_CAT(result_of_is_callable_, BOOST_PP_ITERATION())<F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), T)>
+ , cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false>
+ >
+{};
+
+template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false>
+{
+ typedef decltype(
+ boost::declval<F>()(
+ BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)
+ )
+ ) type;
+};
+
+#else // BOOST_NO_SFINAE_EXPR
+
+template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)),
+ typename result_of_always_void<decltype(
+ boost::declval<F>()(
+ BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)
+ )
+ )>::type> {
+ typedef decltype(
+ boost::declval<F>()(
+ BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)
+ )
+ ) type;
+};
+
+#endif // BOOST_NO_SFINAE_EXPR
+
+} // namespace detail
+
+#else // defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct result_of<F(BOOST_RESULT_OF_ARGS)>
+ : tr1_result_of<F(BOOST_RESULT_OF_ARGS)> { };
+#endif
+
+#endif // defined(BOOST_RESULT_OF_USE_DECLTYPE)
+
+#undef BOOST_RESULT_OF_ARGS
+
+#if BOOST_PP_ITERATION() >= 1
+
+namespace detail {
+
+template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct tr1_result_of_impl<R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
+{
+ typedef R type;
+};
+
+template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct tr1_result_of_impl<R (&)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
+{
+ typedef R type;
+};
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct tr1_result_of_impl<R (T0::*)
+ (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T)),
+ FArgs, false>
+{
+ typedef R type;
+};
+
+template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct tr1_result_of_impl<R (T0::*)
+ (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
+ const,
+ FArgs, false>
+{
+ typedef R type;
+};
+
+template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct tr1_result_of_impl<R (T0::*)
+ (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
+ volatile,
+ FArgs, false>
+{
+ typedef R type;
+};
+
+template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct tr1_result_of_impl<R (T0::*)
+ (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
+ const volatile,
+ FArgs, false>
+{
+ typedef R type;
+};
+#endif
+
+}
+#endif
diff --git a/include/boost/utility/identity_type.hpp b/include/boost/utility/identity_type.hpp
new file mode 100644
index 0000000..4a1f6c4
--- /dev/null
+++ b/include/boost/utility/identity_type.hpp
@@ -0,0 +1,46 @@
+
+// Copyright (C) 2009-2012 Lorenzo Caminiti
+// Distributed under the Boost Software License, Version 1.0
+// (see accompanying file LICENSE_1_0.txt or a copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// Home at http://www.boost.org/libs/utility/identity_type
+
+/** @file
+Wrap type expressions with round parenthesis so they can be passed to macros
+even if they contain commas.
+*/
+
+#ifndef BOOST_IDENTITY_TYPE_HPP_
+#define BOOST_IDENTITY_TYPE_HPP_
+
+#include <boost/type_traits/function_traits.hpp>
+
+/**
+@brief This macro allows to wrap the specified type expression within extra
+round parenthesis so the type can be passed as a single macro parameter even if
+it contains commas (not already wrapped within round parenthesis).
+
+@Params
+@Param{parenthesized_type,
+The type expression to be passed as macro parameter wrapped by a single set
+of round parenthesis <c>(...)</c>.
+This type expression can contain an arbitrary number of commas.
+}
+@EndParams
+
+This macro works on any C++03 compiler (it does not use variadic macros).
+
+This macro must be prefixed by <c>typename</c> when used within templates.
+Note that the compiler will not be able to automatically determine function
+template parameters when they are wrapped with this macro (these parameters
+need to be explicitly specified when calling the function template).
+
+On some compilers (like GCC), using this macro on abstract types requires to
+add and remove a reference to the specified type.
+*/
+#define BOOST_IDENTITY_TYPE(parenthesized_type) \
+ /* must NOT prefix this with `::` to work with parenthesized syntax */ \
+ boost::function_traits< void parenthesized_type >::arg1_type
+
+#endif // #include guard
+
diff --git a/include/boost/utility/in_place_factory.hpp b/include/boost/utility/in_place_factory.hpp
new file mode 100644
index 0000000..1a62ace
--- /dev/null
+++ b/include/boost/utility/in_place_factory.hpp
@@ -0,0 +1,86 @@
+// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2007, Tobias Schwinger.
+//
+// Use, modification, and distribution is subject to 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/optional for documentation.
+//
+// You are welcome to contact the author at:
+// fernando_cacciola@hotmail.com
+//
+#ifndef BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP
+#ifndef BOOST_PP_IS_ITERATING
+
+#include <boost/utility/detail/in_place_factory_prefix.hpp>
+
+namespace boost {
+
+class in_place_factory_base {} ;
+
+#define BOOST_PP_ITERATION_LIMITS (0, BOOST_MAX_INPLACE_FACTORY_ARITY)
+#define BOOST_PP_FILENAME_1 <boost/utility/in_place_factory.hpp>
+#include BOOST_PP_ITERATE()
+
+} // namespace boost
+
+#include <boost/utility/detail/in_place_factory_suffix.hpp>
+
+#define BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP
+#else
+#define N BOOST_PP_ITERATION()
+
+#if N
+template< BOOST_PP_ENUM_PARAMS(N, class A) >
+#endif
+class BOOST_PP_CAT(in_place_factory,N)
+ :
+ public in_place_factory_base
+{
+public:
+
+ explicit BOOST_PP_CAT(in_place_factory,N)
+ ( BOOST_PP_ENUM_BINARY_PARAMS(N,A,const& a) )
+#if N > 0
+ : BOOST_PP_ENUM(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _)
+#endif
+ {}
+
+ template<class T>
+ void* apply(void* address) const
+ {
+ return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) );
+ }
+
+ template<class T>
+ void* apply(void* address, std::size_t n) const
+ {
+ for(char* next = address = this->BOOST_NESTED_TEMPLATE apply<T>(address);
+ !! --n;)
+ this->BOOST_NESTED_TEMPLATE apply<T>(next = next+sizeof(T));
+ return address;
+ }
+
+ BOOST_PP_REPEAT(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _)
+};
+
+#if N > 0
+template< BOOST_PP_ENUM_PARAMS(N, class A) >
+inline BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) >
+in_place( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
+{
+ return BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) >
+ ( BOOST_PP_ENUM_PARAMS(N, a) );
+}
+#else
+inline in_place_factory0 in_place()
+{
+ return in_place_factory0();
+}
+#endif
+
+#undef N
+#endif
+#endif
+
diff --git a/include/boost/utility/result_of.hpp b/include/boost/utility/result_of.hpp
new file mode 100644
index 0000000..2b652ba
--- /dev/null
+++ b/include/boost/utility/result_of.hpp
@@ -0,0 +1,234 @@
+// Boost result_of library
+
+// Copyright Douglas Gregor 2004. Use, modification and
+// distribution is subject to 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/libs/utility
+#ifndef BOOST_RESULT_OF_HPP
+#define BOOST_RESULT_OF_HPP
+
+#include <boost/config.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_member_function_pointer.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/declval.hpp>
+#include <boost/type_traits/conditional.hpp>
+#include <boost/type_traits/type_identity.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/core/enable_if.hpp>
+
+#ifndef BOOST_RESULT_OF_NUM_ARGS
+# define BOOST_RESULT_OF_NUM_ARGS 16
+#endif
+
+// Use the decltype-based version of result_of by default if the compiler
+// supports N3276 <http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2011/n3276.pdf>.
+// The user can force the choice by defining BOOST_RESULT_OF_USE_DECLTYPE,
+// BOOST_RESULT_OF_USE_TR1, or BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK but not more than one!
+#if (defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_RESULT_OF_USE_TR1)) || \
+ (defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)) || \
+ (defined(BOOST_RESULT_OF_USE_TR1) && defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK))
+# error More than one of BOOST_RESULT_OF_USE_DECLTYPE, BOOST_RESULT_OF_USE_TR1 and \
+ BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK cannot be defined at the same time.
+#endif
+
+#ifndef BOOST_RESULT_OF_USE_TR1
+# ifndef BOOST_RESULT_OF_USE_DECLTYPE
+# ifndef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
+# ifndef BOOST_NO_CXX11_DECLTYPE_N3276 // this implies !defined(BOOST_NO_CXX11_DECLTYPE)
+# define BOOST_RESULT_OF_USE_DECLTYPE
+# else
+# define BOOST_RESULT_OF_USE_TR1
+# endif
+# endif
+# endif
+#endif
+
+namespace boost {
+
+template<typename F> struct result_of;
+template<typename F> struct tr1_result_of; // a TR1-style implementation of result_of
+
+#if !defined(BOOST_NO_SFINAE)
+namespace detail {
+
+typedef char result_of_yes_type; // sizeof(result_of_yes_type) == 1
+typedef char (&result_of_no_type)[2]; // sizeof(result_of_no_type) == 2
+
+template<class T> struct result_of_has_type {};
+
+template<class T> struct result_of_has_result_type_impl
+{
+ template<class U> static result_of_yes_type f( result_of_has_type<typename U::result_type>* );
+ template<class U> static result_of_no_type f( ... );
+
+ typedef boost::integral_constant<bool, sizeof(f<T>(0)) == sizeof(result_of_yes_type)> type;
+};
+
+template<class T> struct result_of_has_result_type: result_of_has_result_type_impl<T>::type
+{
+};
+
+// Work around a nvcc bug by only defining has_result when it's needed.
+#ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
+
+template<template<class> class C> struct result_of_has_template {};
+
+template<class T> struct result_of_has_result_impl
+{
+ template<class U> static result_of_yes_type f( result_of_has_template<U::template result>* );
+ template<class U> static result_of_no_type f( ... );
+
+ typedef boost::integral_constant<bool, sizeof(f<T>(0)) == sizeof(result_of_yes_type)> type;
+};
+
+template<class T> struct result_of_has_result: result_of_has_result_impl<T>::type
+{
+};
+
+#endif
+
+template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
+
+template<typename F> struct cpp0x_result_of;
+
+#ifdef BOOST_NO_SFINAE_EXPR
+
+// There doesn't seem to be any other way to turn this off such that the presence of
+// the user-defined operator,() below doesn't cause spurious warning all over the place,
+// so unconditionally turn it off.
+#if BOOST_MSVC
+# pragma warning(disable: 4913) // user defined binary operator ',' exists but no overload could convert all operands, default built-in binary operator ',' used
+#endif
+
+struct result_of_private_type {};
+
+struct result_of_weird_type {
+ friend result_of_private_type operator,(result_of_private_type, result_of_weird_type);
+};
+
+template<typename T>
+result_of_no_type result_of_is_private_type(T const &);
+result_of_yes_type result_of_is_private_type(result_of_private_type);
+
+template<typename C>
+struct result_of_callable_class : C {
+ result_of_callable_class();
+ typedef result_of_private_type const &(*pfn_t)(...);
+ operator pfn_t() const volatile;
+};
+
+template<typename C>
+struct result_of_wrap_callable_class {
+ typedef result_of_callable_class<C> type;
+};
+
+template<typename C>
+struct result_of_wrap_callable_class<C const> {
+ typedef result_of_callable_class<C> const type;
+};
+
+template<typename C>
+struct result_of_wrap_callable_class<C volatile> {
+ typedef result_of_callable_class<C> volatile type;
+};
+
+template<typename C>
+struct result_of_wrap_callable_class<C const volatile> {
+ typedef result_of_callable_class<C> const volatile type;
+};
+
+template<typename C>
+struct result_of_wrap_callable_class<C &> {
+ typedef typename result_of_wrap_callable_class<C>::type &type;
+};
+
+template<typename F, bool TestCallability = true> struct cpp0x_result_of_impl;
+
+#else // BOOST_NO_SFINAE_EXPR
+
+template<typename T>
+struct result_of_always_void
+{
+ typedef void type;
+};
+
+template<typename F, typename Enable = void> struct cpp0x_result_of_impl {};
+
+#endif // BOOST_NO_SFINAE_EXPR
+
+template<typename F>
+struct result_of_void_impl
+{
+ typedef void type;
+};
+
+template<typename R>
+struct result_of_void_impl<R (*)(void)>
+{
+ typedef R type;
+};
+
+template<typename R>
+struct result_of_void_impl<R (&)(void)>
+{
+ typedef R type;
+};
+
+// Determine the return type of a function pointer or pointer to member.
+template<typename F, typename FArgs>
+struct result_of_pointer
+ : tr1_result_of_impl<typename remove_cv<F>::type, FArgs, false> { };
+
+template<typename F, typename FArgs>
+struct tr1_result_of_impl<F, FArgs, true>
+{
+ typedef typename F::result_type type;
+};
+
+template<typename FArgs>
+struct is_function_with_no_args : false_type {};
+
+template<typename F>
+struct is_function_with_no_args<F(void)> : true_type {};
+
+template<typename F, typename FArgs>
+struct result_of_nested_result : F::template result<FArgs>
+{};
+
+template<typename F, typename FArgs>
+struct tr1_result_of_impl<F, FArgs, false>
+ : conditional<is_function_with_no_args<FArgs>::value,
+ result_of_void_impl<F>,
+ result_of_nested_result<F, FArgs> >::type
+{};
+
+} // end namespace detail
+
+#define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_RESULT_OF_NUM_ARGS,<boost/utility/detail/result_of_iterate.hpp>))
+#include BOOST_PP_ITERATE()
+
+#if 0
+// inform dependency trackers, as they can't see through macro includes
+#include <boost/utility/detail/result_of_iterate.hpp>
+#endif
+
+#else
+# define BOOST_NO_RESULT_OF 1
+#endif
+
+}
+
+#endif // BOOST_RESULT_OF_HPP
diff --git a/include/boost/utility/string_ref.hpp b/include/boost/utility/string_ref.hpp
new file mode 100644
index 0000000..d234e54
--- /dev/null
+++ b/include/boost/utility/string_ref.hpp
@@ -0,0 +1,553 @@
+/*
+ Copyright (c) Marshall Clow 2012-2015.
+
+ 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
+
+ Based on the StringRef implementation in LLVM (http://llvm.org) and
+ N3422 by Jeffrey Yasskin
+ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
+
+*/
+
+#ifndef BOOST_STRING_REF_HPP
+#define BOOST_STRING_REF_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/utility/string_ref_fwd.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <cstddef>
+#include <stdexcept>
+#include <algorithm>
+#include <iterator>
+#include <string>
+#include <iosfwd>
+
+#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || (defined(BOOST_GCC) && ((BOOST_GCC+0) / 100) <= 406)
+// GCC 4.6 cannot handle a defaulted function with noexcept specifier
+#define BOOST_STRING_REF_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
+#endif
+
+namespace boost {
+
+ namespace detail {
+ // A helper functor because sometimes we don't have lambdas
+ template <typename charT, typename traits>
+ class string_ref_traits_eq {
+ public:
+ string_ref_traits_eq ( charT ch ) : ch_(ch) {}
+ bool operator () ( charT val ) const { return traits::eq ( ch_, val ); }
+ charT ch_;
+ };
+ }
+
+ template<typename charT, typename traits>
+ class basic_string_ref {
+ public:
+ // types
+ typedef charT value_type;
+ typedef const charT* pointer;
+ typedef const charT& reference;
+ typedef const charT& const_reference;
+ typedef pointer const_iterator; // impl-defined
+ typedef const_iterator iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef const_reverse_iterator reverse_iterator;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+ static BOOST_CONSTEXPR_OR_CONST size_type npos = size_type(-1);
+
+ // construct/copy
+ BOOST_CONSTEXPR basic_string_ref () BOOST_NOEXCEPT
+ : ptr_(NULL), len_(0) {}
+
+ // by defaulting these functions, basic_string_ref becomes
+ // trivially copy/move constructible.
+ BOOST_CONSTEXPR basic_string_ref (const basic_string_ref &rhs) BOOST_NOEXCEPT
+#ifndef BOOST_STRING_REF_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
+ = default;
+#else
+ : ptr_(rhs.ptr_), len_(rhs.len_) {}
+#endif
+
+ basic_string_ref& operator=(const basic_string_ref &rhs) BOOST_NOEXCEPT
+#ifndef BOOST_STRING_REF_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
+ = default;
+#else
+ {
+ ptr_ = rhs.ptr_;
+ len_ = rhs.len_;
+ return *this;
+ }
+#endif
+
+ basic_string_ref(const charT* str) BOOST_NOEXCEPT
+ : ptr_(str), len_(traits::length(str)) {}
+
+ template<typename Allocator>
+ basic_string_ref(const std::basic_string<charT, traits, Allocator>& str)
+ : ptr_(str.data()), len_(str.length()) {}
+
+// #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+// // Constructing a string_ref from a temporary string is a bad idea
+// template<typename Allocator>
+// basic_string_ref( std::basic_string<charT, traits, Allocator>&&)
+// = delete;
+// #endif
+
+ BOOST_CONSTEXPR basic_string_ref(const charT* str, size_type len) BOOST_NOEXCEPT
+ : ptr_(str), len_(len) {}
+
+#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+ template<typename Allocator>
+ explicit operator std::basic_string<charT, traits, Allocator>() const {
+ return std::basic_string<charT, traits, Allocator> ( begin(), end());
+ }
+#endif
+
+ std::basic_string<charT, traits> to_string () const {
+ return std::basic_string<charT, traits> ( begin(), end());
+ }
+
+ // iterators
+ BOOST_CONSTEXPR const_iterator begin() const { return ptr_; }
+ BOOST_CONSTEXPR const_iterator cbegin() const { return ptr_; }
+ BOOST_CONSTEXPR const_iterator end() const { return ptr_ + len_; }
+ BOOST_CONSTEXPR const_iterator cend() const { return ptr_ + len_; }
+ const_reverse_iterator rbegin() const { return const_reverse_iterator (end()); }
+ const_reverse_iterator crbegin() const { return const_reverse_iterator (end()); }
+ const_reverse_iterator rend() const { return const_reverse_iterator (begin()); }
+ const_reverse_iterator crend() const { return const_reverse_iterator (begin()); }
+
+ // capacity
+ BOOST_CONSTEXPR size_type size() const { return len_; }
+ BOOST_CONSTEXPR size_type length() const { return len_; }
+ BOOST_CONSTEXPR size_type max_size() const { return len_; }
+ BOOST_CONSTEXPR bool empty() const { return len_ == 0; }
+
+ // element access
+ BOOST_CONSTEXPR const charT& operator[](size_type pos) const { return ptr_[pos]; }
+
+ const charT& at(size_t pos) const {
+ if ( pos >= len_ )
+ BOOST_THROW_EXCEPTION( std::out_of_range ( "boost::string_ref::at" ) );
+ return ptr_[pos];
+ }
+
+ BOOST_CONSTEXPR const charT& front() const { return ptr_[0]; }
+ BOOST_CONSTEXPR const charT& back() const { return ptr_[len_-1]; }
+ BOOST_CONSTEXPR const charT* data() const { return ptr_; }
+
+ // modifiers
+ void clear() { len_ = 0; }
+ void remove_prefix(size_type n) {
+ if ( n > len_ )
+ n = len_;
+ ptr_ += n;
+ len_ -= n;
+ }
+
+ void remove_suffix(size_type n) {
+ if ( n > len_ )
+ n = len_;
+ len_ -= n;
+ }
+
+
+ // basic_string_ref string operations
+ basic_string_ref substr(size_type pos, size_type n=npos) const {
+ if ( pos > size())
+ BOOST_THROW_EXCEPTION( std::out_of_range ( "string_ref::substr" ) );
+ return basic_string_ref(data() + pos, (std::min)(size() - pos, n));
+ }
+
+ int compare(basic_string_ref x) const {
+ const int cmp = traits::compare ( ptr_, x.ptr_, (std::min)(len_, x.len_));
+ return cmp != 0 ? cmp : ( len_ == x.len_ ? 0 : len_ < x.len_ ? -1 : 1 );
+ }
+
+ bool starts_with(charT c) const { return !empty() && traits::eq ( c, front()); }
+ bool starts_with(basic_string_ref x) const {
+ return len_ >= x.len_ && traits::compare ( ptr_, x.ptr_, x.len_ ) == 0;
+ }
+
+ bool ends_with(charT c) const { return !empty() && traits::eq ( c, back()); }
+ bool ends_with(basic_string_ref x) const {
+ return len_ >= x.len_ && traits::compare ( ptr_ + len_ - x.len_, x.ptr_, x.len_ ) == 0;
+ }
+
+ size_type find(basic_string_ref s) const {
+ const_iterator iter = std::search ( this->cbegin (), this->cend (),
+ s.cbegin (), s.cend (), traits::eq );
+ return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
+ }
+
+ size_type find(charT c) const {
+ const_iterator iter = std::find_if ( this->cbegin (), this->cend (),
+ detail::string_ref_traits_eq<charT, traits> ( c ));
+ return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
+ }
+
+ size_type rfind(basic_string_ref s) const {
+ const_reverse_iterator iter = std::search ( this->crbegin (), this->crend (),
+ s.crbegin (), s.crend (), traits::eq );
+ return iter == this->crend () ? npos : (std::distance(iter, this->crend()) - s.size());
+ }
+
+ size_type rfind(charT c) const {
+ const_reverse_iterator iter = std::find_if ( this->crbegin (), this->crend (),
+ detail::string_ref_traits_eq<charT, traits> ( c ));
+ return iter == this->crend () ? npos : (this->size() - 1 - std::distance(this->crbegin(), iter));
+ }
+
+ size_type find_first_of(charT c) const { return find (c); }
+ size_type find_last_of (charT c) const { return rfind (c); }
+
+ size_type find_first_of(basic_string_ref s) const {
+ const_iterator iter = std::find_first_of
+ ( this->cbegin (), this->cend (), s.cbegin (), s.cend (), traits::eq );
+ return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
+ }
+
+ size_type find_last_of(basic_string_ref s) const {
+ const_reverse_iterator iter = std::find_first_of
+ ( this->crbegin (), this->crend (), s.cbegin (), s.cend (), traits::eq );
+ return iter == this->crend () ? npos : (this->size() - 1 - std::distance(this->crbegin(), iter));
+ }
+
+ size_type find_first_not_of(basic_string_ref s) const {
+ const_iterator iter = find_not_of ( this->cbegin (), this->cend (), s );
+ return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
+ }
+
+ size_type find_first_not_of(charT c) const {
+ for ( const_iterator iter = this->cbegin (); iter != this->cend (); ++iter )
+ if ( !traits::eq ( c, *iter ))
+ return std::distance ( this->cbegin (), iter );
+ return npos;
+ }
+
+ size_type find_last_not_of(basic_string_ref s) const {
+ const_reverse_iterator iter = find_not_of ( this->crbegin (), this->crend (), s );
+ return iter == this->crend () ? npos : (this->size() - 1 - std::distance(this->crbegin(), iter));
+ }
+
+ size_type find_last_not_of(charT c) const {
+ for ( const_reverse_iterator iter = this->crbegin (); iter != this->crend (); ++iter )
+ if ( !traits::eq ( c, *iter ))
+ return this->size() - 1 - std::distance(this->crbegin(), iter);
+ return npos;
+ }
+
+ private:
+
+ template <typename Iterator>
+ Iterator find_not_of ( Iterator first, Iterator last, basic_string_ref s ) const {
+ for ( ; first != last ; ++first )
+ if ( 0 == traits::find ( s.ptr_, s.len_, *first ))
+ return first;
+ return last;
+ }
+
+
+
+ const charT *ptr_;
+ std::size_t len_;
+ };
+
+
+// Comparison operators
+// Equality
+ template<typename charT, typename traits>
+ inline bool operator==(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
+ if ( x.size () != y.size ()) return false;
+ return x.compare(y) == 0;
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline bool operator==(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+ return x == basic_string_ref<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline bool operator==(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+ return basic_string_ref<charT, traits>(x) == y;
+ }
+
+ template<typename charT, typename traits>
+ inline bool operator==(basic_string_ref<charT, traits> x, const charT * y) {
+ return x == basic_string_ref<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits>
+ inline bool operator==(const charT * x, basic_string_ref<charT, traits> y) {
+ return basic_string_ref<charT, traits>(x) == y;
+ }
+
+// Inequality
+ template<typename charT, typename traits>
+ inline bool operator!=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
+ if ( x.size () != y.size ()) return true;
+ return x.compare(y) != 0;
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline bool operator!=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+ return x != basic_string_ref<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline bool operator!=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+ return basic_string_ref<charT, traits>(x) != y;
+ }
+
+ template<typename charT, typename traits>
+ inline bool operator!=(basic_string_ref<charT, traits> x, const charT * y) {
+ return x != basic_string_ref<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits>
+ inline bool operator!=(const charT * x, basic_string_ref<charT, traits> y) {
+ return basic_string_ref<charT, traits>(x) != y;
+ }
+
+// Less than
+ template<typename charT, typename traits>
+ inline bool operator<(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
+ return x.compare(y) < 0;
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline bool operator<(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+ return x < basic_string_ref<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline bool operator<(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+ return basic_string_ref<charT, traits>(x) < y;
+ }
+
+ template<typename charT, typename traits>
+ inline bool operator<(basic_string_ref<charT, traits> x, const charT * y) {
+ return x < basic_string_ref<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits>
+ inline bool operator<(const charT * x, basic_string_ref<charT, traits> y) {
+ return basic_string_ref<charT, traits>(x) < y;
+ }
+
+// Greater than
+ template<typename charT, typename traits>
+ inline bool operator>(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
+ return x.compare(y) > 0;
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline bool operator>(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+ return x > basic_string_ref<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline bool operator>(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+ return basic_string_ref<charT, traits>(x) > y;
+ }
+
+ template<typename charT, typename traits>
+ inline bool operator>(basic_string_ref<charT, traits> x, const charT * y) {
+ return x > basic_string_ref<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits>
+ inline bool operator>(const charT * x, basic_string_ref<charT, traits> y) {
+ return basic_string_ref<charT, traits>(x) > y;
+ }
+
+// Less than or equal to
+ template<typename charT, typename traits>
+ inline bool operator<=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
+ return x.compare(y) <= 0;
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline bool operator<=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+ return x <= basic_string_ref<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline bool operator<=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+ return basic_string_ref<charT, traits>(x) <= y;
+ }
+
+ template<typename charT, typename traits>
+ inline bool operator<=(basic_string_ref<charT, traits> x, const charT * y) {
+ return x <= basic_string_ref<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits>
+ inline bool operator<=(const charT * x, basic_string_ref<charT, traits> y) {
+ return basic_string_ref<charT, traits>(x) <= y;
+ }
+
+// Greater than or equal to
+ template<typename charT, typename traits>
+ inline bool operator>=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
+ return x.compare(y) >= 0;
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline bool operator>=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+ return x >= basic_string_ref<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline bool operator>=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+ return basic_string_ref<charT, traits>(x) >= y;
+ }
+
+ template<typename charT, typename traits>
+ inline bool operator>=(basic_string_ref<charT, traits> x, const charT * y) {
+ return x >= basic_string_ref<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits>
+ inline bool operator>=(const charT * x, basic_string_ref<charT, traits> y) {
+ return basic_string_ref<charT, traits>(x) >= y;
+ }
+
+ namespace detail {
+
+ template<class charT, class traits>
+ inline void sr_insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) {
+ enum { chunk_size = 8 };
+ charT fill_chars[chunk_size];
+ std::fill_n(fill_chars, static_cast< std::size_t >(chunk_size), os.fill());
+ for (; n >= chunk_size && os.good(); n -= chunk_size)
+ os.write(fill_chars, static_cast< std::size_t >(chunk_size));
+ if (n > 0 && os.good())
+ os.write(fill_chars, n);
+ }
+
+ template<class charT, class traits>
+ void sr_insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) {
+ const std::size_t size = str.size();
+ const std::size_t alignment_size = static_cast< std::size_t >(os.width()) - size;
+ const bool align_left = (os.flags() & std::basic_ostream<charT, traits>::adjustfield) == std::basic_ostream<charT, traits>::left;
+ if (!align_left) {
+ detail::sr_insert_fill_chars(os, alignment_size);
+ if (os.good())
+ os.write(str.data(), size);
+ }
+ else {
+ os.write(str.data(), size);
+ if (os.good())
+ detail::sr_insert_fill_chars(os, alignment_size);
+ }
+ }
+
+ } // namespace detail
+
+ // Inserter
+ template<class charT, class traits>
+ inline std::basic_ostream<charT, traits>&
+ operator<<(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) {
+ if (os.good()) {
+ const std::size_t size = str.size();
+ const std::size_t w = static_cast< std::size_t >(os.width());
+ if (w <= size)
+ os.write(str.data(), size);
+ else
+ detail::sr_insert_aligned(os, str);
+ os.width(0);
+ }
+ return os;
+ }
+
+#if 0
+ // numeric conversions
+ //
+ // These are short-term implementations.
+ // In a production environment, I would rather avoid the copying.
+ //
+ inline int stoi (string_ref str, size_t* idx=0, int base=10) {
+ return std::stoi ( std::string(str), idx, base );
+ }
+
+ inline long stol (string_ref str, size_t* idx=0, int base=10) {
+ return std::stol ( std::string(str), idx, base );
+ }
+
+ inline unsigned long stoul (string_ref str, size_t* idx=0, int base=10) {
+ return std::stoul ( std::string(str), idx, base );
+ }
+
+ inline long long stoll (string_ref str, size_t* idx=0, int base=10) {
+ return std::stoll ( std::string(str), idx, base );
+ }
+
+ inline unsigned long long stoull (string_ref str, size_t* idx=0, int base=10) {
+ return std::stoull ( std::string(str), idx, base );
+ }
+
+ inline float stof (string_ref str, size_t* idx=0) {
+ return std::stof ( std::string(str), idx );
+ }
+
+ inline double stod (string_ref str, size_t* idx=0) {
+ return std::stod ( std::string(str), idx );
+ }
+
+ inline long double stold (string_ref str, size_t* idx=0) {
+ return std::stold ( std::string(str), idx );
+ }
+
+ inline int stoi (wstring_ref str, size_t* idx=0, int base=10) {
+ return std::stoi ( std::wstring(str), idx, base );
+ }
+
+ inline long stol (wstring_ref str, size_t* idx=0, int base=10) {
+ return std::stol ( std::wstring(str), idx, base );
+ }
+
+ inline unsigned long stoul (wstring_ref str, size_t* idx=0, int base=10) {
+ return std::stoul ( std::wstring(str), idx, base );
+ }
+
+ inline long long stoll (wstring_ref str, size_t* idx=0, int base=10) {
+ return std::stoll ( std::wstring(str), idx, base );
+ }
+
+ inline unsigned long long stoull (wstring_ref str, size_t* idx=0, int base=10) {
+ return std::stoull ( std::wstring(str), idx, base );
+ }
+
+ inline float stof (wstring_ref str, size_t* idx=0) {
+ return std::stof ( std::wstring(str), idx );
+ }
+
+ inline double stod (wstring_ref str, size_t* idx=0) {
+ return std::stod ( std::wstring(str), idx );
+ }
+
+ inline long double stold (wstring_ref str, size_t* idx=0) {
+ return std::stold ( std::wstring(str), idx );
+ }
+#endif
+
+}
+
+#if 0
+namespace std {
+ // Hashing
+ template<> struct hash<boost::string_ref>;
+ template<> struct hash<boost::u16string_ref>;
+ template<> struct hash<boost::u32string_ref>;
+ template<> struct hash<boost::wstring_ref>;
+}
+#endif
+
+#endif
diff --git a/include/boost/utility/string_ref_fwd.hpp b/include/boost/utility/string_ref_fwd.hpp
new file mode 100644
index 0000000..f58b98c
--- /dev/null
+++ b/include/boost/utility/string_ref_fwd.hpp
@@ -0,0 +1,37 @@
+/*
+ Copyright (c) Marshall Clow 2012-2012.
+
+ 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
+
+ Based on the StringRef implementation in LLVM (http://llvm.org) and
+ N3422 by Jeffrey Yasskin
+ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
+
+*/
+
+#ifndef BOOST_STRING_REF_FWD_HPP
+#define BOOST_STRING_REF_FWD_HPP
+
+#include <boost/config.hpp>
+#include <string>
+
+namespace boost {
+
+ template<typename charT, typename traits = std::char_traits<charT> > class basic_string_ref;
+ typedef basic_string_ref<char, std::char_traits<char> > string_ref;
+ typedef basic_string_ref<wchar_t, std::char_traits<wchar_t> > wstring_ref;
+
+#ifndef BOOST_NO_CXX11_CHAR16_T
+ typedef basic_string_ref<char16_t, std::char_traits<char16_t> > u16string_ref;
+#endif
+
+#ifndef BOOST_NO_CXX11_CHAR32_T
+ typedef basic_string_ref<char32_t, std::char_traits<char32_t> > u32string_ref;
+#endif
+
+}
+
+#endif
diff --git a/include/boost/utility/string_view.hpp b/include/boost/utility/string_view.hpp
new file mode 100644
index 0000000..44efda9
--- /dev/null
+++ b/include/boost/utility/string_view.hpp
@@ -0,0 +1,705 @@
+/*
+ Copyright (c) Marshall Clow 2012-2015.
+ Copyright (c) Beman Dawes 2015
+
+ 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
+
+ Based on the StringRef implementation in LLVM (http://llvm.org) and
+ N3422 by Jeffrey Yasskin
+ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
+ Updated July 2015 to reflect the Library Fundamentals TS
+ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4480.html
+*/
+
+#ifndef BOOST_STRING_VIEW_HPP
+#define BOOST_STRING_VIEW_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/utility/string_view_fwd.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <cstddef>
+#include <stdexcept>
+#include <algorithm>
+#include <iterator>
+#include <string>
+#include <cstring>
+#include <iosfwd>
+
+#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || (defined(BOOST_GCC) && ((BOOST_GCC+0) / 100) <= 406)
+// GCC 4.6 cannot handle a defaulted function with noexcept specifier
+#define BOOST_STRING_VIEW_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
+#endif
+
+namespace boost {
+
+ namespace detail {
+ // A helper functor because sometimes we don't have lambdas
+ template <typename charT, typename traits>
+ class string_view_traits_eq {
+ public:
+ string_view_traits_eq ( charT ch ) : ch_(ch) {}
+ bool operator()( charT val ) const { return traits::eq (ch_, val); }
+ charT ch_;
+ };
+ }
+
+ template<typename charT, typename traits> // traits defaulted in string_view_fwd.hpp
+ class basic_string_view {
+ public:
+ // types
+ typedef traits traits_type;
+ typedef charT value_type;
+ typedef charT* pointer;
+ typedef const charT* const_pointer;
+ typedef charT& reference;
+ typedef const charT& const_reference;
+ typedef const_pointer const_iterator; // impl-defined
+ typedef const_iterator iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef const_reverse_iterator reverse_iterator;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+ static BOOST_CONSTEXPR_OR_CONST size_type npos = size_type(-1);
+
+ // construct/copy
+ BOOST_CONSTEXPR basic_string_view() BOOST_NOEXCEPT
+ : ptr_(NULL), len_(0) {}
+
+ // by defaulting these functions, basic_string_ref becomes
+ // trivially copy/move constructible.
+ BOOST_CONSTEXPR basic_string_view(const basic_string_view &rhs) BOOST_NOEXCEPT
+#ifndef BOOST_STRING_VIEW_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
+ = default;
+#else
+ : ptr_(rhs.ptr_), len_(rhs.len_) {}
+#endif
+
+ basic_string_view& operator=(const basic_string_view &rhs) BOOST_NOEXCEPT
+#ifndef BOOST_STRING_VIEW_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
+ = default;
+#else
+ {
+ ptr_ = rhs.ptr_;
+ len_ = rhs.len_;
+ return *this;
+ }
+#endif
+
+ template<typename Allocator>
+ basic_string_view(const std::basic_string<charT, traits, Allocator>& str) BOOST_NOEXCEPT
+ : ptr_(str.data()), len_(str.length()) {}
+
+// #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+// // Constructing a string_view from a temporary string is a bad idea
+// template<typename Allocator>
+// basic_string_view( std::basic_string<charT, traits, Allocator>&&)
+// = delete;
+// #endif
+
+ BOOST_CONSTEXPR basic_string_view(const charT* str)
+ : ptr_(str), len_(traits::length(str)) {}
+
+ BOOST_CONSTEXPR basic_string_view(const charT* str, size_type len)
+ : ptr_(str), len_(len) {}
+
+ // iterators
+ BOOST_CONSTEXPR const_iterator begin() const BOOST_NOEXCEPT { return ptr_; }
+ BOOST_CONSTEXPR const_iterator cbegin() const BOOST_NOEXCEPT { return ptr_; }
+ BOOST_CONSTEXPR const_iterator end() const BOOST_NOEXCEPT { return ptr_ + len_; }
+ BOOST_CONSTEXPR const_iterator cend() const BOOST_NOEXCEPT { return ptr_ + len_; }
+ const_reverse_iterator rbegin() const BOOST_NOEXCEPT { return const_reverse_iterator(end()); }
+ const_reverse_iterator crbegin() const BOOST_NOEXCEPT { return const_reverse_iterator(end()); }
+ const_reverse_iterator rend() const BOOST_NOEXCEPT { return const_reverse_iterator(begin()); }
+ const_reverse_iterator crend() const BOOST_NOEXCEPT { return const_reverse_iterator(begin()); }
+
+ // capacity
+ BOOST_CONSTEXPR size_type size() const BOOST_NOEXCEPT { return len_; }
+ BOOST_CONSTEXPR size_type length() const BOOST_NOEXCEPT { return len_; }
+ BOOST_CONSTEXPR size_type max_size() const BOOST_NOEXCEPT { return len_; }
+ BOOST_CONSTEXPR bool empty() const BOOST_NOEXCEPT { return len_ == 0; }
+
+ // element access
+ BOOST_CONSTEXPR const_reference operator[](size_type pos) const BOOST_NOEXCEPT { return ptr_[pos]; }
+
+ BOOST_CONSTEXPR const_reference at(size_t pos) const {
+ return pos >= len_ ? BOOST_THROW_EXCEPTION(std::out_of_range("boost::string_view::at")), ptr_[0] : ptr_[pos];
+ }
+
+ BOOST_CONSTEXPR const_reference front() const { return ptr_[0]; }
+ BOOST_CONSTEXPR const_reference back() const { return ptr_[len_-1]; }
+ BOOST_CONSTEXPR const_pointer data() const BOOST_NOEXCEPT { return ptr_; }
+
+ // modifiers
+ void clear() BOOST_NOEXCEPT { len_ = 0; } // Boost extension
+
+ BOOST_CXX14_CONSTEXPR void remove_prefix(size_type n) {
+ if ( n > len_ )
+ n = len_;
+ ptr_ += n;
+ len_ -= n;
+ }
+
+ BOOST_CXX14_CONSTEXPR void remove_suffix(size_type n) {
+ if ( n > len_ )
+ n = len_;
+ len_ -= n;
+ }
+
+ BOOST_CXX14_CONSTEXPR void swap(basic_string_view& s) BOOST_NOEXCEPT {
+ std::swap(ptr_, s.ptr_);
+ std::swap(len_, s.len_);
+ }
+
+ // basic_string_view string operations
+#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+ template<typename Allocator>
+ explicit operator std::basic_string<charT, traits, Allocator>() const {
+ return std::basic_string<charT, traits, Allocator>(begin(), end());
+ }
+#endif
+
+#ifndef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+ template<typename Allocator = std::allocator<charT> >
+ std::basic_string<charT, traits, Allocator> to_string(const Allocator& a = Allocator()) const {
+ return std::basic_string<charT, traits, Allocator>(begin(), end(), a);
+ }
+#else
+ std::basic_string<charT, traits> to_string() const {
+ return std::basic_string<charT, traits>(begin(), end());
+ }
+
+ template<typename Allocator>
+ std::basic_string<charT, traits, Allocator> to_string(const Allocator& a) const {
+ return std::basic_string<charT, traits, Allocator>(begin(), end(), a);
+ }
+#endif
+
+ size_type copy(charT* s, size_type n, size_type pos=0) const {
+ if (pos > size())
+ BOOST_THROW_EXCEPTION(std::out_of_range("string_view::copy" ));
+ size_type rlen = (std::min)(n, len_ - pos);
+ traits_type::copy(s, data() + pos, rlen);
+ return rlen;
+ }
+
+ BOOST_CXX14_CONSTEXPR basic_string_view substr(size_type pos, size_type n=npos) const {
+ if ( pos > size())
+ BOOST_THROW_EXCEPTION( std::out_of_range ( "string_view::substr" ) );
+ return basic_string_view(data() + pos, (std::min)(size() - pos, n));
+ }
+
+ BOOST_CXX14_CONSTEXPR int compare(basic_string_view x) const BOOST_NOEXCEPT {
+ const int cmp = traits::compare(ptr_, x.ptr_, (std::min)(len_, x.len_));
+ return cmp != 0 ? cmp : (len_ == x.len_ ? 0 : len_ < x.len_ ? -1 : 1);
+ }
+
+ BOOST_CXX14_CONSTEXPR int compare(size_type pos1, size_type n1, basic_string_view x)
+ const BOOST_NOEXCEPT {
+ return substr(pos1, n1).compare(x);
+ }
+
+ BOOST_CXX14_CONSTEXPR int compare(size_type pos1, size_type n1,
+ basic_string_view x, size_type pos2, size_type n2) const {
+ return substr(pos1, n1).compare(x.substr(pos2, n2));
+ }
+
+ BOOST_CXX14_CONSTEXPR int compare(const charT* x) const {
+ return compare(basic_string_view(x));
+ }
+
+ BOOST_CXX14_CONSTEXPR int compare(size_type pos1, size_type n1, const charT* x) const {
+ return substr(pos1, n1).compare(basic_string_view(x));
+ }
+
+ BOOST_CXX14_CONSTEXPR int compare(size_type pos1, size_type n1,
+ const charT* x, size_type n2) const {
+ return substr(pos1, n1).compare(basic_string_view(x, n2));
+ }
+
+ // Searches
+ BOOST_CONSTEXPR bool starts_with(charT c) const BOOST_NOEXCEPT { // Boost extension
+ return !empty() && traits::eq(c, front());
+ }
+
+ BOOST_CONSTEXPR bool starts_with(basic_string_view x) const BOOST_NOEXCEPT { // Boost extension
+ return len_ >= x.len_ && traits::compare(ptr_, x.ptr_, x.len_) == 0;
+ }
+
+ BOOST_CONSTEXPR bool ends_with(charT c) const BOOST_NOEXCEPT { // Boost extension
+ return !empty() && traits::eq(c, back());
+ }
+
+ BOOST_CONSTEXPR bool ends_with(basic_string_view x) const BOOST_NOEXCEPT { // Boost extension
+ return len_ >= x.len_ &&
+ traits::compare(ptr_ + len_ - x.len_, x.ptr_, x.len_) == 0;
+ }
+
+ // find
+ BOOST_CXX14_CONSTEXPR size_type find(basic_string_view s, size_type pos = 0) const BOOST_NOEXCEPT {
+ if (pos > size())
+ return npos;
+ if (s.empty())
+ return pos;
+ if (s.size() > size() - pos)
+ return npos;
+ const charT* cur = ptr_ + pos;
+ const charT* last = cend() - s.size() + 1;
+ for (; cur != last ; ++cur) {
+ cur = traits::find(cur, last - cur, s[0]);
+ if (!cur)
+ return npos;
+ if (traits::compare(cur, s.cbegin(), s.size()) == 0)
+ return cur - ptr_;
+ }
+ return npos;
+ }
+ BOOST_CXX14_CONSTEXPR size_type find(charT c, size_type pos = 0) const BOOST_NOEXCEPT {
+ if (pos > size())
+ return npos;
+ const charT* ret_ptr = traits::find(ptr_ + pos, len_ - pos, c);
+ if (ret_ptr)
+ return ret_ptr - ptr_;
+ return npos;
+ }
+ BOOST_CXX14_CONSTEXPR size_type find(const charT* s, size_type pos, size_type n) const BOOST_NOEXCEPT
+ { return find(basic_string_view(s, n), pos); }
+ BOOST_CXX14_CONSTEXPR size_type find(const charT* s, size_type pos = 0) const BOOST_NOEXCEPT
+ { return find(basic_string_view(s), pos); }
+
+ // rfind
+ BOOST_CXX14_CONSTEXPR size_type rfind(basic_string_view s, size_type pos = npos) const BOOST_NOEXCEPT {
+ if (len_ < s.len_)
+ return npos;
+ if (pos > len_ - s.len_)
+ pos = len_ - s.len_;
+ if (s.len_ == 0u) // an empty string is always found
+ return pos;
+ for (const charT* cur = ptr_ + pos; ; --cur) {
+ if (traits::compare(cur, s.ptr_, s.len_) == 0)
+ return cur - ptr_;
+ if (cur == ptr_)
+ return npos;
+ };
+ }
+ BOOST_CXX14_CONSTEXPR size_type rfind(charT c, size_type pos = npos) const BOOST_NOEXCEPT
+ { return rfind(basic_string_view(&c, 1), pos); }
+ BOOST_CXX14_CONSTEXPR size_type rfind(const charT* s, size_type pos, size_type n) const BOOST_NOEXCEPT
+ { return rfind(basic_string_view(s, n), pos); }
+ BOOST_CXX14_CONSTEXPR size_type rfind(const charT* s, size_type pos = npos) const BOOST_NOEXCEPT
+ { return rfind(basic_string_view(s), pos); }
+
+ // find_first_of
+ BOOST_CXX14_CONSTEXPR size_type find_first_of(basic_string_view s, size_type pos = 0) const BOOST_NOEXCEPT {
+ if (pos >= len_ || s.len_ == 0)
+ return npos;
+ const_iterator iter = std::find_first_of
+ (this->cbegin () + pos, this->cend (), s.cbegin (), s.cend (), traits::eq);
+ return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
+ }
+ BOOST_CXX14_CONSTEXPR size_type find_first_of(charT c, size_type pos = 0) const BOOST_NOEXCEPT
+ { return find(c, pos); }
+ BOOST_CXX14_CONSTEXPR size_type find_first_of(const charT* s, size_type pos, size_type n) const BOOST_NOEXCEPT
+ { return find_first_of(basic_string_view(s, n), pos); }
+ BOOST_CXX14_CONSTEXPR size_type find_first_of(const charT* s, size_type pos = 0) const BOOST_NOEXCEPT
+ { return find_first_of(basic_string_view(s), pos); }
+
+ // find_last_of
+ BOOST_CXX14_CONSTEXPR size_type find_last_of(basic_string_view s, size_type pos = npos) const BOOST_NOEXCEPT {
+ if (s.len_ == 0u)
+ return npos;
+ if (pos >= len_)
+ pos = 0;
+ else
+ pos = len_ - (pos+1);
+ const_reverse_iterator iter = std::find_first_of
+ ( this->crbegin () + pos, this->crend (), s.cbegin (), s.cend (), traits::eq );
+ return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter);
+ }
+ BOOST_CXX14_CONSTEXPR size_type find_last_of(charT c, size_type pos = npos) const BOOST_NOEXCEPT
+ { return find_last_of(basic_string_view(&c, 1), pos); }
+ BOOST_CXX14_CONSTEXPR size_type find_last_of(const charT* s, size_type pos, size_type n) const BOOST_NOEXCEPT
+ { return find_last_of(basic_string_view(s, n), pos); }
+ BOOST_CXX14_CONSTEXPR size_type find_last_of(const charT* s, size_type pos = npos) const BOOST_NOEXCEPT
+ { return find_last_of(basic_string_view(s), pos); }
+
+ // find_first_not_of
+ BOOST_CXX14_CONSTEXPR size_type find_first_not_of(basic_string_view s, size_type pos = 0) const BOOST_NOEXCEPT {
+ if (pos >= len_)
+ return npos;
+ if (s.len_ == 0)
+ return pos;
+ const_iterator iter = find_not_of ( this->cbegin () + pos, this->cend (), s );
+ return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
+ }
+ BOOST_CXX14_CONSTEXPR size_type find_first_not_of(charT c, size_type pos = 0) const BOOST_NOEXCEPT
+ { return find_first_not_of(basic_string_view(&c, 1), pos); }
+ BOOST_CXX14_CONSTEXPR size_type find_first_not_of(const charT* s, size_type pos, size_type n) const BOOST_NOEXCEPT
+ { return find_first_not_of(basic_string_view(s, n), pos); }
+ BOOST_CXX14_CONSTEXPR size_type find_first_not_of(const charT* s, size_type pos = 0) const BOOST_NOEXCEPT
+ { return find_first_not_of(basic_string_view(s), pos); }
+
+ // find_last_not_of
+ BOOST_CXX14_CONSTEXPR size_type find_last_not_of(basic_string_view s, size_type pos = npos) const BOOST_NOEXCEPT {
+ if (pos >= len_)
+ pos = len_ - 1;
+ if (s.len_ == 0u)
+ return pos;
+ pos = len_ - (pos+1);
+ const_reverse_iterator iter = find_not_of ( this->crbegin () + pos, this->crend (), s );
+ return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter );
+ }
+ BOOST_CXX14_CONSTEXPR size_type find_last_not_of(charT c, size_type pos = npos) const BOOST_NOEXCEPT
+ { return find_last_not_of(basic_string_view(&c, 1), pos); }
+ BOOST_CXX14_CONSTEXPR size_type find_last_not_of(const charT* s, size_type pos, size_type n) const BOOST_NOEXCEPT
+ { return find_last_not_of(basic_string_view(s, n), pos); }
+ BOOST_CXX14_CONSTEXPR size_type find_last_not_of(const charT* s, size_type pos = npos) const BOOST_NOEXCEPT
+ { return find_last_not_of(basic_string_view(s), pos); }
+
+ private:
+ template <typename r_iter>
+ size_type reverse_distance(r_iter first, r_iter last) const BOOST_NOEXCEPT {
+ // Portability note here: std::distance is not NOEXCEPT, but calling it with a string_view::reverse_iterator will not throw.
+ return len_ - 1 - std::distance ( first, last );
+ }
+
+ template <typename Iterator>
+ Iterator find_not_of(Iterator first, Iterator last, basic_string_view s) const BOOST_NOEXCEPT {
+ for (; first != last ; ++first)
+ if ( 0 == traits::find(s.ptr_, s.len_, *first))
+ return first;
+ return last;
+ }
+
+ const charT *ptr_;
+ std::size_t len_;
+ };
+
+
+// Comparison operators
+// Equality
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ if (x.size () != y.size ()) return false;
+ return x.compare(y) == 0;
+ }
+
+// Inequality
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ if ( x.size () != y.size ()) return true;
+ return x.compare(y) != 0;
+ }
+
+// Less than
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return x.compare(y) < 0;
+ }
+
+// Greater than
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return x.compare(y) > 0;
+ }
+
+// Less than or equal to
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return x.compare(y) <= 0;
+ }
+
+// Greater than or equal to
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return x.compare(y) >= 0;
+ }
+
+// "sufficient additional overloads of comparison functions"
+ template<typename charT, typename traits, typename Allocator>
+ inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
+ const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
+ return x == basic_string_view<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline BOOST_CXX14_CONSTEXPR bool operator==(const std::basic_string<charT, traits, Allocator> & x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return basic_string_view<charT, traits>(x) == y;
+ }
+
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
+ const charT * y) BOOST_NOEXCEPT {
+ return x == basic_string_view<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator==(const charT * x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return basic_string_view<charT, traits>(x) == y;
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
+ const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
+ return x != basic_string_view<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline BOOST_CXX14_CONSTEXPR bool operator!=(const std::basic_string<charT, traits, Allocator> & x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return basic_string_view<charT, traits>(x) != y;
+ }
+
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
+ const charT * y) BOOST_NOEXCEPT {
+ return x != basic_string_view<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator!=(const charT * x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return basic_string_view<charT, traits>(x) != y;
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
+ const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
+ return x < basic_string_view<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline BOOST_CXX14_CONSTEXPR bool operator<(const std::basic_string<charT, traits, Allocator> & x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return basic_string_view<charT, traits>(x) < y;
+ }
+
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
+ const charT * y) BOOST_NOEXCEPT {
+ return x < basic_string_view<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator<(const charT * x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return basic_string_view<charT, traits>(x) < y;
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
+ const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
+ return x > basic_string_view<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline BOOST_CXX14_CONSTEXPR bool operator>(const std::basic_string<charT, traits, Allocator> & x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return basic_string_view<charT, traits>(x) > y;
+ }
+
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
+ const charT * y) BOOST_NOEXCEPT {
+ return x > basic_string_view<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator>(const charT * x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return basic_string_view<charT, traits>(x) > y;
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
+ const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
+ return x <= basic_string_view<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline BOOST_CXX14_CONSTEXPR bool operator<=(const std::basic_string<charT, traits, Allocator> & x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return basic_string_view<charT, traits>(x) <= y;
+ }
+
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
+ const charT * y) BOOST_NOEXCEPT {
+ return x <= basic_string_view<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator<=(const charT * x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return basic_string_view<charT, traits>(x) <= y;
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
+ const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
+ return x >= basic_string_view<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits, typename Allocator>
+ inline BOOST_CXX14_CONSTEXPR bool operator>=(const std::basic_string<charT, traits, Allocator> & x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return basic_string_view<charT, traits>(x) >= y;
+ }
+
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
+ const charT * y) BOOST_NOEXCEPT {
+ return x >= basic_string_view<charT, traits>(y);
+ }
+
+ template<typename charT, typename traits>
+ inline BOOST_CXX14_CONSTEXPR bool operator>=(const charT * x,
+ basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
+ return basic_string_view<charT, traits>(x) >= y;
+ }
+
+ namespace detail {
+
+ template<class charT, class traits>
+ inline void sv_insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) {
+ enum { chunk_size = 8 };
+ charT fill_chars[chunk_size];
+ std::fill_n(fill_chars, static_cast< std::size_t >(chunk_size), os.fill());
+ for (; n >= chunk_size && os.good(); n -= chunk_size)
+ os.write(fill_chars, static_cast< std::size_t >(chunk_size));
+ if (n > 0 && os.good())
+ os.write(fill_chars, n);
+ }
+
+ template<class charT, class traits>
+ void sv_insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_view<charT,traits>& str) {
+ const std::size_t size = str.size();
+ const std::size_t alignment_size = static_cast< std::size_t >(os.width()) - size;
+ const bool align_left = (os.flags() & std::basic_ostream<charT, traits>::adjustfield) == std::basic_ostream<charT, traits>::left;
+ if (!align_left) {
+ detail::sv_insert_fill_chars(os, alignment_size);
+ if (os.good())
+ os.write(str.data(), size);
+ }
+ else {
+ os.write(str.data(), size);
+ if (os.good())
+ detail::sv_insert_fill_chars(os, alignment_size);
+ }
+ }
+
+ } // namespace detail
+
+ // Inserter
+ template<class charT, class traits>
+ inline std::basic_ostream<charT, traits>&
+ operator<<(std::basic_ostream<charT, traits>& os,
+ const basic_string_view<charT,traits>& str) {
+ if (os.good()) {
+ const std::size_t size = str.size();
+ const std::size_t w = static_cast< std::size_t >(os.width());
+ if (w <= size)
+ os.write(str.data(), size);
+ else
+ detail::sv_insert_aligned(os, str);
+ os.width(0);
+ }
+ return os;
+ }
+
+#if 0
+ // numeric conversions
+ //
+ // These are short-term implementations.
+ // In a production environment, I would rather avoid the copying.
+ //
+ inline int stoi (string_view str, size_t* idx=0, int base=10) {
+ return std::stoi ( std::string(str), idx, base );
+ }
+
+ inline long stol (string_view str, size_t* idx=0, int base=10) {
+ return std::stol ( std::string(str), idx, base );
+ }
+
+ inline unsigned long stoul (string_view str, size_t* idx=0, int base=10) {
+ return std::stoul ( std::string(str), idx, base );
+ }
+
+ inline long long stoll (string_view str, size_t* idx=0, int base=10) {
+ return std::stoll ( std::string(str), idx, base );
+ }
+
+ inline unsigned long long stoull (string_view str, size_t* idx=0, int base=10) {
+ return std::stoull ( std::string(str), idx, base );
+ }
+
+ inline float stof (string_view str, size_t* idx=0) {
+ return std::stof ( std::string(str), idx );
+ }
+
+ inline double stod (string_view str, size_t* idx=0) {
+ return std::stod ( std::string(str), idx );
+ }
+
+ inline long double stold (string_view str, size_t* idx=0) {
+ return std::stold ( std::string(str), idx );
+ }
+
+ inline int stoi (wstring_view str, size_t* idx=0, int base=10) {
+ return std::stoi ( std::wstring(str), idx, base );
+ }
+
+ inline long stol (wstring_view str, size_t* idx=0, int base=10) {
+ return std::stol ( std::wstring(str), idx, base );
+ }
+
+ inline unsigned long stoul (wstring_view str, size_t* idx=0, int base=10) {
+ return std::stoul ( std::wstring(str), idx, base );
+ }
+
+ inline long long stoll (wstring_view str, size_t* idx=0, int base=10) {
+ return std::stoll ( std::wstring(str), idx, base );
+ }
+
+ inline unsigned long long stoull (wstring_view str, size_t* idx=0, int base=10) {
+ return std::stoull ( std::wstring(str), idx, base );
+ }
+
+ inline float stof (wstring_view str, size_t* idx=0) {
+ return std::stof ( std::wstring(str), idx );
+ }
+
+ inline double stod (wstring_view str, size_t* idx=0) {
+ return std::stod ( std::wstring(str), idx );
+ }
+
+ inline long double stold (wstring_view str, size_t* idx=0) {
+ return std::stold ( std::wstring(str), idx );
+ }
+#endif
+
+}
+
+#if 0
+namespace std {
+ // Hashing
+ template<> struct hash<boost::string_view>;
+ template<> struct hash<boost::u16string_view>;
+ template<> struct hash<boost::u32string_view>;
+ template<> struct hash<boost::wstring_view>;
+}
+#endif
+
+#endif
diff --git a/include/boost/utility/string_view_fwd.hpp b/include/boost/utility/string_view_fwd.hpp
new file mode 100644
index 0000000..dbda0de
--- /dev/null
+++ b/include/boost/utility/string_view_fwd.hpp
@@ -0,0 +1,39 @@
+/*
+ Copyright (c) Marshall Clow 2012-2012.
+
+ 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
+
+ Based on the StringRef implementation in LLVM (http://llvm.org) and
+ N3422 by Jeffrey Yasskin
+ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
+ Updated July 2015 to reflect the Library Fundamentals TS
+ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4480.html
+
+*/
+
+#ifndef BOOST_STRING_VIEW_FWD_HPP
+#define BOOST_STRING_VIEW_FWD_HPP
+
+#include <boost/config.hpp>
+#include <string>
+
+namespace boost {
+
+ template<typename charT, typename traits = std::char_traits<charT> > class basic_string_view;
+ typedef basic_string_view<char, std::char_traits<char> > string_view;
+ typedef basic_string_view<wchar_t, std::char_traits<wchar_t> > wstring_view;
+
+#ifndef BOOST_NO_CXX11_CHAR16_T
+ typedef basic_string_view<char16_t, std::char_traits<char16_t> > u16string_view;
+#endif
+
+#ifndef BOOST_NO_CXX11_CHAR32_T
+ typedef basic_string_view<char32_t, std::char_traits<char32_t> > u32string_view;
+#endif
+
+}
+
+#endif
diff --git a/include/boost/utility/typed_in_place_factory.hpp b/include/boost/utility/typed_in_place_factory.hpp
new file mode 100644
index 0000000..833a346
--- /dev/null
+++ b/include/boost/utility/typed_in_place_factory.hpp
@@ -0,0 +1,77 @@
+// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2007, Tobias Schwinger.
+//
+// Use, modification, and distribution is subject to 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/optional for documentation.
+//
+// You are welcome to contact the author at:
+// fernando_cacciola@hotmail.com
+//
+#ifndef BOOST_UTILITY_TYPED_INPLACE_FACTORY_04APR2007_HPP
+#ifndef BOOST_PP_IS_ITERATING
+
+#include <boost/utility/detail/in_place_factory_prefix.hpp>
+
+namespace boost {
+
+class typed_in_place_factory_base {} ;
+
+#define BOOST_PP_ITERATION_LIMITS (0, BOOST_MAX_INPLACE_FACTORY_ARITY)
+#define BOOST_PP_FILENAME_1 <boost/utility/typed_in_place_factory.hpp>
+#include BOOST_PP_ITERATE()
+
+} // namespace boost
+
+#include <boost/utility/detail/in_place_factory_suffix.hpp>
+
+#define BOOST_UTILITY_TYPED_INPLACE_FACTORY_04APR2007_HPP
+#else
+#define N BOOST_PP_ITERATION()
+
+template< class T BOOST_PP_ENUM_TRAILING_PARAMS(N,class A) >
+class BOOST_PP_CAT(typed_in_place_factory,N)
+ :
+ public typed_in_place_factory_base
+{
+public:
+
+ typedef T value_type;
+
+ explicit BOOST_PP_CAT(typed_in_place_factory,N)
+ ( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
+#if N > 0
+ : BOOST_PP_ENUM(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _)
+#endif
+ {}
+
+ void* apply (void* address) const
+ {
+ return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) );
+ }
+
+ void* apply (void* address, std::size_t n) const
+ {
+ for(void* next = address = this->apply(address); !! --n;)
+ this->apply(next = static_cast<char *>(next) + sizeof(T));
+ return address;
+ }
+
+ BOOST_PP_REPEAT(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _)
+};
+
+template< class T BOOST_PP_ENUM_TRAILING_PARAMS(N, class A) >
+inline BOOST_PP_CAT(typed_in_place_factory,N)<
+ T BOOST_PP_ENUM_TRAILING_PARAMS(N, A) >
+in_place( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
+{
+ return BOOST_PP_CAT(typed_in_place_factory,N)<
+ T BOOST_PP_ENUM_TRAILING_PARAMS(N, A) >( BOOST_PP_ENUM_PARAMS(N, a) );
+}
+
+#undef N
+#endif
+#endif
+
diff --git a/include/boost/utility/value_init.hpp b/include/boost/utility/value_init.hpp
new file mode 100644
index 0000000..9d8de70
--- /dev/null
+++ b/include/boost/utility/value_init.hpp
@@ -0,0 +1,281 @@
+// (C) Copyright 2002-2008, Fernando Luis Cacciola Carballal.
+//
+// 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)
+//
+// 21 Ago 2002 (Created) Fernando Cacciola
+// 24 Dec 2007 (Refactored and worked around various compiler bugs) Fernando Cacciola, Niels Dekker
+// 23 May 2008 (Fixed operator= const issue, added initialized_value) Niels Dekker, Fernando Cacciola
+// 21 Ago 2008 (Added swap) Niels Dekker, Fernando Cacciola
+// 20 Feb 2009 (Fixed logical const-ness issues) Niels Dekker, Fernando Cacciola
+// 03 Apr 2010 (Added initialized<T>, suggested by Jeffrey Hellrung, fixing #3472) Niels Dekker
+// 30 May 2010 (Made memset call conditional, fixing #3869) Niels Dekker
+//
+#ifndef BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
+#define BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
+
+// Note: The implementation of boost::value_initialized had to deal with the
+// fact that various compilers haven't fully implemented value-initialization.
+// The constructor of boost::value_initialized<T> works around these compiler
+// issues, by clearing the bytes of T, before constructing the T object it
+// contains. More details on these issues are at libs/utility/value_init.htm
+
+#include <boost/aligned_storage.hpp>
+#include <boost/config.hpp> // For BOOST_NO_COMPLETE_VALUE_INITIALIZATION.
+#include <boost/detail/workaround.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/cv_traits.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/swap.hpp>
+#include <cstring>
+#include <new>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+// It is safe to ignore the following warning from MSVC 7.1 or higher:
+// "warning C4351: new behavior: elements of array will be default initialized"
+#pragma warning(disable: 4351)
+// It is safe to ignore the following MSVC warning, which may pop up when T is
+// a const type: "warning C4512: assignment operator could not be generated".
+#pragma warning(disable: 4512)
+#endif
+
+#ifdef BOOST_NO_COMPLETE_VALUE_INITIALIZATION
+ // Implementation detail: The macro BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
+ // suggests that a workaround should be applied, because of compiler issues
+ // regarding value-initialization.
+ #define BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
+#endif
+
+// Implementation detail: The macro BOOST_DETAIL_VALUE_INIT_WORKAROUND
+// switches the value-initialization workaround either on or off.
+#ifndef BOOST_DETAIL_VALUE_INIT_WORKAROUND
+ #ifdef BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
+ #define BOOST_DETAIL_VALUE_INIT_WORKAROUND 1
+ #else
+ #define BOOST_DETAIL_VALUE_INIT_WORKAROUND 0
+ #endif
+#endif
+
+namespace boost {
+
+template<class T>
+class initialized
+{
+ private :
+ struct wrapper
+ {
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+ typename
+#endif
+ remove_const<T>::type data;
+
+ BOOST_GPU_ENABLED
+ wrapper()
+ :
+ data()
+ {
+ }
+
+ BOOST_GPU_ENABLED
+ wrapper(T const & arg)
+ :
+ data(arg)
+ {
+ }
+ };
+
+ mutable
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+ typename
+#endif
+ aligned_storage<sizeof(wrapper), alignment_of<wrapper>::value>::type x;
+
+ BOOST_GPU_ENABLED
+ wrapper * wrapper_address() const
+ {
+ return static_cast<wrapper *>( static_cast<void*>(&x));
+ }
+
+ public :
+
+ BOOST_GPU_ENABLED
+ initialized()
+ {
+#if BOOST_DETAIL_VALUE_INIT_WORKAROUND
+ std::memset(&x, 0, sizeof(x));
+#endif
+ new (wrapper_address()) wrapper();
+ }
+
+ BOOST_GPU_ENABLED
+ initialized(initialized const & arg)
+ {
+ new (wrapper_address()) wrapper( static_cast<wrapper const &>(*(arg.wrapper_address())));
+ }
+
+ BOOST_GPU_ENABLED
+ explicit initialized(T const & arg)
+ {
+ new (wrapper_address()) wrapper(arg);
+ }
+
+ BOOST_GPU_ENABLED
+ initialized & operator=(initialized const & arg)
+ {
+ // Assignment is only allowed when T is non-const.
+ BOOST_STATIC_ASSERT( ! is_const<T>::value );
+ *wrapper_address() = static_cast<wrapper const &>(*(arg.wrapper_address()));
+ return *this;
+ }
+
+ BOOST_GPU_ENABLED
+ ~initialized()
+ {
+ wrapper_address()->wrapper::~wrapper();
+ }
+
+ BOOST_GPU_ENABLED
+ T const & data() const
+ {
+ return wrapper_address()->data;
+ }
+
+ BOOST_GPU_ENABLED
+ T& data()
+ {
+ return wrapper_address()->data;
+ }
+
+ BOOST_GPU_ENABLED
+ void swap(initialized & arg)
+ {
+ ::boost::swap( this->data(), arg.data() );
+ }
+
+ BOOST_GPU_ENABLED
+ operator T const &() const
+ {
+ return wrapper_address()->data;
+ }
+
+ BOOST_GPU_ENABLED
+ operator T&()
+ {
+ return wrapper_address()->data;
+ }
+
+} ;
+
+template<class T>
+BOOST_GPU_ENABLED
+T const& get ( initialized<T> const& x )
+{
+ return x.data() ;
+}
+
+template<class T>
+BOOST_GPU_ENABLED
+T& get ( initialized<T>& x )
+{
+ return x.data() ;
+}
+
+template<class T>
+BOOST_GPU_ENABLED
+void swap ( initialized<T> & lhs, initialized<T> & rhs )
+{
+ lhs.swap(rhs) ;
+}
+
+template<class T>
+class value_initialized
+{
+ private :
+
+ // initialized<T> does value-initialization by default.
+ initialized<T> m_data;
+
+ public :
+
+ BOOST_GPU_ENABLED
+ value_initialized()
+ :
+ m_data()
+ { }
+
+ BOOST_GPU_ENABLED
+ T const & data() const
+ {
+ return m_data.data();
+ }
+
+ BOOST_GPU_ENABLED
+ T& data()
+ {
+ return m_data.data();
+ }
+
+ BOOST_GPU_ENABLED
+ void swap(value_initialized & arg)
+ {
+ m_data.swap(arg.m_data);
+ }
+
+ BOOST_GPU_ENABLED
+ operator T const &() const
+ {
+ return m_data;
+ }
+
+ BOOST_GPU_ENABLED
+ operator T&()
+ {
+ return m_data;
+ }
+} ;
+
+
+template<class T>
+BOOST_GPU_ENABLED
+T const& get ( value_initialized<T> const& x )
+{
+ return x.data() ;
+}
+
+template<class T>
+BOOST_GPU_ENABLED
+T& get ( value_initialized<T>& x )
+{
+ return x.data() ;
+}
+
+template<class T>
+BOOST_GPU_ENABLED
+void swap ( value_initialized<T> & lhs, value_initialized<T> & rhs )
+{
+ lhs.swap(rhs) ;
+}
+
+
+class initialized_value_t
+{
+ public :
+
+ template <class T> BOOST_GPU_ENABLED operator T() const
+ {
+ return initialized<T>().data();
+ }
+};
+
+initialized_value_t const initialized_value = {} ;
+
+
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif