<pre style='margin:0'>
Christopher Nielsen (mascguy) pushed a commit to branch master
in repository macports-ports.

</pre>
<p><a href="https://github.com/macports/macports-ports/commit/84cbbe27a97fc1068aaa75ef9e9ba6a155457ded">https://github.com/macports/macports-ports/commit/84cbbe27a97fc1068aaa75ef9e9ba6a155457ded</a></p>
<pre style="white-space: pre; background: #F8F8F8"><span style='display:block; white-space:pre;color:#808000;'>commit 84cbbe27a97fc1068aaa75ef9e9ba6a155457ded
</span>Author: Christopher Chavez <chrischavez@gmx.us>
AuthorDate: Fri Jul 22 07:24:36 2022 -0500

<span style='display:block; white-space:pre;color:#404040;'>    qt(59|511)-qtlocation: fix build for Xcode ≥ 11
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    Fixes: https://trac.macports.org/ticket/61031
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    [skip ci]
</span>---
 aqua/qt511/Portfile                                |    9 +
 aqua/qt511/files/optional.hpp                      | 1066 ++++++++++++++++++++
 .../files/patch-qtlocation-mbgl-optional.diff      |   13 +
 aqua/qt59/Portfile                                 |   13 +
 aqua/qt59/files/optional.hpp                       | 1066 ++++++++++++++++++++
 .../qt59/files/patch-qtlocation-mbgl-optional.diff |   11 +
 aqua/qt59/files/patch-qtlocation-mbgl-tileset.diff |   24 +
 7 files changed, 2202 insertions(+)

<span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt511/Portfile b/aqua/qt511/Portfile
</span><span style='display:block; white-space:pre;color:#808080;'>index 0263b2dbd3a..8409a3dfc52 100644
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>--- a/aqua/qt511/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt511/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -1379,6 +1379,15 @@ foreach {module module_info} [array get modules] {
</span>                     }
                 }
 
<span style='display:block; white-space:pre;background:#e0ffe0;'>+                # see https://trac.macports.org/ticket/61031
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                patchfiles-append patch-qtlocation-mbgl-optional.diff
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                post-patch {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                    set experimental_dir \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                        ${worksrcpath}/src/3rdparty/mapbox-gl-native/deps/optional/f5b56b71/include/experimental/
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                    file mkdir ${experimental_dir}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                    copy ${filespath}/optional.hpp ${experimental_dir}/optional
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span>                 # std::auto_ptr was removed in C++17
                 # see https://bugreports.qt.io/browse/QTBUG-64441
                 configure.args-append DEFINES+=BOOST_NO_AUTO_PTR
<span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt511/files/optional.hpp b/aqua/qt511/files/optional.hpp
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 00000000000..d01b089c032
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt511/files/optional.hpp
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,1066 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// Copyright (C) 2011 - 2012 Andrzej Krzemienski.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+//
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// Use, modification, and distribution is subject to the Boost Software
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// http://www.boost.org/LICENSE_1_0.txt)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+//
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// The idea and interface is based on Boost.Optional library
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// authored by Fernando Luis Cacciola Carballal
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# ifndef ___OPTIONAL_HPP___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# define ___OPTIONAL_HPP___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# include <utility>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# include <type_traits>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# include <initializer_list>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# include <cassert>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# include <functional>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# include <string>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# include <stdexcept>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# define TR2_OPTIONAL_REQUIRES(...) typename enable_if<__VA_ARGS__::value, bool>::type = false
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if defined __GNUC__ // NOTE: GNUC is also defined for Clang
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   elif (__GNUC__ > 4)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   elif (__GNUC__ > 4)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if (__GNUC__ == 4) && (__GNUC_MINOR__ == 8) && (__GNUC_PATCHLEVEL__ >= 1)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   elif (__GNUC__ > 4)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if defined __clang_major__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if (__clang_major__ == 3 && __clang_minor__ >= 5)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   elif (__clang_major__ > 3)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   elif (__clang_major__ == 3 && __clang_minor__ == 4 && __clang_patchlevel__ >= 2)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if defined _MSC_VER
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if (_MSC_VER >= 1900)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if defined __clang__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if (__clang_major__ > 2) || (__clang_major__ == 2) && (__clang_minor__ >= 9)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define OPTIONAL_HAS_THIS_RVALUE_REFS 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define OPTIONAL_HAS_THIS_RVALUE_REFS 0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_HAS_THIS_RVALUE_REFS 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_HAS_THIS_RVALUE_REFS 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_HAS_THIS_RVALUE_REFS 0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_CONSTEXPR_INIT_LIST constexpr
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_CONSTEXPR_INIT_LIST
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ && (defined __cplusplus) && (__cplusplus != 201103L)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_HAS_MOVE_ACCESSORS 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_HAS_MOVE_ACCESSORS 0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// In C++11 constexpr implies const, so we need to make non-const members also non-constexpr
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if (defined __cplusplus) && (__cplusplus == 201103L)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_MUTABLE_CONSTEXPR
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_MUTABLE_CONSTEXPR constexpr
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+namespace std{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+namespace experimental{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// BEGIN workaround for missing is_trivially_destructible
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if defined TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it: it is already there
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it: it is already there
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it: it is already there
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it: the user doesn't want it
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   template <typename T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   using is_trivially_destructible = std::has_trivial_destructor<T>;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// END workaround for missing is_trivially_destructible
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if (defined TR2_OPTIONAL_GCC_4_7_AND_HIGHER___)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it; our metafunctions are already defined.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it; our metafunctions are already defined.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it: it is already there
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it: the user doesn't want it
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// workaround for missing traits in GCC and CLANG
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+struct is_nothrow_move_constructible
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool value = std::is_nothrow_constructible<T, T&&>::value;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T, class U>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+struct is_assignable
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class X, class Y>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool has_assign(...) { return false; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class X, class Y, size_t S = sizeof((std::declval<X>() = std::declval<Y>(), true)) >
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // the comma operator is necessary for the cases where operator= returns void
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool has_assign(bool) { return true; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool value = has_assign<T, U>(true);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+struct is_nothrow_move_assignable
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class X, bool has_any_move_assign>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  struct has_nothrow_move_assign {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr static bool value = false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class X>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  struct has_nothrow_move_assign<X, true> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr static bool value = noexcept( std::declval<X&>() = std::declval<X&&>() );
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool value = has_nothrow_move_assign<T, is_assignable<T&, T&&>::value>::value;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// end workaround
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.4, optional for object types
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> class optional;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.5, optional for lvalue reference types
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> class optional<T&>;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// workaround: std utility functions aren't constexpr yet
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type& t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return static_cast<T&&>(t);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type&& t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    static_assert(!std::is_lvalue_reference<T>::value, "!!");
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return static_cast<T&&>(t);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> inline constexpr typename std::remove_reference<T>::type&& constexpr_move(T&& t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return static_cast<typename std::remove_reference<T>::type&&>(t);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#if defined NDEBUG
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) (EXPR)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) ((CHECK) ? (EXPR) : ([]{assert(!#CHECK);}(), (EXPR)))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+namespace detail_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// static_addressof: a constexpr version of addressof
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <typename T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+struct has_overloaded_addressof
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class X>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool has_overload(...) { return false; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class X, size_t S = sizeof(std::declval<X&>().operator&()) >
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool has_overload(bool) { return true; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool value = has_overload<T>(true);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <typename T, TR2_OPTIONAL_REQUIRES(!has_overloaded_addressof<T>)>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+constexpr T* static_addressof(T& ref)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return &ref;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <typename T, TR2_OPTIONAL_REQUIRES(has_overloaded_addressof<T>)>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+T* static_addressof(T& ref)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return std::addressof(ref);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// the call to convert<A>(b) has return type A and converts b to type A iff b decltype(b) is implicitly convertible to A  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class U>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+constexpr U convert(U v) { return v; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+namespace swap_ns
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  using std::swap;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void adl_swap(T& t, T& u) noexcept(noexcept(swap(t, u)))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    swap(t, u);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+} // namespace swap_ns
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+} // namespace detail
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+constexpr struct trivial_init_t{} trivial_init{};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.6, In-place construction
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+constexpr struct in_place_t{} in_place{};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.7, Disengaged state indicator
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+struct nullopt_t
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  struct init{};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr explicit nullopt_t(init){}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+constexpr nullopt_t nullopt{nullopt_t::init()};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.8, class bad_optional_access
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+class bad_optional_access : public logic_error {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  explicit bad_optional_access(const string& what_arg) : logic_error{what_arg} {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  explicit bad_optional_access(const char* what_arg) : logic_error{what_arg} {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+union storage_t
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  unsigned char dummy_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T value_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr storage_t( trivial_init_t ) noexcept : dummy_() {};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class... Args>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr storage_t( Args&&... args ) : value_(constexpr_forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ~storage_t(){}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+union constexpr_storage_t
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    unsigned char dummy_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    T value_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr constexpr_storage_t( trivial_init_t ) noexcept : dummy_() {};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    template <class... Args>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr constexpr_storage_t( Args&&... args ) : value_(constexpr_forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ~constexpr_storage_t() = default;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+struct optional_base
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    bool init_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    storage_t<T> storage_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr optional_base() noexcept : init_(false), storage_(trivial_init) {};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    explicit constexpr optional_base(const T& v) : init_(true), storage_(v) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    explicit constexpr optional_base(T&& v) : init_(true), storage_(constexpr_move(v)) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    template <class... Args> explicit optional_base(in_place_t, Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        : init_(true), storage_(constexpr_forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    explicit optional_base(in_place_t, std::initializer_list<U> il, Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        : init_(true), storage_(il, std::forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ~optional_base() { if (init_) storage_.value_.T::~T(); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+struct constexpr_optional_base
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    bool init_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr_storage_t<T> storage_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr constexpr_optional_base() noexcept : init_(false), storage_(trivial_init) {};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    explicit constexpr constexpr_optional_base(const T& v) : init_(true), storage_(v) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    explicit constexpr constexpr_optional_base(T&& v) : init_(true), storage_(constexpr_move(v)) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    template <class... Args> explicit constexpr constexpr_optional_base(in_place_t, Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      : init_(true), storage_(constexpr_forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    OPTIONAL_CONSTEXPR_INIT_LIST explicit constexpr_optional_base(in_place_t, std::initializer_list<U> il, Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      : init_(true), storage_(il, std::forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ~constexpr_optional_base() = default;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+using OptionalBase = typename std::conditional<
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    is_trivially_destructible<T>::value,                          // if possible
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr_optional_base<typename std::remove_const<T>::type>, // use base with trivial destructor
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    optional_base<typename std::remove_const<T>::type>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+>::type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+class optional : private OptionalBase<T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  static_assert( !std::is_same<typename std::decay<T>::type, nullopt_t>::value, "bad T" );
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  static_assert( !std::is_same<typename std::decay<T>::type, in_place_t>::value, "bad T" );
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr bool initialized() const noexcept { return OptionalBase<T>::init_; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  typename std::remove_const<T>::type* dataptr() {  return std::addressof(OptionalBase<T>::storage_.value_); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr const T* dataptr() const { return detail_::static_addressof(OptionalBase<T>::storage_.value_); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr const T& contained_val() const& { return OptionalBase<T>::storage_.value_; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if OPTIONAL_HAS_MOVE_ACCESSORS == 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T&& contained_val() && { return std::move(OptionalBase<T>::storage_.value_); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T& contained_val() & { return OptionalBase<T>::storage_.value_; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T& contained_val() & { return OptionalBase<T>::storage_.value_; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T&& contained_val() && { return std::move(OptionalBase<T>::storage_.value_); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr const T& contained_val() const { return OptionalBase<T>::storage_.value_; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T& contained_val() { return OptionalBase<T>::storage_.value_; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void clear() noexcept {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (initialized()) dataptr()->T::~T();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    OptionalBase<T>::init_ = false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class... Args>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void initialize(Args&&... args) noexcept(noexcept(T(std::forward<Args>(args)...)))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    assert(!OptionalBase<T>::init_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ::new (static_cast<void*>(dataptr())) T(std::forward<Args>(args)...);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    OptionalBase<T>::init_ = true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class U, class... Args>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void initialize(std::initializer_list<U> il, Args&&... args) noexcept(noexcept(T(il, std::forward<Args>(args)...)))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    assert(!OptionalBase<T>::init_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ::new (static_cast<void*>(dataptr())) T(il, std::forward<Args>(args)...);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    OptionalBase<T>::init_ = true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  typedef T value_type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.5.1, constructors
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional() noexcept : OptionalBase<T>()  {};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional(nullopt_t) noexcept : OptionalBase<T>() {};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  optional(const optional& rhs)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  : OptionalBase<T>()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (rhs.initialized()) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        ::new (static_cast<void*>(dataptr())) T(*rhs);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        OptionalBase<T>::init_ = true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  optional(optional&& rhs) noexcept(is_nothrow_move_constructible<T>::value)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  : OptionalBase<T>()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (rhs.initialized()) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        ::new (static_cast<void*>(dataptr())) T(std::move(*rhs));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        OptionalBase<T>::init_ = true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional(const T& v) : OptionalBase<T>(v) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional(T&& v) : OptionalBase<T>(constexpr_move(v)) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class... Args>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  explicit constexpr optional(in_place_t, Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  : OptionalBase<T>(in_place_t{}, constexpr_forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_CONSTEXPR_INIT_LIST explicit optional(in_place_t, std::initializer_list<U> il, Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  : OptionalBase<T>(in_place_t{}, il, constexpr_forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.4.2, Destructor
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ~optional() = default;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.4.3, assignment
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  optional& operator=(nullopt_t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    clear();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  optional& operator=(const optional& rhs)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if      (initialized() == true  && rhs.initialized() == false) clear();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    else if (initialized() == false && rhs.initialized() == true)  initialize(*rhs);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    else if (initialized() == true  && rhs.initialized() == true)  contained_val() = *rhs;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  optional& operator=(optional&& rhs)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  noexcept(is_nothrow_move_assignable<T>::value && is_nothrow_move_constructible<T>::value)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if      (initialized() == true  && rhs.initialized() == false) clear();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    else if (initialized() == false && rhs.initialized() == true)  initialize(std::move(*rhs));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    else if (initialized() == true  && rhs.initialized() == true)  contained_val() = std::move(*rhs);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class U>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  auto operator=(U&& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  -> typename enable_if
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  <
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    is_same<typename decay<U>::type, T>::value,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    optional&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  >::type
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (initialized()) { contained_val() = std::forward<U>(v); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    else               { initialize(std::forward<U>(v));  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class... Args>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void emplace(Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    clear();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    initialize(std::forward<Args>(args)...);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class U, class... Args>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void emplace(initializer_list<U> il, Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    clear();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    initialize<U, Args...>(il, std::forward<Args>(args)...);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.4.4, Swap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void swap(optional<T>& rhs) noexcept(is_nothrow_move_constructible<T>::value
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                                       && noexcept(detail_::swap_ns::adl_swap(declval<T&>(), declval<T&>())))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if      (initialized() == true  && rhs.initialized() == false) { rhs.initialize(std::move(**this)); clear(); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    else if (initialized() == false && rhs.initialized() == true)  { initialize(std::move(*rhs)); rhs.clear(); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    else if (initialized() == true  && rhs.initialized() == true)  { using std::swap; swap(**this, *rhs); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.4.5, Observers
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  explicit constexpr operator bool() const noexcept { return initialized(); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr bool has_value() const noexcept { return initialized(); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T const* operator ->() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), dataptr());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if OPTIONAL_HAS_MOVE_ACCESSORS == 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T* operator ->() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    assert (initialized());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return dataptr();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T const& operator *() const& {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T& operator *() & {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    assert (initialized());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return contained_val();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T&& operator *() && {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    assert (initialized());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return constexpr_move(contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T const& value() const& {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T& value() & {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T&& value() && {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (!initialized()) throw bad_optional_access("bad optional access");
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return std::move(contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T* operator ->() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    assert (initialized());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return dataptr();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T const& operator *() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T& operator *() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    assert (initialized());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return contained_val();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T const& value() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T& value() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class V>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T value_or(V&& v) const&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if OPTIONAL_HAS_MOVE_ACCESSORS == 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class V>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T value_or(V&& v) &&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class V>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T value_or(V&& v) &&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class V>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T value_or(V&& v) const
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.6.3.6, modifiers
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void reset() noexcept { clear(); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+class optional<T&>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  static_assert( !std::is_same<T, nullopt_t>::value, "bad T" );
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  static_assert( !std::is_same<T, in_place_t>::value, "bad T" );
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T* ref;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.5.1, construction/destruction
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional() noexcept : ref(nullptr) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional(nullopt_t) noexcept : ref(nullptr) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional(T& v) noexcept : ref(detail_::static_addressof(v)) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  optional(T&&) = delete;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional(const optional& rhs) noexcept : ref(rhs.ref) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  explicit constexpr optional(in_place_t, T& v) noexcept : ref(detail_::static_addressof(v)) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  explicit optional(in_place_t, T&&) = delete;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ~optional() = default;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.5.2, mutation
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  optional& operator=(nullopt_t) noexcept {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ref = nullptr;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // optional& operator=(const optional& rhs) noexcept {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // ref = rhs.ref;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // optional& operator=(optional&& rhs) noexcept {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // ref = rhs.ref;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <typename U>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  auto operator=(U&& rhs) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  -> typename enable_if
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  <
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    is_same<typename decay<U>::type, optional<T&>>::value,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    optional&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  >::type
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ref = rhs.ref;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <typename U>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  auto operator=(U&& rhs) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  -> typename enable_if
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  <
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    !is_same<typename decay<U>::type, optional<T&>>::value,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    optional&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  >::type
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  = delete;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void emplace(T& v) noexcept {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ref = detail_::static_addressof(v);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void emplace(T&&) = delete;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void swap(optional<T&>& rhs) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    std::swap(ref, rhs.ref);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.5.3, observers
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T* operator->() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, ref);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T& operator*() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, *ref);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T& value() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return ref ? *ref : (throw bad_optional_access("bad optional access"), *ref);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  explicit constexpr operator bool() const noexcept {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return ref != nullptr;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr bool has_value() const noexcept {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return ref != nullptr;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class V>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr typename decay<T>::type value_or(V&& v) const
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this ? **this : detail_::convert<typename decay<T>::type>(constexpr_forward<V>(v));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // x.x.x.x, modifiers
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void reset() noexcept { ref = nullptr; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+class optional<T&&>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  static_assert( sizeof(T) == 0, "optional rvalue references disallowed" );
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.8, Relational operators
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const optional<T>& x, const optional<T>& y)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) != bool(y) ? false : bool(x) == false ? true : *x == *y;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const optional<T>& x, const optional<T>& y)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return !(x == y);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const optional<T>& x, const optional<T>& y)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return (!y) ? false : (!x) ? true : *x < *y;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const optional<T>& x, const optional<T>& y)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return (y < x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const optional<T>& x, const optional<T>& y)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return !(y < x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const optional<T>& x, const optional<T>& y)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return !(x < y);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.9, Comparison with nullopt
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return (!x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return (!x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return (!x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return (!x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.10, Comparison with T
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const optional<T>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x == v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const T& v, const optional<T>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v == *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const optional<T>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x != v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const T& v, const optional<T>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v != *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const optional<T>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x < v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const T& v, const optional<T>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v > *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const optional<T>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x > v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const T& v, const optional<T>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v < *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const optional<T>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x >= v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const T& v, const optional<T>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v <= *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const optional<T>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x <= v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const T& v, const optional<T>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v >= *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// Comparison of optional<T&> with T
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const optional<T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x == v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const T& v, const optional<T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v == *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const optional<T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x != v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const T& v, const optional<T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v != *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const optional<T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x < v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const T& v, const optional<T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v > *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const optional<T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x > v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const T& v, const optional<T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v < *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const optional<T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x >= v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const T& v, const optional<T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v <= *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const optional<T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x <= v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const T& v, const optional<T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v >= *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// Comparison of optional<T const&> with T
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const optional<const T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x == v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const T& v, const optional<const T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v == *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const optional<const T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x != v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const T& v, const optional<const T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v != *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const optional<const T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x < v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const T& v, const optional<const T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v > *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const optional<const T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x > v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const T& v, const optional<const T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v < *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const optional<const T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x >= v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const T& v, const optional<const T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v <= *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const optional<const T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x <= v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const T& v, const optional<const T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v >= *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.12, Specialized algorithms
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y)))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  x.swap(y);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+constexpr optional<typename decay<T>::type> make_optional(T&& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return optional<typename decay<T>::type>(constexpr_forward<T>(v));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class X>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+constexpr optional<X&> make_optional(reference_wrapper<X> v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return optional<X&>(v.get());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+} // namespace experimental
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+} // namespace std
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+namespace std
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <typename T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  struct hash<std::experimental::optional<T>>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    typedef typename hash<T>::result_type result_type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    typedef std::experimental::optional<T> argument_type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr result_type operator()(argument_type const& arg) const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      return arg ? std::hash<T>{}(*arg) : result_type{};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <typename T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  struct hash<std::experimental::optional<T&>>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    typedef typename hash<T>::result_type result_type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    typedef std::experimental::optional<T&> argument_type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr result_type operator()(argument_type const& arg) const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      return arg ? std::hash<T>{}(*arg) : result_type{};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# undef TR2_OPTIONAL_REQUIRES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# undef TR2_OPTIONAL_ASSERTED_EXPRESSION
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif //___OPTIONAL_HPP___
</span><span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt511/files/patch-qtlocation-mbgl-optional.diff b/aqua/qt511/files/patch-qtlocation-mbgl-optional.diff
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 00000000000..fb7f41dde1a
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt511/files/patch-qtlocation-mbgl-optional.diff
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,13 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- src/3rdparty/mapbox-gl-native/mapbox-gl-native.pro.orig
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ src/3rdparty/mapbox-gl-native/mapbox-gl-native.pro
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -402,8 +402,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     deps/geometry/0.9.2/include \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     deps/kdbush/0.1.1-1 \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     deps/kdbush/0.1.1-1/include \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-    deps/optional/f27e7908 \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-    deps/optional/f27e7908/include \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    deps/optional/f5b56b71 \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    deps/optional/f5b56b71/include \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     deps/pixelmatch/0.10.0 \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     deps/pixelmatch/0.10.0/include \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     deps/polylabel/1.0.3 \
</span><span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt59/Portfile b/aqua/qt59/Portfile
</span><span style='display:block; white-space:pre;color:#808080;'>index f97a32423d8..1ff5d29f01e 100644
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>--- a/aqua/qt59/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt59/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -1374,6 +1374,19 @@ foreach {module module_info} [array get modules] {
</span>                 # see https://bugreports.qt.io/browse/QTBUG-67810
                 patchfiles-append patch-qtlocation-no-cxx17.diff
 
<span style='display:block; white-space:pre;background:#e0ffe0;'>+                # see https://trac.macports.org/ticket/61031
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                patchfiles-append patch-qtlocation-mbgl-optional.diff
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                post-patch {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                    set experimental_dir \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                        ${worksrcpath}/src/3rdparty/mapbox-gl-native/deps/optional/f5b56b71/include/experimental/
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                    file mkdir ${experimental_dir}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                    copy ${filespath}/optional.hpp ${experimental_dir}/optional
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # error: invalid operands to binary expression ('const mbgl::Tileset' and 'const mbgl::Tileset')
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                #    return bool(x) ? *x != v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                #                     ~~ ^  ~
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                patchfiles-append patch-qtlocation-mbgl-tileset.diff
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span>                 # avoid unnecessary dependency on OpenSSL
                 configure.args-append "QMAKE_LIBS_OPENSSL="
             }
<span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt59/files/optional.hpp b/aqua/qt59/files/optional.hpp
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 00000000000..d01b089c032
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt59/files/optional.hpp
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,1066 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// Copyright (C) 2011 - 2012 Andrzej Krzemienski.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+//
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// Use, modification, and distribution is subject to the Boost Software
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// http://www.boost.org/LICENSE_1_0.txt)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+//
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// The idea and interface is based on Boost.Optional library
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// authored by Fernando Luis Cacciola Carballal
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# ifndef ___OPTIONAL_HPP___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# define ___OPTIONAL_HPP___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# include <utility>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# include <type_traits>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# include <initializer_list>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# include <cassert>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# include <functional>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# include <string>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# include <stdexcept>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# define TR2_OPTIONAL_REQUIRES(...) typename enable_if<__VA_ARGS__::value, bool>::type = false
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if defined __GNUC__ // NOTE: GNUC is also defined for Clang
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   elif (__GNUC__ > 4)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   elif (__GNUC__ > 4)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if (__GNUC__ == 4) && (__GNUC_MINOR__ == 8) && (__GNUC_PATCHLEVEL__ >= 1)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   elif (__GNUC__ > 4)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if defined __clang_major__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if (__clang_major__ == 3 && __clang_minor__ >= 5)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   elif (__clang_major__ > 3)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   elif (__clang_major__ == 3 && __clang_minor__ == 4 && __clang_patchlevel__ >= 2)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if defined _MSC_VER
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if (_MSC_VER >= 1900)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if defined __clang__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if (__clang_major__ > 2) || (__clang_major__ == 2) && (__clang_minor__ >= 9)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define OPTIONAL_HAS_THIS_RVALUE_REFS 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#     define OPTIONAL_HAS_THIS_RVALUE_REFS 0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_HAS_THIS_RVALUE_REFS 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_HAS_THIS_RVALUE_REFS 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_HAS_THIS_RVALUE_REFS 0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_CONSTEXPR_INIT_LIST constexpr
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_CONSTEXPR_INIT_LIST
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ && (defined __cplusplus) && (__cplusplus != 201103L)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_HAS_MOVE_ACCESSORS 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_HAS_MOVE_ACCESSORS 0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// In C++11 constexpr implies const, so we need to make non-const members also non-constexpr
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if (defined __cplusplus) && (__cplusplus == 201103L)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_MUTABLE_CONSTEXPR
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   define OPTIONAL_MUTABLE_CONSTEXPR constexpr
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+namespace std{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+namespace experimental{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// BEGIN workaround for missing is_trivially_destructible
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if defined TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it: it is already there
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it: it is already there
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it: it is already there
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it: the user doesn't want it
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   template <typename T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   using is_trivially_destructible = std::has_trivial_destructor<T>;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// END workaround for missing is_trivially_destructible
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if (defined TR2_OPTIONAL_GCC_4_7_AND_HIGHER___)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it; our metafunctions are already defined.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it; our metafunctions are already defined.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it: it is already there
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // leave it: the user doesn't want it
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// workaround for missing traits in GCC and CLANG
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+struct is_nothrow_move_constructible
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool value = std::is_nothrow_constructible<T, T&&>::value;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T, class U>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+struct is_assignable
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class X, class Y>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool has_assign(...) { return false; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class X, class Y, size_t S = sizeof((std::declval<X>() = std::declval<Y>(), true)) >
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // the comma operator is necessary for the cases where operator= returns void
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool has_assign(bool) { return true; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool value = has_assign<T, U>(true);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+struct is_nothrow_move_assignable
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class X, bool has_any_move_assign>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  struct has_nothrow_move_assign {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr static bool value = false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class X>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  struct has_nothrow_move_assign<X, true> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr static bool value = noexcept( std::declval<X&>() = std::declval<X&&>() );
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool value = has_nothrow_move_assign<T, is_assignable<T&, T&&>::value>::value;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// end workaround
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.4, optional for object types
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> class optional;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.5, optional for lvalue reference types
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> class optional<T&>;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// workaround: std utility functions aren't constexpr yet
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type& t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return static_cast<T&&>(t);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type&& t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    static_assert(!std::is_lvalue_reference<T>::value, "!!");
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return static_cast<T&&>(t);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> inline constexpr typename std::remove_reference<T>::type&& constexpr_move(T&& t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return static_cast<typename std::remove_reference<T>::type&&>(t);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#if defined NDEBUG
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) (EXPR)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) ((CHECK) ? (EXPR) : ([]{assert(!#CHECK);}(), (EXPR)))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+namespace detail_
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// static_addressof: a constexpr version of addressof
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <typename T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+struct has_overloaded_addressof
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class X>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool has_overload(...) { return false; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class X, size_t S = sizeof(std::declval<X&>().operator&()) >
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool has_overload(bool) { return true; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr static bool value = has_overload<T>(true);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <typename T, TR2_OPTIONAL_REQUIRES(!has_overloaded_addressof<T>)>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+constexpr T* static_addressof(T& ref)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return &ref;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <typename T, TR2_OPTIONAL_REQUIRES(has_overloaded_addressof<T>)>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+T* static_addressof(T& ref)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return std::addressof(ref);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// the call to convert<A>(b) has return type A and converts b to type A iff b decltype(b) is implicitly convertible to A  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class U>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+constexpr U convert(U v) { return v; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+namespace swap_ns
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  using std::swap;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void adl_swap(T& t, T& u) noexcept(noexcept(swap(t, u)))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    swap(t, u);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+} // namespace swap_ns
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+} // namespace detail
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+constexpr struct trivial_init_t{} trivial_init{};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.6, In-place construction
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+constexpr struct in_place_t{} in_place{};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.7, Disengaged state indicator
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+struct nullopt_t
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  struct init{};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr explicit nullopt_t(init){}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+constexpr nullopt_t nullopt{nullopt_t::init()};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.8, class bad_optional_access
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+class bad_optional_access : public logic_error {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  explicit bad_optional_access(const string& what_arg) : logic_error{what_arg} {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  explicit bad_optional_access(const char* what_arg) : logic_error{what_arg} {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+union storage_t
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  unsigned char dummy_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T value_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr storage_t( trivial_init_t ) noexcept : dummy_() {};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class... Args>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr storage_t( Args&&... args ) : value_(constexpr_forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ~storage_t(){}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+union constexpr_storage_t
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    unsigned char dummy_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    T value_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr constexpr_storage_t( trivial_init_t ) noexcept : dummy_() {};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    template <class... Args>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr constexpr_storage_t( Args&&... args ) : value_(constexpr_forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ~constexpr_storage_t() = default;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+struct optional_base
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    bool init_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    storage_t<T> storage_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr optional_base() noexcept : init_(false), storage_(trivial_init) {};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    explicit constexpr optional_base(const T& v) : init_(true), storage_(v) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    explicit constexpr optional_base(T&& v) : init_(true), storage_(constexpr_move(v)) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    template <class... Args> explicit optional_base(in_place_t, Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        : init_(true), storage_(constexpr_forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    explicit optional_base(in_place_t, std::initializer_list<U> il, Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        : init_(true), storage_(il, std::forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ~optional_base() { if (init_) storage_.value_.T::~T(); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+struct constexpr_optional_base
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    bool init_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr_storage_t<T> storage_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr constexpr_optional_base() noexcept : init_(false), storage_(trivial_init) {};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    explicit constexpr constexpr_optional_base(const T& v) : init_(true), storage_(v) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    explicit constexpr constexpr_optional_base(T&& v) : init_(true), storage_(constexpr_move(v)) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    template <class... Args> explicit constexpr constexpr_optional_base(in_place_t, Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      : init_(true), storage_(constexpr_forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    OPTIONAL_CONSTEXPR_INIT_LIST explicit constexpr_optional_base(in_place_t, std::initializer_list<U> il, Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      : init_(true), storage_(il, std::forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ~constexpr_optional_base() = default;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+using OptionalBase = typename std::conditional<
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    is_trivially_destructible<T>::value,                          // if possible
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr_optional_base<typename std::remove_const<T>::type>, // use base with trivial destructor
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    optional_base<typename std::remove_const<T>::type>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+>::type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+class optional : private OptionalBase<T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  static_assert( !std::is_same<typename std::decay<T>::type, nullopt_t>::value, "bad T" );
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  static_assert( !std::is_same<typename std::decay<T>::type, in_place_t>::value, "bad T" );
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr bool initialized() const noexcept { return OptionalBase<T>::init_; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  typename std::remove_const<T>::type* dataptr() {  return std::addressof(OptionalBase<T>::storage_.value_); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr const T* dataptr() const { return detail_::static_addressof(OptionalBase<T>::storage_.value_); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr const T& contained_val() const& { return OptionalBase<T>::storage_.value_; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if OPTIONAL_HAS_MOVE_ACCESSORS == 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T&& contained_val() && { return std::move(OptionalBase<T>::storage_.value_); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T& contained_val() & { return OptionalBase<T>::storage_.value_; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T& contained_val() & { return OptionalBase<T>::storage_.value_; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T&& contained_val() && { return std::move(OptionalBase<T>::storage_.value_); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr const T& contained_val() const { return OptionalBase<T>::storage_.value_; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T& contained_val() { return OptionalBase<T>::storage_.value_; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void clear() noexcept {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (initialized()) dataptr()->T::~T();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    OptionalBase<T>::init_ = false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class... Args>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void initialize(Args&&... args) noexcept(noexcept(T(std::forward<Args>(args)...)))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    assert(!OptionalBase<T>::init_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ::new (static_cast<void*>(dataptr())) T(std::forward<Args>(args)...);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    OptionalBase<T>::init_ = true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class U, class... Args>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void initialize(std::initializer_list<U> il, Args&&... args) noexcept(noexcept(T(il, std::forward<Args>(args)...)))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    assert(!OptionalBase<T>::init_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ::new (static_cast<void*>(dataptr())) T(il, std::forward<Args>(args)...);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    OptionalBase<T>::init_ = true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  typedef T value_type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.5.1, constructors
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional() noexcept : OptionalBase<T>()  {};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional(nullopt_t) noexcept : OptionalBase<T>() {};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  optional(const optional& rhs)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  : OptionalBase<T>()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (rhs.initialized()) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        ::new (static_cast<void*>(dataptr())) T(*rhs);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        OptionalBase<T>::init_ = true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  optional(optional&& rhs) noexcept(is_nothrow_move_constructible<T>::value)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  : OptionalBase<T>()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (rhs.initialized()) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        ::new (static_cast<void*>(dataptr())) T(std::move(*rhs));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        OptionalBase<T>::init_ = true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional(const T& v) : OptionalBase<T>(v) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional(T&& v) : OptionalBase<T>(constexpr_move(v)) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class... Args>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  explicit constexpr optional(in_place_t, Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  : OptionalBase<T>(in_place_t{}, constexpr_forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_CONSTEXPR_INIT_LIST explicit optional(in_place_t, std::initializer_list<U> il, Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  : OptionalBase<T>(in_place_t{}, il, constexpr_forward<Args>(args)...) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.4.2, Destructor
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ~optional() = default;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.4.3, assignment
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  optional& operator=(nullopt_t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    clear();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  optional& operator=(const optional& rhs)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if      (initialized() == true  && rhs.initialized() == false) clear();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    else if (initialized() == false && rhs.initialized() == true)  initialize(*rhs);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    else if (initialized() == true  && rhs.initialized() == true)  contained_val() = *rhs;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  optional& operator=(optional&& rhs)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  noexcept(is_nothrow_move_assignable<T>::value && is_nothrow_move_constructible<T>::value)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if      (initialized() == true  && rhs.initialized() == false) clear();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    else if (initialized() == false && rhs.initialized() == true)  initialize(std::move(*rhs));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    else if (initialized() == true  && rhs.initialized() == true)  contained_val() = std::move(*rhs);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class U>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  auto operator=(U&& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  -> typename enable_if
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  <
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    is_same<typename decay<U>::type, T>::value,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    optional&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  >::type
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (initialized()) { contained_val() = std::forward<U>(v); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    else               { initialize(std::forward<U>(v));  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class... Args>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void emplace(Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    clear();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    initialize(std::forward<Args>(args)...);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class U, class... Args>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void emplace(initializer_list<U> il, Args&&... args)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    clear();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    initialize<U, Args...>(il, std::forward<Args>(args)...);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.4.4, Swap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void swap(optional<T>& rhs) noexcept(is_nothrow_move_constructible<T>::value
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                                       && noexcept(detail_::swap_ns::adl_swap(declval<T&>(), declval<T&>())))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if      (initialized() == true  && rhs.initialized() == false) { rhs.initialize(std::move(**this)); clear(); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    else if (initialized() == false && rhs.initialized() == true)  { initialize(std::move(*rhs)); rhs.clear(); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    else if (initialized() == true  && rhs.initialized() == true)  { using std::swap; swap(**this, *rhs); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.4.5, Observers
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  explicit constexpr operator bool() const noexcept { return initialized(); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr bool has_value() const noexcept { return initialized(); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T const* operator ->() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), dataptr());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if OPTIONAL_HAS_MOVE_ACCESSORS == 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T* operator ->() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    assert (initialized());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return dataptr();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T const& operator *() const& {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T& operator *() & {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    assert (initialized());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return contained_val();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T&& operator *() && {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    assert (initialized());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return constexpr_move(contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T const& value() const& {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T& value() & {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T&& value() && {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    if (!initialized()) throw bad_optional_access("bad optional access");
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return std::move(contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T* operator ->() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    assert (initialized());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return dataptr();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T const& operator *() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T& operator *() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    assert (initialized());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return contained_val();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T const& value() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T& value() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class V>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T value_or(V&& v) const&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   if OPTIONAL_HAS_MOVE_ACCESSORS == 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class V>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  OPTIONAL_MUTABLE_CONSTEXPR T value_or(V&& v) &&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class V>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T value_or(V&& v) &&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+#   endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class V>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T value_or(V&& v) const
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.6.3.6, modifiers
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void reset() noexcept { clear(); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+class optional<T&>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  static_assert( !std::is_same<T, nullopt_t>::value, "bad T" );
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  static_assert( !std::is_same<T, in_place_t>::value, "bad T" );
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  T* ref;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.5.1, construction/destruction
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional() noexcept : ref(nullptr) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional(nullopt_t) noexcept : ref(nullptr) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional(T& v) noexcept : ref(detail_::static_addressof(v)) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  optional(T&&) = delete;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr optional(const optional& rhs) noexcept : ref(rhs.ref) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  explicit constexpr optional(in_place_t, T& v) noexcept : ref(detail_::static_addressof(v)) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  explicit optional(in_place_t, T&&) = delete;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  ~optional() = default;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.5.2, mutation
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  optional& operator=(nullopt_t) noexcept {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ref = nullptr;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // optional& operator=(const optional& rhs) noexcept {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // ref = rhs.ref;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // optional& operator=(optional&& rhs) noexcept {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // ref = rhs.ref;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    // return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <typename U>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  auto operator=(U&& rhs) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  -> typename enable_if
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  <
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    is_same<typename decay<U>::type, optional<T&>>::value,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    optional&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  >::type
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ref = rhs.ref;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <typename U>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  auto operator=(U&& rhs) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  -> typename enable_if
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  <
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    !is_same<typename decay<U>::type, optional<T&>>::value,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    optional&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  >::type
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  = delete;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void emplace(T& v) noexcept {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    ref = detail_::static_addressof(v);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void emplace(T&&) = delete;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void swap(optional<T&>& rhs) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    std::swap(ref, rhs.ref);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // 20.5.5.3, observers
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T* operator->() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, ref);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T& operator*() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, *ref);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr T& value() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return ref ? *ref : (throw bad_optional_access("bad optional access"), *ref);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  explicit constexpr operator bool() const noexcept {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return ref != nullptr;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr bool has_value() const noexcept {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return ref != nullptr;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <class V>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  constexpr typename decay<T>::type value_or(V&& v) const
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    return *this ? **this : detail_::convert<typename decay<T>::type>(constexpr_forward<V>(v));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  // x.x.x.x, modifiers
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  void reset() noexcept { ref = nullptr; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+class optional<T&&>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  static_assert( sizeof(T) == 0, "optional rvalue references disallowed" );
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.8, Relational operators
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const optional<T>& x, const optional<T>& y)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) != bool(y) ? false : bool(x) == false ? true : *x == *y;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const optional<T>& x, const optional<T>& y)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return !(x == y);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const optional<T>& x, const optional<T>& y)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return (!y) ? false : (!x) ? true : *x < *y;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const optional<T>& x, const optional<T>& y)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return (y < x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const optional<T>& x, const optional<T>& y)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return !(y < x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const optional<T>& x, const optional<T>& y)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return !(x < y);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.9, Comparison with nullopt
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return (!x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return (!x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return (!x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return (!x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.10, Comparison with T
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const optional<T>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x == v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const T& v, const optional<T>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v == *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const optional<T>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x != v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const T& v, const optional<T>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v != *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const optional<T>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x < v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const T& v, const optional<T>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v > *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const optional<T>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x > v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const T& v, const optional<T>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v < *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const optional<T>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x >= v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const T& v, const optional<T>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v <= *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const optional<T>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x <= v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const T& v, const optional<T>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v >= *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// Comparison of optional<T&> with T
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const optional<T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x == v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const T& v, const optional<T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v == *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const optional<T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x != v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const T& v, const optional<T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v != *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const optional<T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x < v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const T& v, const optional<T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v > *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const optional<T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x > v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const T& v, const optional<T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v < *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const optional<T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x >= v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const T& v, const optional<T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v <= *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const optional<T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x <= v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const T& v, const optional<T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v >= *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// Comparison of optional<T const&> with T
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const optional<const T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x == v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator==(const T& v, const optional<const T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v == *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const optional<const T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x != v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator!=(const T& v, const optional<const T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v != *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const optional<const T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x < v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const T& v, const optional<const T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v > *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>(const optional<const T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x > v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<(const T& v, const optional<const T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v < *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const optional<const T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x >= v : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const T& v, const optional<const T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v <= *x : false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator<=(const optional<const T&>& x, const T& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? *x <= v : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T> constexpr bool operator>=(const T& v, const optional<const T&>& x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return bool(x) ? v >= *x : true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+// 20.5.12, Specialized algorithms
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y)))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  x.swap(y);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+constexpr optional<typename decay<T>::type> make_optional(T&& v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return optional<typename decay<T>::type>(constexpr_forward<T>(v));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+template <class X>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+constexpr optional<X&> make_optional(reference_wrapper<X> v)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  return optional<X&>(v.get());
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+} // namespace experimental
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+} // namespace std
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+namespace std
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <typename T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  struct hash<std::experimental::optional<T>>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    typedef typename hash<T>::result_type result_type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    typedef std::experimental::optional<T> argument_type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr result_type operator()(argument_type const& arg) const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      return arg ? std::hash<T>{}(*arg) : result_type{};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  template <typename T>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  struct hash<std::experimental::optional<T&>>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    typedef typename hash<T>::result_type result_type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    typedef std::experimental::optional<T&> argument_type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    constexpr result_type operator()(argument_type const& arg) const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      return arg ? std::hash<T>{}(*arg) : result_type{};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# undef TR2_OPTIONAL_REQUIRES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# undef TR2_OPTIONAL_ASSERTED_EXPRESSION
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+# endif //___OPTIONAL_HPP___
</span><span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt59/files/patch-qtlocation-mbgl-optional.diff b/aqua/qt59/files/patch-qtlocation-mbgl-optional.diff
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 00000000000..7ef37eacc16
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt59/files/patch-qtlocation-mbgl-optional.diff
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,11 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- src/3rdparty/mapbox-gl-native/mapbox-gl-native.pro.orig
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ src/3rdparty/mapbox-gl-native/mapbox-gl-native.pro
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -363,6 +363,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     deps/geometry/0.9.2/include \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     deps/kdbush/0.1.1-1 \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     deps/kdbush/0.1.1-1/include \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    deps/optional/f5b56b71 \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    deps/optional/f5b56b71/include \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     deps/pixelmatch/0.10.0 \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     deps/pixelmatch/0.10.0/include \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     deps/polylabel/1.0.3 \
</span><span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt59/files/patch-qtlocation-mbgl-tileset.diff b/aqua/qt59/files/patch-qtlocation-mbgl-tileset.diff
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 00000000000..5cb93380cfd
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt59/files/patch-qtlocation-mbgl-tileset.diff
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,24 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+From af9bb97e47cfadbd63231d8a09d874cad9916285 Mon Sep 17 00:00:00 2001
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+From: "Thiago Marcos P. Santos" <tmpsantos@gmail.com>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Date: Fri, 15 Dec 2017 04:13:57 +0200
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Subject: [PATCH] [windows][core] Add missing != operator to Tileset
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+---
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ include/mbgl/util/tileset.hpp | 4 ++++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 1 file changed, 4 insertions(+)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+diff --git a/include/mbgl/util/tileset.hpp b/include/mbgl/util/tileset.hpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+index 7bef0e89ed1..1b7b8f0f755 100644
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- src/3rdparty/mapbox-gl-native/include/mbgl/util/tileset.hpp.orig
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ src/3rdparty/mapbox-gl-native/include/mbgl/util/tileset.hpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -37,6 +37,10 @@ class Tileset {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         return std::tie(lhs.tiles, lhs.zoomRange, lhs.attribution, lhs.scheme, lhs.bounds)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             == std::tie(rhs.tiles, rhs.zoomRange, rhs.attribution, rhs.scheme, rhs.bounds);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    friend bool operator!=(const Tileset& lhs, const Tileset& rhs) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        return !(lhs == rhs);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ } // namespace mbgl
</span></pre><pre style='margin:0'>

</pre>