From owner-svn-ports-all@freebsd.org Sat Dec 29 23:07:18 2018 Return-Path: Delivered-To: svn-ports-all@mailman.ysv.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mailman.ysv.freebsd.org (Postfix) with ESMTP id D7F341430059; Sat, 29 Dec 2018 23:07:17 +0000 (UTC) (envelope-from tcberner@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) server-signature RSA-PSS (4096 bits) client-signature RSA-PSS (4096 bits) client-digest SHA256) (Client CN "mxrelay.nyi.freebsd.org", Issuer "Let's Encrypt Authority X3" (verified OK)) by mx1.freebsd.org (Postfix) with ESMTPS id 7344A89463; Sat, 29 Dec 2018 23:07:17 +0000 (UTC) (envelope-from tcberner@FreeBSD.org) Received: from repo.freebsd.org (repo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:0]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (Client did not present a certificate) by mxrelay.nyi.freebsd.org (Postfix) with ESMTPS id 46FA019D4B; Sat, 29 Dec 2018 23:07:17 +0000 (UTC) (envelope-from tcberner@FreeBSD.org) Received: from repo.freebsd.org ([127.0.1.37]) by repo.freebsd.org (8.15.2/8.15.2) with ESMTP id wBTN7HLo020763; Sat, 29 Dec 2018 23:07:17 GMT (envelope-from tcberner@FreeBSD.org) Received: (from tcberner@localhost) by repo.freebsd.org (8.15.2/8.15.2/Submit) id wBTN7Hrw020761; Sat, 29 Dec 2018 23:07:17 GMT (envelope-from tcberner@FreeBSD.org) Message-Id: <201812292307.wBTN7Hrw020761@repo.freebsd.org> X-Authentication-Warning: repo.freebsd.org: tcberner set sender to tcberner@FreeBSD.org using -f From: "Tobias C. Berner" Date: Sat, 29 Dec 2018 23:07:17 +0000 (UTC) To: ports-committers@freebsd.org, svn-ports-all@freebsd.org, svn-ports-head@freebsd.org Subject: svn commit: r488694 - head/deskutils/kmail/files X-SVN-Group: ports-head X-SVN-Commit-Author: tcberner X-SVN-Commit-Paths: head/deskutils/kmail/files X-SVN-Commit-Revision: 488694 X-SVN-Commit-Repository: ports MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Rspamd-Queue-Id: 7344A89463 X-Spamd-Bar: -- Authentication-Results: mx1.freebsd.org X-Spamd-Result: default: False [-2.96 / 15.00]; local_wl_from(0.00)[FreeBSD.org]; NEURAL_HAM_MEDIUM(-1.00)[-0.999,0]; NEURAL_HAM_SHORT(-0.96)[-0.964,0]; NEURAL_HAM_LONG(-1.00)[-0.998,0]; ASN(0.00)[asn:11403, ipnet:2610:1c1:1::/48, country:US] X-BeenThere: svn-ports-all@freebsd.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: SVN commit messages for the ports tree List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 29 Dec 2018 23:07:18 -0000 Author: tcberner Date: Sat Dec 29 23:07:16 2018 New Revision: 488694 URL: https://svnweb.freebsd.org/changeset/ports/488694 Log: deskutils/kmail: include optional.h from boost to fix build on recent CURRENT On FreeBSD Current optional is no longer in experimental/optional. Further, switching to c++17 to use it, would require changes to databases/akonadi to no longer use auto_ptr. As this all would be a hassle, follow what upstream has done for a similar problem with akonadi on Windows [1]: Import a 3rdparty optional.h and use that. [1] https://github.com/KDE/akonadi/commit/482315f4cbc79d3725738fa1e62c8e0ce053bdea PR: 234022 Added: head/deskutils/kmail/files/ head/deskutils/kmail/files/patch-agents_unifiedmailboxagent_boost__optional.h (contents, props changed) head/deskutils/kmail/files/patch-agents_unifiedmailboxagent_utils.h (contents, props changed) Added: head/deskutils/kmail/files/patch-agents_unifiedmailboxagent_boost__optional.h ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/deskutils/kmail/files/patch-agents_unifiedmailboxagent_boost__optional.h Sat Dec 29 23:07:16 2018 (r488694) @@ -0,0 +1,1082 @@ +Copyright (C) 2011-2016 Andrzej Krzemienski + +Distributed under the Boost Software License, Version 1.0 +(see accompanying file LICENSE_1_0.txt or a copy at +http://www.boost.org/LICENSE_1_0.txt) + +The idea and interface is based on Boost.Optional library +authored by Fernando Luis Cacciola Carballal + +Home at https://github.com/akrzemi1/Optional + + +--- agents/unifiedmailboxagent/boost_optional.h.orig 2018-12-29 21:08:10 UTC ++++ agents/unifiedmailboxagent/boost_optional.h +@@ -0,0 +1,1067 @@ ++// Copyright (C) 2011 - 2012 Andrzej Krzemienski. ++// ++// Use, modification, and distribution is subject to the Boost Software ++// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at ++// http://www.boost.org/LICENSE_1_0.txt) ++// ++// The idea and interface is based on Boost.Optional library ++// authored by Fernando Luis Cacciola Carballal ++ ++# ifndef ___OPTIONAL_HPP___ ++# define ___OPTIONAL_HPP___ ++ ++# include ++# include ++# include ++# include ++# include ++# include ++# include ++ ++# define TR2_OPTIONAL_REQUIRES(...) typename enable_if<__VA_ARGS__::value, bool>::type = false ++ ++# if defined __GNUC__ // NOTE: GNUC is also defined for Clang ++# if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8) ++# define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___ ++# elif (__GNUC__ > 4) ++# define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___ ++# endif ++# ++# if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 7) ++# define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___ ++# elif (__GNUC__ > 4) ++# define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___ ++# endif ++# ++# if (__GNUC__ == 4) && (__GNUC_MINOR__ == 8) && (__GNUC_PATCHLEVEL__ >= 1) ++# define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___ ++# elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9) ++# define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___ ++# elif (__GNUC__ > 4) ++# define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___ ++# endif ++# endif ++# ++# if defined __clang_major__ ++# if (__clang_major__ == 3 && __clang_minor__ >= 5) ++# define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ ++# elif (__clang_major__ > 3) ++# define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ ++# endif ++# if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ ++# define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_ ++# elif (__clang_major__ == 3 && __clang_minor__ == 4 && __clang_patchlevel__ >= 2) ++# define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_ ++# endif ++# endif ++# ++# if defined _MSC_VER ++# if (_MSC_VER >= 1900) ++# define TR2_OPTIONAL_MSVC_2015_AND_HIGHER___ ++# endif ++# endif ++ ++# if defined __clang__ ++# if (__clang_major__ > 2) || (__clang_major__ == 2) && (__clang_minor__ >= 9) ++# define OPTIONAL_HAS_THIS_RVALUE_REFS 1 ++# else ++# define OPTIONAL_HAS_THIS_RVALUE_REFS 0 ++# endif ++# elif defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___ ++# define OPTIONAL_HAS_THIS_RVALUE_REFS 1 ++# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___ ++# define OPTIONAL_HAS_THIS_RVALUE_REFS 1 ++# else ++# define OPTIONAL_HAS_THIS_RVALUE_REFS 0 ++# endif ++ ++ ++# if defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___ ++# define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 1 ++# define OPTIONAL_CONSTEXPR_INIT_LIST constexpr ++# else ++# define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 0 ++# define OPTIONAL_CONSTEXPR_INIT_LIST ++# endif ++ ++# if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ && (defined __cplusplus) && (__cplusplus != 201103L) ++# define OPTIONAL_HAS_MOVE_ACCESSORS 1 ++# else ++# define OPTIONAL_HAS_MOVE_ACCESSORS 0 ++# endif ++ ++# // In C++11 constexpr implies const, so we need to make non-const members also non-constexpr ++# if (defined __cplusplus) && (__cplusplus == 201103L) ++# define OPTIONAL_MUTABLE_CONSTEXPR ++# else ++# define OPTIONAL_MUTABLE_CONSTEXPR constexpr ++# endif ++ ++namespace std{ ++ ++namespace experimental{ ++ ++// BEGIN workaround for missing is_trivially_destructible ++# if defined TR2_OPTIONAL_GCC_4_8_AND_HIGHER___ ++ // leave it: it is already there ++# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_ ++ // leave it: it is already there ++# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___ ++ // leave it: it is already there ++# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS ++ // leave it: the user doesn't want it ++# else ++ template ++ using is_trivially_destructible = std::has_trivial_destructor; ++# endif ++// END workaround for missing is_trivially_destructible ++ ++# if (defined TR2_OPTIONAL_GCC_4_7_AND_HIGHER___) ++ // leave it; our metafunctions are already defined. ++# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_ ++ // leave it; our metafunctions are already defined. ++# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___ ++ // leave it: it is already there ++# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS ++ // leave it: the user doesn't want it ++# else ++ ++ ++// workaround for missing traits in GCC and CLANG ++template ++struct is_nothrow_move_constructible ++{ ++ constexpr static bool value = std::is_nothrow_constructible::value; ++}; ++ ++ ++template ++struct is_assignable ++{ ++ template ++ constexpr static bool has_assign(...) { return false; } ++ ++ template () = std::declval(), true)) > ++ // the comma operator is necessary for the cases where operator= returns void ++ constexpr static bool has_assign(bool) { return true; } ++ ++ constexpr static bool value = has_assign(true); ++}; ++ ++ ++template ++struct is_nothrow_move_assignable ++{ ++ template ++ struct has_nothrow_move_assign { ++ constexpr static bool value = false; ++ }; ++ ++ template ++ struct has_nothrow_move_assign { ++ constexpr static bool value = noexcept( std::declval() = std::declval() ); ++ }; ++ ++ constexpr static bool value = has_nothrow_move_assign::value>::value; ++}; ++// end workaround ++ ++ ++# endif ++ ++ ++ ++// 20.5.4, optional for object types ++template class optional; ++ ++// 20.5.5, optional for lvalue reference types ++template class optional; ++ ++ ++// workaround: std utility functions aren't constexpr yet ++template inline constexpr T&& constexpr_forward(typename std::remove_reference::type& t) noexcept ++{ ++ return static_cast(t); ++} ++ ++template inline constexpr T&& constexpr_forward(typename std::remove_reference::type&& t) noexcept ++{ ++ static_assert(!std::is_lvalue_reference::value, "!!"); ++ return static_cast(t); ++} ++ ++template inline constexpr typename std::remove_reference::type&& constexpr_move(T&& t) noexcept ++{ ++ return static_cast::type&&>(t); ++} ++ ++ ++#if defined NDEBUG ++# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) (EXPR) ++#else ++# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) ((CHECK) ? (EXPR) : ([]{assert(!#CHECK);}(), (EXPR))) ++#endif ++ ++ ++namespace detail_ ++{ ++ ++// static_addressof: a constexpr version of addressof ++template ++struct has_overloaded_addressof ++{ ++ template ++ constexpr static bool has_overload(...) { return false; } ++ ++ template ().operator&()) > ++ constexpr static bool has_overload(bool) { return true; } ++ ++ constexpr static bool value = has_overload(true); ++}; ++ ++template )> ++constexpr T* static_addressof(T& ref) ++{ ++ return &ref; ++} ++ ++template )> ++T* static_addressof(T& ref) ++{ ++ return std::addressof(ref); ++} ++ ++ ++// the call to convert(b) has return type A and converts b to type A iff b decltype(b) is implicitly convertible to A ++template ++constexpr U convert(U v) { return v; } ++ ++ ++namespace swap_ns ++{ ++ using std::swap; ++ ++ template ++ void adl_swap(T& t, T& u) noexcept(noexcept(swap(t, u))) ++ { ++ swap(t, u); ++ } ++ ++} // namespace swap_ns ++ ++} // namespace detail ++ ++ ++constexpr struct trivial_init_t{} trivial_init{}; ++ ++ ++// 20.5.6, In-place construction ++constexpr struct in_place_t{} in_place{}; ++ ++ ++// 20.5.7, Disengaged state indicator ++struct nullopt_t ++{ ++ struct init{}; ++ constexpr explicit nullopt_t(init){} ++}; ++constexpr nullopt_t nullopt{nullopt_t::init()}; ++ ++ ++// 20.5.8, class bad_optional_access ++class bad_optional_access : public logic_error { ++public: ++ explicit bad_optional_access(const string& what_arg) : logic_error{what_arg} {} ++ explicit bad_optional_access(const char* what_arg) : logic_error{what_arg} {} ++}; ++ ++ ++template ++union storage_t ++{ ++ unsigned char dummy_; ++ T value_; ++ ++ constexpr storage_t( trivial_init_t ) noexcept : dummy_() {}; ++ ++ template ++ constexpr storage_t( Args&&... args ) : value_(constexpr_forward(args)...) {} ++ ++ ~storage_t(){} ++}; ++ ++ ++template ++union constexpr_storage_t ++{ ++ unsigned char dummy_; ++ T value_; ++ ++ constexpr constexpr_storage_t( trivial_init_t ) noexcept : dummy_() {}; ++ ++ template ++ constexpr constexpr_storage_t( Args&&... args ) : value_(constexpr_forward(args)...) {} ++ ++ ~constexpr_storage_t() = default; ++}; ++ ++ ++template ++struct optional_base ++{ ++ bool init_; ++ storage_t storage_; ++ ++ constexpr optional_base() noexcept : init_(false), storage_(trivial_init) {}; ++ ++ explicit constexpr optional_base(const T& v) : init_(true), storage_(v) {} ++ ++ explicit constexpr optional_base(T&& v) : init_(true), storage_(constexpr_move(v)) {} ++ ++ template explicit optional_base(in_place_t, Args&&... args) ++ : init_(true), storage_(constexpr_forward(args)...) {} ++ ++ template >)> ++ explicit optional_base(in_place_t, std::initializer_list il, Args&&... args) ++ : init_(true), storage_(il, std::forward(args)...) {} ++ ++ ~optional_base() { if (init_) storage_.value_.T::~T(); } ++}; ++ ++ ++template ++struct constexpr_optional_base ++{ ++ bool init_; ++ constexpr_storage_t storage_; ++ ++ constexpr constexpr_optional_base() noexcept : init_(false), storage_(trivial_init) {}; ++ ++ explicit constexpr constexpr_optional_base(const T& v) : init_(true), storage_(v) {} ++ ++ explicit constexpr constexpr_optional_base(T&& v) : init_(true), storage_(constexpr_move(v)) {} ++ ++ template explicit constexpr constexpr_optional_base(in_place_t, Args&&... args) ++ : init_(true), storage_(constexpr_forward(args)...) {} ++ ++ template >)> ++ OPTIONAL_CONSTEXPR_INIT_LIST explicit constexpr_optional_base(in_place_t, std::initializer_list il, Args&&... args) ++ : init_(true), storage_(il, std::forward(args)...) {} ++ ++ ~constexpr_optional_base() = default; ++}; ++ ++template ++using OptionalBase = typename std::conditional< ++ is_trivially_destructible::value, // if possible ++ constexpr_optional_base::type>, // use base with trivial destructor ++ optional_base::type> ++>::type; ++ ++ ++ ++template ++class optional : private OptionalBase ++{ ++ static_assert( !std::is_same::type, nullopt_t>::value, "bad T" ); ++ static_assert( !std::is_same::type, in_place_t>::value, "bad T" ); ++ ++ ++ constexpr bool initialized() const noexcept { return OptionalBase::init_; } ++ typename std::remove_const::type* dataptr() { return std::addressof(OptionalBase::storage_.value_); } ++ constexpr const T* dataptr() const { return detail_::static_addressof(OptionalBase::storage_.value_); } ++ ++# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1 ++ constexpr const T& contained_val() const& { return OptionalBase::storage_.value_; } ++# if OPTIONAL_HAS_MOVE_ACCESSORS == 1 ++ OPTIONAL_MUTABLE_CONSTEXPR T&& contained_val() && { return std::move(OptionalBase::storage_.value_); } ++ OPTIONAL_MUTABLE_CONSTEXPR T& contained_val() & { return OptionalBase::storage_.value_; } ++# else ++ T& contained_val() & { return OptionalBase::storage_.value_; } ++ T&& contained_val() && { return std::move(OptionalBase::storage_.value_); } ++# endif ++# else ++ constexpr const T& contained_val() const { return OptionalBase::storage_.value_; } ++ T& contained_val() { return OptionalBase::storage_.value_; } ++# endif ++ ++ void clear() noexcept { ++ if (initialized()) dataptr()->T::~T(); ++ OptionalBase::init_ = false; ++ } ++ ++ template ++ void initialize(Args&&... args) noexcept(noexcept(T(std::forward(args)...))) ++ { ++ assert(!OptionalBase::init_); ++ ::new (static_cast(dataptr())) T(std::forward(args)...); ++ OptionalBase::init_ = true; ++ } ++ ++ template ++ void initialize(std::initializer_list il, Args&&... args) noexcept(noexcept(T(il, std::forward(args)...))) ++ { ++ assert(!OptionalBase::init_); ++ ::new (static_cast(dataptr())) T(il, std::forward(args)...); ++ OptionalBase::init_ = true; ++ } ++ ++public: ++ typedef T value_type; ++ ++ // 20.5.5.1, constructors ++ constexpr optional() noexcept : OptionalBase() {}; ++ constexpr optional(nullopt_t) noexcept : OptionalBase() {}; ++ ++ optional(const optional& rhs) ++ : OptionalBase() ++ { ++ if (rhs.initialized()) { ++ ::new (static_cast(dataptr())) T(*rhs); ++ OptionalBase::init_ = true; ++ } ++ } ++ ++ optional(optional&& rhs) noexcept(is_nothrow_move_constructible::value) ++ : OptionalBase() ++ { ++ if (rhs.initialized()) { ++ ::new (static_cast(dataptr())) T(std::move(*rhs)); ++ OptionalBase::init_ = true; ++ } ++ } ++ ++ constexpr optional(const T& v) : OptionalBase(v) {} ++ ++ constexpr optional(T&& v) : OptionalBase(constexpr_move(v)) {} ++ ++ template ++ explicit constexpr optional(in_place_t, Args&&... args) ++ : OptionalBase(in_place_t{}, constexpr_forward(args)...) {} ++ ++ template >)> ++ OPTIONAL_CONSTEXPR_INIT_LIST explicit optional(in_place_t, std::initializer_list il, Args&&... args) ++ : OptionalBase(in_place_t{}, il, constexpr_forward(args)...) {} ++ ++ // 20.5.4.2, Destructor ++ ~optional() = default; ++ ++ // 20.5.4.3, assignment ++ optional& operator=(nullopt_t) noexcept ++ { ++ clear(); ++ return *this; ++ } ++ ++ optional& operator=(const optional& rhs) ++ { ++ if (initialized() == true && rhs.initialized() == false) clear(); ++ else if (initialized() == false && rhs.initialized() == true) initialize(*rhs); ++ else if (initialized() == true && rhs.initialized() == true) contained_val() = *rhs; ++ return *this; ++ } ++ ++ optional& operator=(optional&& rhs) ++ noexcept(is_nothrow_move_assignable::value && is_nothrow_move_constructible::value) ++ { ++ if (initialized() == true && rhs.initialized() == false) clear(); ++ else if (initialized() == false && rhs.initialized() == true) initialize(std::move(*rhs)); ++ else if (initialized() == true && rhs.initialized() == true) contained_val() = std::move(*rhs); ++ return *this; ++ } ++ ++ template ++ auto operator=(U&& v) ++ -> typename enable_if ++ < ++ is_same::type, T>::value, ++ optional& ++ >::type ++ { ++ if (initialized()) { contained_val() = std::forward(v); } ++ else { initialize(std::forward(v)); } ++ return *this; ++ } ++ ++ ++ template ++ void emplace(Args&&... args) ++ { ++ clear(); ++ initialize(std::forward(args)...); ++ } ++ ++ template ++ void emplace(initializer_list il, Args&&... args) ++ { ++ clear(); ++ initialize(il, std::forward(args)...); ++ } ++ ++ // 20.5.4.4, Swap ++ void swap(optional& rhs) noexcept(is_nothrow_move_constructible::value ++ && noexcept(detail_::swap_ns::adl_swap(declval(), declval()))) ++ { ++ if (initialized() == true && rhs.initialized() == false) { rhs.initialize(std::move(**this)); clear(); } ++ else if (initialized() == false && rhs.initialized() == true) { initialize(std::move(*rhs)); rhs.clear(); } ++ else if (initialized() == true && rhs.initialized() == true) { using std::swap; swap(**this, *rhs); } ++ } ++ ++ // 20.5.4.5, Observers ++ ++ explicit constexpr operator bool() const noexcept { return initialized(); } ++ constexpr bool has_value() const noexcept { return initialized(); } ++ ++ constexpr T const* operator ->() const { ++ return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), dataptr()); ++ } ++ ++# if OPTIONAL_HAS_MOVE_ACCESSORS == 1 ++ ++ OPTIONAL_MUTABLE_CONSTEXPR T* operator ->() { ++ assert (initialized()); ++ return dataptr(); ++ } ++ ++ constexpr T const& operator *() const& { ++ return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val()); ++ } ++ ++ OPTIONAL_MUTABLE_CONSTEXPR T& operator *() & { ++ assert (initialized()); ++ return contained_val(); ++ } ++ ++ OPTIONAL_MUTABLE_CONSTEXPR T&& operator *() && { ++ assert (initialized()); ++ return constexpr_move(contained_val()); ++ } ++ ++ constexpr T const& value() const& { ++ return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val()); ++ } ++ ++ OPTIONAL_MUTABLE_CONSTEXPR T& value() & { ++ return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val()); ++ } ++ ++ OPTIONAL_MUTABLE_CONSTEXPR T&& value() && { ++ if (!initialized()) throw bad_optional_access("bad optional access"); ++ return std::move(contained_val()); ++ } ++ ++# else ++ ++ T* operator ->() { ++ assert (initialized()); ++ return dataptr(); ++ } ++ ++ constexpr T const& operator *() const { ++ return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val()); ++ } ++ ++ T& operator *() { ++ assert (initialized()); ++ return contained_val(); ++ } ++ ++ constexpr T const& value() const { ++ return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val()); ++ } ++ ++ T& value() { ++ return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val()); ++ } ++ ++# endif ++ ++# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1 ++ ++ template ++ constexpr T value_or(V&& v) const& ++ { ++ return *this ? **this : detail_::convert(constexpr_forward(v)); ++ } ++ ++# if OPTIONAL_HAS_MOVE_ACCESSORS == 1 ++ ++ template ++ OPTIONAL_MUTABLE_CONSTEXPR T value_or(V&& v) && ++ { ++ return *this ? constexpr_move(const_cast&>(*this).contained_val()) : detail_::convert(constexpr_forward(v)); ++ } ++ ++# else ++ ++ template ++ T value_or(V&& v) && ++ { ++ return *this ? constexpr_move(const_cast&>(*this).contained_val()) : detail_::convert(constexpr_forward(v)); ++ } ++ ++# endif ++ ++# else ++ ++ template ++ constexpr T value_or(V&& v) const ++ { ++ return *this ? **this : detail_::convert(constexpr_forward(v)); ++ } ++ ++# endif ++ ++ // 20.6.3.6, modifiers ++ void reset() noexcept { clear(); } ++}; ++ ++ ++template ++class optional ++{ ++ static_assert( !std::is_same::value, "bad T" ); ++ static_assert( !std::is_same::value, "bad T" ); ++ T* ref; ++ ++public: ++ ++ // 20.5.5.1, construction/destruction ++ constexpr optional() noexcept : ref(nullptr) {} ++ ++ constexpr optional(nullopt_t) noexcept : ref(nullptr) {} ++ ++ constexpr optional(T& v) noexcept : ref(detail_::static_addressof(v)) {} ++ ++ optional(T&&) = delete; ++ ++ constexpr optional(const optional& rhs) noexcept : ref(rhs.ref) {} ++ ++ explicit constexpr optional(in_place_t, T& v) noexcept : ref(detail_::static_addressof(v)) {} ++ ++ explicit optional(in_place_t, T&&) = delete; ++ ++ ~optional() = default; ++ ++ // 20.5.5.2, mutation ++ optional& operator=(nullopt_t) noexcept { ++ ref = nullptr; ++ return *this; ++ } ++ ++ // optional& operator=(const optional& rhs) noexcept { ++ // ref = rhs.ref; ++ // return *this; ++ // } ++ ++ // optional& operator=(optional&& rhs) noexcept { ++ // ref = rhs.ref; ++ // return *this; ++ // } ++ ++ template ++ auto operator=(U&& rhs) noexcept ++ -> typename enable_if ++ < ++ is_same::type, optional>::value, ++ optional& ++ >::type ++ { ++ ref = rhs.ref; ++ return *this; ++ } ++ ++ template ++ auto operator=(U&& rhs) noexcept ++ -> typename enable_if ++ < ++ !is_same::type, optional>::value, ++ optional& ++ >::type ++ = delete; ++ ++ void emplace(T& v) noexcept { ++ ref = detail_::static_addressof(v); ++ } ++ ++ void emplace(T&&) = delete; ++ ++ ++ void swap(optional& rhs) noexcept ++ { ++ std::swap(ref, rhs.ref); ++ } ++ ++ // 20.5.5.3, observers ++ constexpr T* operator->() const { ++ return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, ref); ++ } ++ ++ constexpr T& operator*() const { ++ return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, *ref); ++ } ++ ++ constexpr T& value() const { ++ return ref ? *ref : (throw bad_optional_access("bad optional access"), *ref); ++ } ++ ++ explicit constexpr operator bool() const noexcept { ++ return ref != nullptr; ++ } ++ ++ constexpr bool has_value() const noexcept { ++ return ref != nullptr; ++ } ++ ++ template ++ constexpr typename decay::type value_or(V&& v) const ++ { ++ return *this ? **this : detail_::convert::type>(constexpr_forward(v)); ++ } ++ ++ // x.x.x.x, modifiers ++ void reset() noexcept { ref = nullptr; } ++}; ++ ++ ++template ++class optional ++{ ++ static_assert( sizeof(T) == 0, "optional rvalue references disallowed" ); ++}; ++ ++ ++// 20.5.8, Relational operators ++template constexpr bool operator==(const optional& x, const optional& y) ++{ ++ return bool(x) != bool(y) ? false : bool(x) == false ? true : *x == *y; ++} ++ ++template constexpr bool operator!=(const optional& x, const optional& y) ++{ ++ return !(x == y); ++} ++ ++template constexpr bool operator<(const optional& x, const optional& y) ++{ ++ return (!y) ? false : (!x) ? true : *x < *y; ++} ++ ++template constexpr bool operator>(const optional& x, const optional& y) ++{ ++ return (y < x); ++} ++ ++template constexpr bool operator<=(const optional& x, const optional& y) ++{ ++ return !(y < x); ++} ++ ++template constexpr bool operator>=(const optional& x, const optional& y) ++{ ++ return !(x < y); ++} ++ ++ ++// 20.5.9, Comparison with nullopt ++template constexpr bool operator==(const optional& x, nullopt_t) noexcept ++{ ++ return (!x); ++} ++ ++template constexpr bool operator==(nullopt_t, const optional& x) noexcept ++{ ++ return (!x); ++} ++ ++template constexpr bool operator!=(const optional& x, nullopt_t) noexcept ++{ ++ return bool(x); ++} ++ ++template constexpr bool operator!=(nullopt_t, const optional& x) noexcept ++{ ++ return bool(x); ++} ++ ++template constexpr bool operator<(const optional&, nullopt_t) noexcept ++{ ++ return false; ++} ++ ++template constexpr bool operator<(nullopt_t, const optional& x) noexcept ++{ ++ return bool(x); ++} ++ ++template constexpr bool operator<=(const optional& x, nullopt_t) noexcept ++{ ++ return (!x); ++} ++ ++template constexpr bool operator<=(nullopt_t, const optional&) noexcept ++{ ++ return true; ++} ++ ++template constexpr bool operator>(const optional& x, nullopt_t) noexcept ++{ ++ return bool(x); ++} ++ ++template constexpr bool operator>(nullopt_t, const optional&) noexcept ++{ ++ return false; ++} ++ ++template constexpr bool operator>=(const optional&, nullopt_t) noexcept ++{ ++ return true; ++} ++ ++template constexpr bool operator>=(nullopt_t, const optional& x) noexcept ++{ ++ return (!x); ++} ++ ++ ++ ++// 20.5.10, Comparison with T ++template constexpr bool operator==(const optional& x, const T& v) ++{ ++ return bool(x) ? *x == v : false; ++} ++ ++template constexpr bool operator==(const T& v, const optional& x) ++{ ++ return bool(x) ? v == *x : false; ++} ++ ++template constexpr bool operator!=(const optional& x, const T& v) ++{ ++ return bool(x) ? *x != v : true; ++} ++ ++template constexpr bool operator!=(const T& v, const optional& x) ++{ ++ return bool(x) ? v != *x : true; ++} ++ ++template constexpr bool operator<(const optional& x, const T& v) ++{ ++ return bool(x) ? *x < v : true; ++} ++ ++template constexpr bool operator>(const T& v, const optional& x) ++{ ++ return bool(x) ? v > *x : true; ++} ++ ++template constexpr bool operator>(const optional& x, const T& v) ++{ ++ return bool(x) ? *x > v : false; ++} ++ ++template constexpr bool operator<(const T& v, const optional& x) ++{ ++ return bool(x) ? v < *x : false; ++} ++ ++template constexpr bool operator>=(const optional& x, const T& v) ++{ ++ return bool(x) ? *x >= v : false; ++} ++ ++template constexpr bool operator<=(const T& v, const optional& x) ++{ ++ return bool(x) ? v <= *x : false; ++} ++ ++template constexpr bool operator<=(const optional& x, const T& v) ++{ ++ return bool(x) ? *x <= v : true; ++} ++ ++template constexpr bool operator>=(const T& v, const optional& x) ++{ ++ return bool(x) ? v >= *x : true; ++} ++ ++ ++// Comparison of optional with T ++template constexpr bool operator==(const optional& x, const T& v) ++{ ++ return bool(x) ? *x == v : false; ++} ++ ++template constexpr bool operator==(const T& v, const optional& x) ++{ ++ return bool(x) ? v == *x : false; ++} ++ ++template constexpr bool operator!=(const optional& x, const T& v) ++{ ++ return bool(x) ? *x != v : true; ++} ++ ++template constexpr bool operator!=(const T& v, const optional& x) ++{ ++ return bool(x) ? v != *x : true; ++} ++ ++template constexpr bool operator<(const optional& x, const T& v) ++{ ++ return bool(x) ? *x < v : true; ++} ++ ++template constexpr bool operator>(const T& v, const optional& x) ++{ ++ return bool(x) ? v > *x : true; ++} ++ ++template constexpr bool operator>(const optional& x, const T& v) ++{ ++ return bool(x) ? *x > v : false; ++} ++ ++template constexpr bool operator<(const T& v, const optional& x) ++{ ++ return bool(x) ? v < *x : false; ++} ++ ++template constexpr bool operator>=(const optional& x, const T& v) ++{ ++ return bool(x) ? *x >= v : false; ++} ++ ++template constexpr bool operator<=(const T& v, const optional& x) ++{ ++ return bool(x) ? v <= *x : false; ++} ++ ++template constexpr bool operator<=(const optional& x, const T& v) ++{ ++ return bool(x) ? *x <= v : true; ++} ++ ++template constexpr bool operator>=(const T& v, const optional& x) ++{ ++ return bool(x) ? v >= *x : true; ++} ++ ++// Comparison of optional with T ++template constexpr bool operator==(const optional& x, const T& v) ++{ ++ return bool(x) ? *x == v : false; ++} ++ ++template constexpr bool operator==(const T& v, const optional& x) ++{ ++ return bool(x) ? v == *x : false; ++} ++ ++template constexpr bool operator!=(const optional& x, const T& v) ++{ ++ return bool(x) ? *x != v : true; ++} ++ ++template constexpr bool operator!=(const T& v, const optional& x) ++{ ++ return bool(x) ? v != *x : true; ++} ++ ++template constexpr bool operator<(const optional& x, const T& v) ++{ ++ return bool(x) ? *x < v : true; ++} ++ ++template constexpr bool operator>(const T& v, const optional& x) ++{ ++ return bool(x) ? v > *x : true; ++} ++ *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***