head	1.1;
branch	1.1.1;
access;
symbols
	netbsd-11-0-RC5:1.1.1.10
	netbsd-11-0-RC4:1.1.1.10
	netbsd-11-0-RC3:1.1.1.10
	netbsd-11-0-RC2:1.1.1.10
	netbsd-11-0-RC1:1.1.1.10
	gcc-14-3-0:1.1.1.11
	perseant-exfatfs-base-20250801:1.1.1.10
	netbsd-11:1.1.1.10.0.2
	netbsd-11-base:1.1.1.10
	gcc-12-5-0:1.1.1.10
	netbsd-10-1-RELEASE:1.1.1.8
	perseant-exfatfs-base-20240630:1.1.1.10
	gcc-12-4-0:1.1.1.10
	perseant-exfatfs:1.1.1.9.0.2
	perseant-exfatfs-base:1.1.1.9
	netbsd-9-4-RELEASE:1.1.1.1.6.1
	netbsd-10-0-RELEASE:1.1.1.8
	netbsd-10-0-RC6:1.1.1.8
	netbsd-10-0-RC5:1.1.1.8
	netbsd-10-0-RC4:1.1.1.8
	netbsd-10-0-RC3:1.1.1.8
	netbsd-10-0-RC2:1.1.1.8
	netbsd-10-0-RC1:1.1.1.8
	gcc-12-3-0:1.1.1.9
	gcc-10-5-0:1.1.1.8
	netbsd-10:1.1.1.8.0.2
	netbsd-10-base:1.1.1.8
	netbsd-9-3-RELEASE:1.1.1.1.6.1
	gcc-10-4-0:1.1.1.8
	cjep_sun2x-base1:1.1.1.7
	cjep_sun2x:1.1.1.7.0.4
	cjep_sun2x-base:1.1.1.7
	cjep_staticlib_x-base1:1.1.1.7
	netbsd-9-2-RELEASE:1.1.1.1.6.1
	cjep_staticlib_x:1.1.1.7.0.2
	cjep_staticlib_x-base:1.1.1.7
	gcc-10-3-0:1.1.1.7
	netbsd-9-1-RELEASE:1.1.1.1.6.1
	gcc-9-3-0:1.1.1.6
	gcc-7-5-0:1.1.1.4
	phil-wifi-20200421:1.1.1.3
	phil-wifi-20200411:1.1.1.3
	is-mlppp:1.1.1.2.0.2
	is-mlppp-base:1.1.1.2
	phil-wifi-20200406:1.1.1.3
	gcc-8-4-0:1.1.1.5
	netbsd-9-0-RELEASE:1.1.1.1
	netbsd-9-0-RC2:1.1.1.1
	netbsd-9-0-RC1:1.1.1.1
	phil-wifi-20191119:1.1.1.2
	gcc-8-3-0:1.1.1.2
	netbsd-9:1.1.1.1.0.6
	netbsd-9-base:1.1.1.1
	phil-wifi:1.1.1.1.0.4
	phil-wifi-20190609:1.1.1.1
	pgoyette-compat-merge-20190127:1.1.1.1.2.2
	pgoyette-compat:1.1.1.1.0.2
	pgoyette-compat-20190127:1.1.1.1
	gcc-7-4-0:1.1.1.1
	FSF:1.1.1;
locks; strict;
comment	@# @;


1.1
date	2019.01.19.10.14.11;	author mrg;	state Exp;
branches
	1.1.1.1;
next	;
commitid	VQ8OwWIg5RS9kn8B;

1.1.1.1
date	2019.01.19.10.14.11;	author mrg;	state Exp;
branches
	1.1.1.1.2.1
	1.1.1.1.4.1
	1.1.1.1.6.1;
next	1.1.1.2;
commitid	VQ8OwWIg5RS9kn8B;

1.1.1.2
date	2019.10.01.09.36.07;	author mrg;	state Exp;
branches;
next	1.1.1.3;
commitid	smvgr2IPAQDr89FB;

1.1.1.3
date	2020.03.11.08.15.49;	author mrg;	state Exp;
branches;
next	1.1.1.4;
commitid	AhKhCnGPUZgytXZB;

1.1.1.4
date	2020.08.11.05.10.39;	author mrg;	state Exp;
branches;
next	1.1.1.5;
commitid	5dBRDT7i6e65xBjC;

1.1.1.5
date	2020.08.11.05.30.09;	author mrg;	state Exp;
branches;
next	1.1.1.6;
commitid	7AI4OfpLi4eqEBjC;

1.1.1.6
date	2020.09.05.07.52.09;	author mrg;	state Exp;
branches;
next	1.1.1.7;
commitid	ZRYA7IOuwfMjAPmC;

1.1.1.7
date	2021.04.10.22.10.04;	author mrg;	state Exp;
branches;
next	1.1.1.8;
commitid	eC4g0MRpqTvEkNOC;

1.1.1.8
date	2022.07.22.19.52.36;	author mrg;	state Exp;
branches;
next	1.1.1.9;
commitid	fUYPgdKzIHqhwVMD;

1.1.1.9
date	2023.07.30.05.21.20;	author mrg;	state Exp;
branches
	1.1.1.9.2.1;
next	1.1.1.10;
commitid	tk6nV4mbc9nVEMyE;

1.1.1.10
date	2024.06.30.07.35.40;	author mrg;	state Exp;
branches;
next	1.1.1.11;
commitid	m7BwZsPdfJvuHYfF;

1.1.1.11
date	2025.09.13.23.45.48;	author mrg;	state Exp;
branches;
next	;
commitid	KwhwN4krNWa6XBaG;

1.1.1.1.2.1
date	2019.01.19.10.14.11;	author pgoyette;	state dead;
branches;
next	1.1.1.1.2.2;
commitid	JKpcmvSjdT25dl9B;

1.1.1.1.2.2
date	2019.01.26.21.59.38;	author pgoyette;	state Exp;
branches;
next	;
commitid	JKpcmvSjdT25dl9B;

1.1.1.1.4.1
date	2019.01.19.10.14.11;	author christos;	state dead;
branches;
next	1.1.1.1.4.2;
commitid	jtc8rnCzWiEEHGqB;

1.1.1.1.4.2
date	2019.06.10.21.54.58;	author christos;	state Exp;
branches;
next	1.1.1.1.4.3;
commitid	jtc8rnCzWiEEHGqB;

1.1.1.1.4.3
date	2020.04.08.14.06.38;	author martin;	state Exp;
branches;
next	1.1.1.1.4.4;
commitid	Qli2aW9E74UFuA3C;

1.1.1.1.4.4
date	2020.04.13.07.58.43;	author martin;	state Exp;
branches;
next	;
commitid	X01YhRUPVUDaec4C;

1.1.1.1.6.1
date	2020.08.14.10.45.31;	author martin;	state Exp;
branches;
next	;
commitid	N4xCrirfb6ezh1kC;

1.1.1.9.2.1
date	2024.07.01.01.00.59;	author perseant;	state Exp;
branches;
next	;
commitid	NkoYLLCQWWw9v4gF;


desc
@@


1.1
log
@Initial revision
@
text
@// <optional> -*- C++ -*-

// Copyright (C) 2013-2017 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @@file include/optional
 *  This is a Standard C++ Library header.
 */

#ifndef _GLIBCXX_OPTIONAL
#define _GLIBCXX_OPTIONAL 1

#pragma GCC system_header

#if __cplusplus >= 201703L

#include <utility>
#include <type_traits>
#include <stdexcept>
#include <new>
#include <initializer_list>
#include <bits/functexcept.h>
#include <bits/functional_hash.h>
#include <bits/enable_special_members.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /**
   *  @@addtogroup utilities
   *  @@{
   */

#define __cpp_lib_optional 201603

  template<typename _Tp>
    class optional;

  /// Tag type to disengage optional objects.
  struct nullopt_t
  {
    // Do not user-declare default constructor at all for
    // optional_value = {} syntax to work.
    // nullopt_t() = delete;

    // Used for constructing nullopt.
    enum class _Construct { _Token };

    // Must be constexpr for nullopt_t to be literal.
    explicit constexpr nullopt_t(_Construct) { }
  };

  /// Tag to disengage optional objects.
  inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token };

  /**
   *  @@brief Exception class thrown when a disengaged optional object is
   *  dereferenced.
   *  @@ingroup exceptions
   */
  class bad_optional_access : public exception
  {
  public:
    bad_optional_access() { }
    virtual const char* what() const noexcept override
    {return "bad optional access";}

    virtual ~bad_optional_access() noexcept = default;
  };

  void
  __throw_bad_optional_access()
  __attribute__((__noreturn__));

  // XXX Does not belong here.
  inline void
  __throw_bad_optional_access()
  { _GLIBCXX_THROW_OR_ABORT(bad_optional_access()); }


  // Payload for constexpr optionals.
  template <typename _Tp,
	    bool /*_TrivialCopyMove*/ =
	      is_trivially_copy_constructible<_Tp>::value
	      && is_trivially_move_constructible<_Tp>::value,
	    bool /*_ShouldProvideDestructor*/ =
	      is_trivially_destructible<_Tp>::value>
    struct _Optional_payload
    {
      constexpr _Optional_payload()
	: _M_empty() {}

      template<typename... _Args>
      constexpr _Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...),
	  _M_engaged(true)
      {}

      template<typename _Up, typename... _Args>
      constexpr _Optional_payload(std::initializer_list<_Up> __il,
				  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true) {}

      template <class _Up> struct __ctor_tag {};

      constexpr _Optional_payload(__ctor_tag<bool>,
				  const _Tp& __other)
	: _M_payload(__other),
	  _M_engaged(true)
      {}

      constexpr _Optional_payload(__ctor_tag<void>)
	: _M_empty()
      {}

      constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
	: _M_payload(std::move(__other)),
	  _M_engaged(true)
      {}

      constexpr _Optional_payload(bool __engaged,
				  const _Optional_payload& __other)
	: _Optional_payload(__engaged ?
			    _Optional_payload(__ctor_tag<bool>{},
					      __other._M_payload) :
			    _Optional_payload(__ctor_tag<void>{}))
      {}

      constexpr _Optional_payload(bool __engaged,
				  _Optional_payload&& __other)
	: _Optional_payload(__engaged
			    ? _Optional_payload(__ctor_tag<bool>{},
						std::move(__other._M_payload))
			    : _Optional_payload(__ctor_tag<void>{}))
      {}

      using _Stored_type = remove_const_t<_Tp>;
      struct _Empty_byte { };
      union {
          _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged = false;
    };

  // Payload for non-constexpr optionals with non-trivial destructor.
  template <typename _Tp>
    struct _Optional_payload<_Tp, false, false>
    {
      constexpr _Optional_payload()
	: _M_empty() {}

      template <typename... _Args>
      constexpr _Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...),
	  _M_engaged(true) {}

      template<typename _Up, typename... _Args>
      constexpr _Optional_payload(std::initializer_list<_Up> __il,
				  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true) {}
      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
	: _Optional_payload(__other)
      {}

      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
	: _Optional_payload(std::move(__other))
      {}

      constexpr _Optional_payload(const _Optional_payload& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(__other._M_payload);
      }

      constexpr _Optional_payload(_Optional_payload&& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(std::move(__other._M_payload));
      }

      using _Stored_type = remove_const_t<_Tp>;
      struct _Empty_byte { };
      union {
          _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged = false;

      ~_Optional_payload()
      {
        if (_M_engaged)
          _M_payload.~_Stored_type();
      }

      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new ((void *) std::__addressof(this->_M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_engaged = true;
        }
    };

  // Payload for non-constexpr optionals with trivial destructor.
  template <typename _Tp>
    struct _Optional_payload<_Tp, false, true>
    {
      constexpr _Optional_payload()
	: _M_empty() {}

      template <typename... _Args>
      constexpr _Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...),
	  _M_engaged(true) {}

      template<typename _Up, typename... _Args>
      constexpr _Optional_payload(std::initializer_list<_Up> __il,
				  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true) {}
      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
	: _Optional_payload(__other)
      {}

      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
	: _Optional_payload(std::move(__other))
      {}

      constexpr _Optional_payload(const _Optional_payload& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(__other._M_payload);
      }

      constexpr _Optional_payload(_Optional_payload&& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(std::move(__other._M_payload));
      }

      using _Stored_type = remove_const_t<_Tp>;
      struct _Empty_byte { };
      union {
          _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged = false;

      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new ((void *) std::__addressof(this->_M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_engaged = true;
        }
    };

  /**
    * @@brief Class template that holds the necessary state for @@ref optional
    * and that has the responsibility for construction and the special members.
    *
    * Such a separate base class template is necessary in order to
    * conditionally enable the special members (e.g. copy/move constructors).
    * Note that this means that @@ref _Optional_base implements the
    * functionality for copy and move assignment, but not for converting
    * assignment.
    *
    * @@see optional, _Enable_special_members
    */
  template<typename _Tp>
    class _Optional_base
    {
    private:
      // Remove const to avoid prohibition of reusing object storage for
      // const-qualified types in [3.8/9]. This is strictly internal
      // and even optional itself is oblivious to it.
      using _Stored_type = remove_const_t<_Tp>;

    public:

      // Constructors for disengaged optionals.
      constexpr _Optional_base() noexcept
      { }

      constexpr _Optional_base(nullopt_t) noexcept
      { }

      // Constructors for engaged optionals.
      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
		     std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
		     __il, std::forward<_Args>(__args)...)
        { }

      // Copy and move constructors.
      constexpr _Optional_base(const _Optional_base& __other)
	: _M_payload(__other._M_payload._M_engaged,
		     __other._M_payload)
      { }

      constexpr _Optional_base(_Optional_base&& __other)
      noexcept(is_nothrow_move_constructible<_Tp>())
	: _M_payload(__other._M_payload._M_engaged,
		     std::move(__other._M_payload))
      { }

      // Assignment operators.
      _Optional_base&
      operator=(const _Optional_base& __other)
      {
        if (this->_M_payload._M_engaged && __other._M_payload._M_engaged)
          this->_M_get() = __other._M_get();
        else
	  {
	    if (__other._M_payload._M_engaged)
	      this->_M_construct(__other._M_get());
	    else
	      this->_M_reset();
	  }

        return *this;
      }

      _Optional_base&
      operator=(_Optional_base&& __other)
      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
		      is_nothrow_move_assignable<_Tp>>())
      {
	if (this->_M_payload._M_engaged && __other._M_payload._M_engaged)
	  this->_M_get() = std::move(__other._M_get());
	else
	  {
	    if (__other._M_payload._M_engaged)
	      this->_M_construct(std::move(__other._M_get()));
	    else
	      this->_M_reset();
	  }
	return *this;
      }
      // The following functionality is also needed by optional, hence the
      // protected accessibility.
    protected:
      constexpr bool _M_is_engaged() const noexcept
      { return this->_M_payload._M_engaged; }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload._M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload._M_payload; }

      // The _M_construct operation has !_M_engaged as a precondition
      // while _M_destruct has _M_engaged as a precondition.
      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new (std::__addressof(this->_M_payload._M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_payload._M_engaged = true;
        }

      void
      _M_destruct()
      {
        this->_M_payload._M_engaged = false;
        this->_M_payload._M_payload.~_Stored_type();
      }

      // _M_reset is a 'safe' operation with no precondition.
      void
      _M_reset()
      {
        if (this->_M_payload._M_engaged)
          this->_M_destruct();
      }

    private:
      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
  class optional;

  template<typename _Tp, typename _Up>
    using __converts_from_optional =
      __or_<is_constructible<_Tp, const optional<_Up>&>,
	    is_constructible<_Tp, optional<_Up>&>,
	    is_constructible<_Tp, const optional<_Up>&&>,
	    is_constructible<_Tp, optional<_Up>&&>,
	    is_convertible<const optional<_Up>&, _Tp>,
	    is_convertible<optional<_Up>&, _Tp>,
	    is_convertible<const optional<_Up>&&, _Tp>,
	    is_convertible<optional<_Up>&&, _Tp>>;

  template<typename _Tp, typename _Up>
    using __assigns_from_optional =
      __or_<is_assignable<_Tp&, const optional<_Up>&>,
	    is_assignable<_Tp&, optional<_Up>&>,
	    is_assignable<_Tp&, const optional<_Up>&&>,
	    is_assignable<_Tp&, optional<_Up>&&>>;

  /**
    * @@brief Class template for optional values.
    */
  template<typename _Tp>
    class optional
    : private _Optional_base<_Tp>,
      private _Enable_copy_move<
        // Copy constructor.
        is_copy_constructible<_Tp>::value,
        // Copy assignment.
        __and_<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>::value,
        // Move constructor.
        is_move_constructible<_Tp>::value,
        // Move assignment.
        __and_<is_move_constructible<_Tp>, is_move_assignable<_Tp>>::value,
        // Unique tag type.
        optional<_Tp>>
    {
      static_assert(__and_<__not_<is_same<remove_cv_t<_Tp>, nullopt_t>>,
			   __not_<is_same<remove_cv_t<_Tp>, in_place_t>>,
			   __not_<is_reference<_Tp>>>(),
                    "Invalid instantiation of optional<T>");

    private:
      using _Base = _Optional_base<_Tp>;

    public:
      using value_type = _Tp;

      constexpr optional() = default;

      constexpr optional(nullopt_t) noexcept
	: _Base(nullopt) { }

      // Converting constructors for engaged optionals.
      template <typename _Up = _Tp,
                enable_if_t<__and_<
			      __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
			      __not_<is_same<in_place_t, decay_t<_Up>>>,
			      is_constructible<_Tp, _Up&&>,
			      is_convertible<_Up&&, _Tp>
			      >::value, bool> = true>
      constexpr optional(_Up&& __t)
        : _Base(std::in_place, std::forward<_Up>(__t)) { }

      template <typename _Up = _Tp,
                enable_if_t<__and_<
			      __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
			      __not_<is_same<in_place_t, decay_t<_Up>>>,
			      is_constructible<_Tp, _Up&&>,
			      __not_<is_convertible<_Up&&, _Tp>>
			      >::value, bool> = false>
      explicit constexpr optional(_Up&& __t)
        : _Base(std::in_place, std::forward<_Up>(__t)) { }

      template <typename _Up,
                enable_if_t<__and_<
			    __not_<is_same<_Tp, _Up>>,
			    is_constructible<_Tp, const _Up&>,
			    is_convertible<const _Up&, _Tp>,
			    __not_<__converts_from_optional<_Tp, _Up>>
			    >::value, bool> = true>
      constexpr optional(const optional<_Up>& __t)
      {
	if (__t)
	  emplace(*__t);
      }

      template <typename _Up,
                 enable_if_t<__and_<
			       __not_<is_same<_Tp, _Up>>,
			       is_constructible<_Tp, const _Up&>,
			       __not_<is_convertible<const _Up&, _Tp>>,
			       __not_<__converts_from_optional<_Tp, _Up>>
			       >::value, bool> = false>
      explicit constexpr optional(const optional<_Up>& __t)
      {
	if (__t)
	  emplace(*__t);
      }

      template <typename _Up,
                enable_if_t<__and_<
			      __not_<is_same<_Tp, _Up>>,
			      is_constructible<_Tp, _Up&&>,
			      is_convertible<_Up&&, _Tp>,
			      __not_<__converts_from_optional<_Tp, _Up>>
			      >::value, bool> = true>
      constexpr optional(optional<_Up>&& __t)
      {
	if (__t)
	  emplace(std::move(*__t));
      }

      template <typename _Up,
                enable_if_t<__and_<
			    __not_<is_same<_Tp, _Up>>,
			    is_constructible<_Tp, _Up&&>,
			    __not_<is_convertible<_Up&&, _Tp>>,
			    __not_<__converts_from_optional<_Tp, _Up>>
			    >::value, bool> = false>
      explicit constexpr optional(optional<_Up>&& __t)
      {
	if (__t)
	  emplace(std::move(*__t));
      }

      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
      explicit constexpr optional(in_place_t, _Args&&... __args)
        : _Base(std::in_place, std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
      explicit constexpr optional(in_place_t,
				  initializer_list<_Up> __il,
				  _Args&&... __args)
        : _Base(std::in_place, __il, std::forward<_Args>(__args)...) { }

      // Assignment operators.
      optional&
      operator=(nullopt_t) noexcept
      {
        this->_M_reset();
        return *this;
      }

      template<typename _Up = _Tp>
        enable_if_t<__and_<
		      __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
		      is_constructible<_Tp, _Up>,
		      __not_<__and_<is_scalar<_Tp>,
				    is_same<_Tp, decay_t<_Up>>>>,
		      is_assignable<_Tp&, _Up>>::value,
		    optional&>
        operator=(_Up&& __u)
        {
          if (this->_M_is_engaged())
            this->_M_get() = std::forward<_Up>(__u);
          else
            this->_M_construct(std::forward<_Up>(__u));

          return *this;
        }

      template<typename _Up>
	enable_if_t<__and_<
		      __not_<is_same<_Tp, _Up>>,
		      is_constructible<_Tp, const _Up&>,
		      is_assignable<_Tp&, _Up>,
		      __not_<__converts_from_optional<_Tp, _Up>>,
		      __not_<__assigns_from_optional<_Tp, _Up>>
		      >::value,
		    optional&>
        operator=(const optional<_Up>& __u)
        {
          if (__u)
            {
              if (this->_M_is_engaged())
                this->_M_get() = *__u;
              else
                this->_M_construct(*__u);
            }
          else
            {
              this->_M_reset();
            }
          return *this;
        }

      template<typename _Up>
	enable_if_t<__and_<
		      __not_<is_same<_Tp, _Up>>,
		      is_constructible<_Tp, _Up>,
		      is_assignable<_Tp&, _Up>,
		      __not_<__converts_from_optional<_Tp, _Up>>,
		      __not_<__assigns_from_optional<_Tp, _Up>>
		      >::value,
		    optional&>
        operator=(optional<_Up>&& __u)
        {
          if (__u)
            {
              if (this->_M_is_engaged())
                this->_M_get() = std::move(*__u);
              else
                this->_M_construct(std::move(*__u));
            }
          else
            {
              this->_M_reset();
            }

          return *this;
        }

      template<typename... _Args>
	enable_if_t<is_constructible<_Tp, _Args&&...>::value, _Tp&>
	emplace(_Args&&... __args)
	{
	  this->_M_reset();
	  this->_M_construct(std::forward<_Args>(__args)...);
	  return this->_M_get();
	}

      template<typename _Up, typename... _Args>
	enable_if_t<is_constructible<_Tp, initializer_list<_Up>&,
				     _Args&&...>::value, _Tp&>
	emplace(initializer_list<_Up> __il, _Args&&... __args)
	{
	  this->_M_reset();
	  this->_M_construct(__il, std::forward<_Args>(__args)...);
	  return this->_M_get();
	}

      // Destructor is implicit, implemented in _Optional_base.

      // Swap.
      void
      swap(optional& __other)
      noexcept(is_nothrow_move_constructible<_Tp>()
               && is_nothrow_swappable_v<_Tp>)
      {
        using std::swap;

        if (this->_M_is_engaged() && __other._M_is_engaged())
          swap(this->_M_get(), __other._M_get());
        else if (this->_M_is_engaged())
	  {
	    __other._M_construct(std::move(this->_M_get()));
	    this->_M_destruct();
	  }
        else if (__other._M_is_engaged())
	  {
	    this->_M_construct(std::move(__other._M_get()));
	    __other._M_destruct();
	  }
      }

      // Observers.
      constexpr const _Tp*
      operator->() const
      { return std::__addressof(this->_M_get()); }

      _Tp*
      operator->()
      { return std::__addressof(this->_M_get()); }

      constexpr const _Tp&
      operator*() const&
      { return this->_M_get(); }

      constexpr _Tp&
      operator*()&
      { return this->_M_get(); }

      constexpr _Tp&&
      operator*()&&
      { return std::move(this->_M_get()); }

      constexpr const _Tp&&
      operator*() const&&
      { return std::move(this->_M_get()); }

      constexpr explicit operator bool() const noexcept
      { return this->_M_is_engaged(); }

      constexpr bool has_value() const noexcept
      { return this->_M_is_engaged(); }

      constexpr const _Tp&
      value() const&
      {
	return this->_M_is_engaged()
	  ?  this->_M_get()
	  : (__throw_bad_optional_access(),
	     this->_M_get());
      }

      constexpr _Tp&
      value()&
      {
	return this->_M_is_engaged()
	  ?  this->_M_get()
	  : (__throw_bad_optional_access(),
	     this->_M_get());
      }

      constexpr _Tp&&
      value()&&
      {
	return this->_M_is_engaged()
	  ?  std::move(this->_M_get())
	  : (__throw_bad_optional_access(),
	     std::move(this->_M_get()));
      }

      constexpr const _Tp&&
      value() const&&
      {
	return this->_M_is_engaged()
	  ?  std::move(this->_M_get())
	  : (__throw_bad_optional_access(),
	     std::move(this->_M_get()));
      }

      template<typename _Up>
	constexpr _Tp
	value_or(_Up&& __u) const&
	{
	  static_assert(__and_<is_copy_constructible<_Tp>,
			       is_convertible<_Up&&, _Tp>>(),
			"Cannot return value");

	  return this->_M_is_engaged()
	    ? this->_M_get()
	    : static_cast<_Tp>(std::forward<_Up>(__u));
	}

      template<typename _Up>
	_Tp
	value_or(_Up&& __u) &&
	{
	  static_assert(__and_<is_move_constructible<_Tp>,
			       is_convertible<_Up&&, _Tp>>(),
			"Cannot return value" );

	  return this->_M_is_engaged()
	    ? std::move(this->_M_get())
	    : static_cast<_Tp>(std::forward<_Up>(__u));
	}
      void reset() noexcept { this->_M_reset(); }
    };

  template<typename _Tp>
    using __optional_relop_t =
    enable_if_t<is_convertible<_Tp, bool>::value, bool>;

  // Comparisons between optional values.
  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
    {
      return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
	     && (!__lhs || *__lhs == *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
    {
      return static_cast<bool>(__lhs) != static_cast<bool>(__rhs)
	|| (static_cast<bool>(__lhs) && *__lhs != *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
    {
      return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
    {
      return static_cast<bool>(__lhs) && (!__rhs || *__lhs > *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
    {
      return !__lhs || (static_cast<bool>(__rhs) && *__lhs <= *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
    {
      return !__rhs || (static_cast<bool>(__lhs) && *__lhs >= *__rhs);
    }

  // Comparisons with nullopt.
  template<typename _Tp>
    constexpr bool
    operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return !__lhs; }

  template<typename _Tp>
    constexpr bool
    operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return !__rhs; }

  template<typename _Tp>
    constexpr bool
    operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return static_cast<bool>(__lhs); }

  template<typename _Tp>
    constexpr bool
    operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return static_cast<bool>(__rhs); }

  template<typename _Tp>
    constexpr bool
    operator<(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept
    { return false; }

  template<typename _Tp>
    constexpr bool
    operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return static_cast<bool>(__rhs); }

  template<typename _Tp>
    constexpr bool
    operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return static_cast<bool>(__lhs); }

  template<typename _Tp>
    constexpr bool
    operator>(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept
    { return false; }

  template<typename _Tp>
    constexpr bool
    operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return !__lhs; }

  template<typename _Tp>
    constexpr bool
    operator<=(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept
    { return true; }

  template<typename _Tp>
    constexpr bool
    operator>=(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept
    { return true; }

  template<typename _Tp>
    constexpr bool
    operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return !__rhs; }

  // Comparisons with value type.
  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
    { return __lhs && *__lhs == __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() == declval<_Tp>())>
    { return __rhs && __lhs == *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
    { return !__lhs || *__lhs != __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() != declval<_Tp>())>
    { return !__rhs || __lhs != *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
    { return !__lhs || *__lhs < __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() < declval<_Tp>())>
    { return __rhs && __lhs < *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
    { return __lhs && *__lhs > __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() > declval<_Tp>())>
    { return !__rhs || __lhs > *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
    { return !__lhs || *__lhs <= __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() <= declval<_Tp>())>
    { return __rhs && __lhs <= *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
    { return __lhs && *__lhs >= __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() >= declval<_Tp>())>
    { return !__rhs || __lhs >= *__rhs; }

  // Swap and creation functions.

  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 2748. swappable traits for optionals
  template<typename _Tp>
    inline enable_if_t<is_move_constructible_v<_Tp> && is_swappable_v<_Tp>>
    swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs)
    noexcept(noexcept(__lhs.swap(__rhs)))
    { __lhs.swap(__rhs); }

  template<typename _Tp>
    enable_if_t<!(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)>
    swap(optional<_Tp>&, optional<_Tp>&) = delete;

  template<typename _Tp>
    constexpr optional<decay_t<_Tp>>
    make_optional(_Tp&& __t)
    { return optional<decay_t<_Tp>> { std::forward<_Tp>(__t) }; }

  template<typename _Tp, typename ..._Args>
    constexpr optional<_Tp>
    make_optional(_Args&&... __args)
    { return optional<_Tp> { in_place, std::forward<_Args>(__args)... }; }

  template<typename _Tp, typename _Up, typename ..._Args>
    constexpr optional<_Tp>
    make_optional(initializer_list<_Up> __il, _Args&&... __args)
    { return optional<_Tp> { in_place, __il, std::forward<_Args>(__args)... }; }

  // Hash.

  template<typename _Tp, typename _Up = remove_const_t<_Tp>,
           bool = __poison_hash<_Up>::__enable_hash_call>
    struct __optional_hash_call_base
    {
      size_t
      operator()(const optional<_Tp>& __t) const
      noexcept(noexcept(hash<_Up>{}(*__t)))
      {
        // We pick an arbitrary hash for disengaged optionals which hopefully
        // usual values of _Tp won't typically hash to.
        constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333);
        return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash;
      }
    };

  template<typename _Tp, typename _Up>
    struct __optional_hash_call_base<_Tp, _Up, false> {};

  template<typename _Tp>
    struct hash<optional<_Tp>>
    : private __poison_hash<remove_const_t<_Tp>>,
      public __optional_hash_call_base<_Tp>
    {
      using result_type = size_t;
      using argument_type = optional<_Tp>;
    };

  /// @@}

#if __cpp_deduction_guides >= 201606
  template <typename _Tp> optional(_Tp) -> optional<_Tp>;
#endif

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // C++17

#endif // _GLIBCXX_OPTIONAL
@


1.1.1.1
log
@import GCC 7.4.0.  main changes include:

The non-standard C++0x type traits has_trivial_default_constructor,
has_trivial_copy_constructor and has_trivial_copy_assign have been
removed.

On ARM targets (arm*-*-*), a bug introduced in GCC 5 that affects
conformance to the procedure call standard (AAPCS) has been fixed.

Many optimiser improvements

DWARF-5 support.

Many new and enhanced warnings.

Warnings about format strings now underline the pertinent part of
the string, and can offer suggested fixes.

Several new warnings related to buffer overflows and buffer
truncation.

New __builtin_add_overflow_p, __builtin_sub_overflow_p,
__builtin_mul_overflow_p built-ins added that test for overflow.

The C++ front end has experimental support for all of the current
C++17 draft.

The -fverbose-asm option has been expanded to prints comments
showing the source lines that correspond to the assembly.

The gcc and g++ driver programs will now provide suggestions for
misspelled arguments to command-line options.


AArch64 specific:

GCC has been updated to the latest revision of the procedure call
standard (AAPCS64) to provide support for parameter passing when
data types have been over-aligned.

The ARMv8.2-A and ARMv8.3-A architecture are now supported.

ARM specific:

Support for the ARMv5 and ARMv5E architectures has been
deprecated (which have no known implementations).

A new command-line option -mpure-code has been added. It does not
allow constant data to be placed in code sections.

x86 specific:

Support for the AVX-512 4FMAPS, 4VNNIW, VPOPCNTDQ and Software
Guard Extensions (SGX) ISA extensions has been added.

PPC specific:

GCC now diagnoses inline assembly that clobbers register r2.

RISC-V specific:

Support for the RISC-V instruction set has been added.

SH specific:

Support for SH5/SH64 has been removed.

Support for SH2A has been enhanced.
@
text
@@


1.1.1.1.6.1
log
@Pull up the following, all via patch, requested by mrg in ticket #1049:

	external/gpl3/gcc/dist/ChangeLog
	external/gpl3/gcc/dist/LAST_UPDATED
	external/gpl3/gcc/dist/MD5SUMS
	external/gpl3/gcc/dist/NEWS
	external/gpl3/gcc/dist/config/ChangeLog
	external/gpl3/gcc/dist/contrib/ChangeLog
	external/gpl3/gcc/dist/contrib/test_summary
	external/gpl3/gcc/dist/contrib/header-tools/ChangeLog
	external/gpl3/gcc/dist/contrib/reghunt/ChangeLog
	external/gpl3/gcc/dist/contrib/regression/ChangeLog
	external/gpl3/gcc/dist/fixincludes/ChangeLog
	external/gpl3/gcc/dist/fixincludes/fixincl.x
	external/gpl3/gcc/dist/fixincludes/inclhack.def
	external/gpl3/gcc/dist/fixincludes/tests/base/architecture/ppc/math.h
	external/gpl3/gcc/dist/fixincludes/tests/base/dispatch/object.h
	external/gpl3/gcc/dist/fixincludes/tests/base/os/availability.h
	external/gpl3/gcc/dist/fixincludes/tests/base/os/base.h
	external/gpl3/gcc/dist/gcc/BASE-VER
	external/gpl3/gcc/dist/gcc/ChangeLog
	external/gpl3/gcc/dist/gcc/DATESTAMP
	external/gpl3/gcc/dist/gcc/builtins.c
	external/gpl3/gcc/dist/gcc/calls.c
	external/gpl3/gcc/dist/gcc/cfgcleanup.c
	external/gpl3/gcc/dist/gcc/cfghooks.c
	external/gpl3/gcc/dist/gcc/cfghooks.h
	external/gpl3/gcc/dist/gcc/cfgloop.h
	external/gpl3/gcc/dist/gcc/cfgloopmanip.c
	external/gpl3/gcc/dist/gcc/cfgrtl.c
	external/gpl3/gcc/dist/gcc/combine.c
	external/gpl3/gcc/dist/gcc/config.gcc
	external/gpl3/gcc/dist/gcc/convert.c
	external/gpl3/gcc/dist/gcc/dce.c
	external/gpl3/gcc/dist/gcc/df-core.c
	external/gpl3/gcc/dist/gcc/dse.c
	external/gpl3/gcc/dist/gcc/dwarf2out.c
	external/gpl3/gcc/dist/gcc/except.c
	external/gpl3/gcc/dist/gcc/explow.c
	external/gpl3/gcc/dist/gcc/expmed.c
	external/gpl3/gcc/dist/gcc/expr.c
	external/gpl3/gcc/dist/gcc/final.c
	external/gpl3/gcc/dist/gcc/fold-const.c
	external/gpl3/gcc/dist/gcc/function.c
	external/gpl3/gcc/dist/gcc/gcse.c
	external/gpl3/gcc/dist/gcc/gengtype-lex.c
	external/gpl3/gcc/dist/gcc/ggc-page.c
	external/gpl3/gcc/dist/gcc/gimple-fold.c
	external/gpl3/gcc/dist/gcc/gimple-pretty-print.c
	external/gpl3/gcc/dist/gcc/gimple-ssa-sprintf.c
	external/gpl3/gcc/dist/gcc/gimple-ssa-strength-reduction.c
	external/gpl3/gcc/dist/gcc/gimple.c
	external/gpl3/gcc/dist/gcc/gimple.h
	external/gpl3/gcc/dist/gcc/gimplify.c
	external/gpl3/gcc/dist/gcc/graphite-scop-detection.c
	external/gpl3/gcc/dist/gcc/input.c
	external/gpl3/gcc/dist/gcc/internal-fn.c
	external/gpl3/gcc/dist/gcc/internal-fn.h
	external/gpl3/gcc/dist/gcc/ipa-cp.c
	external/gpl3/gcc/dist/gcc/ipa-icf-gimple.c
	external/gpl3/gcc/dist/gcc/ipa-inline.c
	external/gpl3/gcc/dist/gcc/ipa-prop.c
	external/gpl3/gcc/dist/gcc/ipa-pure-const.c
	external/gpl3/gcc/dist/gcc/ipa-reference.c
	external/gpl3/gcc/dist/gcc/ipa-utils.c
	external/gpl3/gcc/dist/gcc/ipa-utils.h
	external/gpl3/gcc/dist/gcc/ira.c
	external/gpl3/gcc/dist/gcc/loop-unroll.c
	external/gpl3/gcc/dist/gcc/lra-constraints.c
	external/gpl3/gcc/dist/gcc/lra.c
	external/gpl3/gcc/dist/gcc/lto-streamer-in.c
	external/gpl3/gcc/dist/gcc/lto-streamer-out.c
	external/gpl3/gcc/dist/gcc/lto-streamer.h
	external/gpl3/gcc/dist/gcc/lto-wrapper.c
	external/gpl3/gcc/dist/gcc/match.pd
	external/gpl3/gcc/dist/gcc/omp-expand.c
	external/gpl3/gcc/dist/gcc/omp-low.c
	external/gpl3/gcc/dist/gcc/omp-simd-clone.c
	external/gpl3/gcc/dist/gcc/optabs.c
	external/gpl3/gcc/dist/gcc/optc-save-gen.awk
	external/gpl3/gcc/dist/gcc/opth-gen.awk
	external/gpl3/gcc/dist/gcc/opts-common.c
	external/gpl3/gcc/dist/gcc/opts-global.c
	external/gpl3/gcc/dist/gcc/opts.c
	external/gpl3/gcc/dist/gcc/resource.c
	external/gpl3/gcc/dist/gcc/rtl.h
	external/gpl3/gcc/dist/gcc/rtlanal.c
	external/gpl3/gcc/dist/gcc/store-motion.c
	external/gpl3/gcc/dist/gcc/symtab.c
	external/gpl3/gcc/dist/gcc/toplev.c
	external/gpl3/gcc/dist/gcc/tree-cfg.c
	external/gpl3/gcc/dist/gcc/tree-complex.c
	external/gpl3/gcc/dist/gcc/tree-core.h
	external/gpl3/gcc/dist/gcc/tree-data-ref.c
	external/gpl3/gcc/dist/gcc/tree-data-ref.h
	external/gpl3/gcc/dist/gcc/tree-inline.c
	external/gpl3/gcc/dist/gcc/tree-inline.h
	external/gpl3/gcc/dist/gcc/tree-loop-distribution.c
	external/gpl3/gcc/dist/gcc/tree-outof-ssa.c
	external/gpl3/gcc/dist/gcc/tree-scalar-evolution.c
	external/gpl3/gcc/dist/gcc/tree-sra.c
	external/gpl3/gcc/dist/gcc/tree-ssa-copy.c
	external/gpl3/gcc/dist/gcc/tree-ssa-dom.c
	external/gpl3/gcc/dist/gcc/tree-ssa-forwprop.c
	external/gpl3/gcc/dist/gcc/tree-ssa-loop-ch.c
	external/gpl3/gcc/dist/gcc/tree-ssa-loop-ivcanon.c
	external/gpl3/gcc/dist/gcc/tree-ssa-loop-ivopts.c
	external/gpl3/gcc/dist/gcc/tree-ssa-loop-split.c
	external/gpl3/gcc/dist/gcc/tree-ssa-math-opts.c
	external/gpl3/gcc/dist/gcc/tree-ssa-phiopt.c
	external/gpl3/gcc/dist/gcc/tree-ssa-phiprop.c
	external/gpl3/gcc/dist/gcc/tree-ssa-pre.c
	external/gpl3/gcc/dist/gcc/tree-ssa-reassoc.c
	external/gpl3/gcc/dist/gcc/tree-ssa-sccvn.c
	external/gpl3/gcc/dist/gcc/tree-ssa-sccvn.h
	external/gpl3/gcc/dist/gcc/tree-ssa-sink.c
	external/gpl3/gcc/dist/gcc/tree-ssa-strlen.c
	external/gpl3/gcc/dist/gcc/tree-ssa-structalias.c
	external/gpl3/gcc/dist/gcc/tree-ssanames.c
	external/gpl3/gcc/dist/gcc/tree-streamer-in.c
	external/gpl3/gcc/dist/gcc/tree-streamer-out.c
	external/gpl3/gcc/dist/gcc/tree-vect-data-refs.c
	external/gpl3/gcc/dist/gcc/tree-vect-slp.c
	external/gpl3/gcc/dist/gcc/tree-vect-stmts.c
	external/gpl3/gcc/dist/gcc/tree-vrp.c
	external/gpl3/gcc/dist/gcc/tree.c
	external/gpl3/gcc/dist/gcc/tree.h
	external/gpl3/gcc/dist/gcc/valtrack.c
	external/gpl3/gcc/dist/gcc/varasm.c
	external/gpl3/gcc/dist/gcc/xcoffout.c
	external/gpl3/gcc/dist/gcc/xcoffout.h
	external/gpl3/gcc/dist/gcc/brig/ChangeLog
	external/gpl3/gcc/dist/gcc/c/ChangeLog
	external/gpl3/gcc/dist/gcc/c/c-decl.c
	external/gpl3/gcc/dist/gcc/c/c-parser.c
	external/gpl3/gcc/dist/gcc/c/c-tree.h
	external/gpl3/gcc/dist/gcc/c/c-typeck.c
	external/gpl3/gcc/dist/gcc/c-family/ChangeLog
	external/gpl3/gcc/dist/gcc/c-family/c-ada-spec.c
	external/gpl3/gcc/dist/gcc/c-family/c-common.c
	external/gpl3/gcc/dist/gcc/c-family/c-lex.c
	external/gpl3/gcc/dist/gcc/c-family/c-omp.c
	external/gpl3/gcc/dist/gcc/config/darwin-c.c
	external/gpl3/gcc/dist/gcc/config/darwin-driver.c
	external/gpl3/gcc/dist/gcc/config/darwin-protos.h
	external/gpl3/gcc/dist/gcc/config/darwin.c
	external/gpl3/gcc/dist/gcc/config/darwin.h
	external/gpl3/gcc/dist/gcc/config/darwin.opt
	external/gpl3/gcc/dist/gcc/config/darwin10.h
	external/gpl3/gcc/dist/gcc/config/darwin9.h
	external/gpl3/gcc/dist/gcc/config/aarch64/aarch64-c.c
	external/gpl3/gcc/dist/gcc/config/aarch64/aarch64.md
	external/gpl3/gcc/dist/gcc/config/aarch64/cortex-a57-fma-steering.c
	external/gpl3/gcc/dist/gcc/config/aarch64/iterators.md
	external/gpl3/gcc/dist/gcc/config/alpha/alpha.c
	external/gpl3/gcc/dist/gcc/config/arm/arm.c
	external/gpl3/gcc/dist/gcc/config/arm/arm.h
	external/gpl3/gcc/dist/gcc/config/arm/arm.md
	external/gpl3/gcc/dist/gcc/config/arm/constraints.md
	external/gpl3/gcc/dist/gcc/config/arm/neon.md
	external/gpl3/gcc/dist/gcc/config/arm/t-rtems
	external/gpl3/gcc/dist/gcc/config/avr/avr.c
	external/gpl3/gcc/dist/gcc/config/i386/avx2intrin.h
	external/gpl3/gcc/dist/gcc/config/i386/avxintrin.h
	external/gpl3/gcc/dist/gcc/config/i386/cpuid.h
	external/gpl3/gcc/dist/gcc/config/i386/darwin.h
	external/gpl3/gcc/dist/gcc/config/i386/darwin32-biarch.h
	external/gpl3/gcc/dist/gcc/config/i386/darwin64-biarch.h
	external/gpl3/gcc/dist/gcc/config/i386/darwin64.h
	external/gpl3/gcc/dist/gcc/config/i386/emmintrin.h
	external/gpl3/gcc/dist/gcc/config/i386/i386-builtin.def
	external/gpl3/gcc/dist/gcc/config/i386/i386.c
	external/gpl3/gcc/dist/gcc/config/i386/i386.h
	external/gpl3/gcc/dist/gcc/config/i386/i386.md
	external/gpl3/gcc/dist/gcc/config/i386/sse.md
	external/gpl3/gcc/dist/gcc/config/i386/t-darwin
	external/gpl3/gcc/dist/gcc/config/i386/t-darwin32-biarch
	external/gpl3/gcc/dist/gcc/config/i386/t-darwin64
	external/gpl3/gcc/dist/gcc/config/i386/t-darwin64-biarch
	external/gpl3/gcc/dist/gcc/config/nvptx/nvptx.c
	external/gpl3/gcc/dist/gcc/config/pa/pa.c
	external/gpl3/gcc/dist/gcc/config/pa/pa.md
	external/gpl3/gcc/dist/gcc/config/rs6000/altivec.h
	external/gpl3/gcc/dist/gcc/config/rs6000/altivec.md
	external/gpl3/gcc/dist/gcc/config/rs6000/crypto.md
	external/gpl3/gcc/dist/gcc/config/rs6000/darwin.h
	external/gpl3/gcc/dist/gcc/config/rs6000/darwin.md
	external/gpl3/gcc/dist/gcc/config/rs6000/darwin32-biarch.h
	external/gpl3/gcc/dist/gcc/config/rs6000/darwin64-biarch.h
	external/gpl3/gcc/dist/gcc/config/rs6000/darwin64.h
	external/gpl3/gcc/dist/gcc/config/rs6000/darwin7.h
	external/gpl3/gcc/dist/gcc/config/rs6000/rs6000-builtin.def
	external/gpl3/gcc/dist/gcc/config/rs6000/rs6000-c.c
	external/gpl3/gcc/dist/gcc/config/rs6000/rs6000.c
	external/gpl3/gcc/dist/gcc/config/rs6000/rs6000.md
	external/gpl3/gcc/dist/gcc/config/rs6000/t-darwin32-biarch
	external/gpl3/gcc/dist/gcc/config/rs6000/t-darwin64
	external/gpl3/gcc/dist/gcc/config/rs6000/t-darwin64-biarch
	external/gpl3/gcc/dist/gcc/config/rs6000/t-darwin8
	external/gpl3/gcc/dist/gcc/config/rs6000/t-linux
	external/gpl3/gcc/dist/gcc/config/rs6000/vsx.md
	external/gpl3/gcc/dist/gcc/config/s390/s390-builtins.def
	external/gpl3/gcc/dist/gcc/config/s390/s390.c
	external/gpl3/gcc/dist/gcc/config/s390/s390.md
	external/gpl3/gcc/dist/gcc/config/s390/vector.md
	external/gpl3/gcc/dist/gcc/config/s390/vx-builtins.md
	external/gpl3/gcc/dist/gcc/config/sh/sh.c
	external/gpl3/gcc/dist/gcc/config/sh/sh.h
	external/gpl3/gcc/dist/gcc/config/sh/sh.md
	external/gpl3/gcc/dist/gcc/config/sparc/sparc.c
	external/gpl3/gcc/dist/gcc/config/sparc/sparc.md
	external/gpl3/gcc/dist/gcc/config/xtensa/xtensa.c
	external/gpl3/gcc/dist/gcc/cp/ChangeLog
	external/gpl3/gcc/dist/gcc/cp/call.c
	external/gpl3/gcc/dist/gcc/cp/class.c
	external/gpl3/gcc/dist/gcc/cp/config-lang.in
	external/gpl3/gcc/dist/gcc/cp/constexpr.c
	external/gpl3/gcc/dist/gcc/cp/cp-tree.h
	external/gpl3/gcc/dist/gcc/cp/decl.c
	external/gpl3/gcc/dist/gcc/cp/decl2.c
	external/gpl3/gcc/dist/gcc/cp/init.c
	external/gpl3/gcc/dist/gcc/cp/lambda.c
	external/gpl3/gcc/dist/gcc/cp/optimize.c
	external/gpl3/gcc/dist/gcc/cp/parser.c
	external/gpl3/gcc/dist/gcc/cp/pt.c
	external/gpl3/gcc/dist/gcc/cp/semantics.c
	external/gpl3/gcc/dist/gcc/cp/typeck.c
	external/gpl3/gcc/dist/gcc/cp/vtable-class-hierarchy.c
	external/gpl3/gcc/dist/gcc/doc/cpp.1
	external/gpl3/gcc/dist/gcc/doc/cpp.info
	external/gpl3/gcc/dist/gcc/doc/cppinternals.info
	external/gpl3/gcc/dist/gcc/doc/extend.texi
	external/gpl3/gcc/dist/gcc/doc/fsf-funding.7
	external/gpl3/gcc/dist/gcc/doc/g++.1
	external/gpl3/gcc/dist/gcc/doc/gcc.1
	external/gpl3/gcc/dist/gcc/doc/gcc.info
	external/gpl3/gcc/dist/gcc/doc/gccinstall.info
	external/gpl3/gcc/dist/gcc/doc/gccint.info
	external/gpl3/gcc/dist/gcc/doc/gcov-dump.1
	external/gpl3/gcc/dist/gcc/doc/gcov-tool.1
	external/gpl3/gcc/dist/gcc/doc/gcov.1
	external/gpl3/gcc/dist/gcc/doc/gfdl.7
	external/gpl3/gcc/dist/gcc/doc/gfortran.1
	external/gpl3/gcc/dist/gcc/doc/gpl.7
	external/gpl3/gcc/dist/gcc/doc/invoke.texi
	external/gpl3/gcc/dist/gcc/doc/sourcebuild.texi
	external/gpl3/gcc/dist/gcc/jit/ChangeLog
	external/gpl3/gcc/dist/gcc/lto/ChangeLog
	external/gpl3/gcc/dist/gcc/objc/ChangeLog
	external/gpl3/gcc/dist/gcc/objc/objc-act.c
	external/gpl3/gcc/dist/gcc/objc/objc-act.h
	external/gpl3/gcc/dist/gcc/objcp/ChangeLog
	external/gpl3/gcc/dist/gcc/objcp/config-lang.in
	external/gpl3/gcc/dist/include/ChangeLog
	external/gpl3/gcc/dist/intl/ChangeLog
	external/gpl3/gcc/dist/libbacktrace/ChangeLog
	external/gpl3/gcc/dist/libcc1/ChangeLog
	external/gpl3/gcc/dist/libcpp/ChangeLog
	external/gpl3/gcc/dist/libcpp/line-map.c
	external/gpl3/gcc/dist/libdecnumber/ChangeLog
	external/gpl3/gcc/dist/libgcc/ChangeLog
	external/gpl3/gcc/dist/libgcc/config.host
	external/gpl3/gcc/dist/libgcc/config/t-darwin
	external/gpl3/gcc/dist/libgcc/config/libbid/ChangeLog
	external/gpl3/gcc/dist/libgcc/config/rs6000/darwin-vecsave.S
	external/gpl3/gcc/dist/libgcc/config/rs6000/t-darwin
	external/gpl3/gcc/dist/libgcc/config/rs6000/t-darwin64
	external/gpl3/gcc/dist/libgomp/ChangeLog
	external/gpl3/gcc/dist/libgomp/plugin/plugin-hsa.c
	external/gpl3/gcc/dist/libhsail-rt/ChangeLog
	external/gpl3/gcc/dist/libiberty/ChangeLog
	external/gpl3/gcc/dist/libiberty/simple-object-elf.c
	external/gpl3/gcc/dist/libobjc/ChangeLog
	external/gpl3/gcc/dist/libsanitizer/ChangeLog
	external/gpl3/gcc/dist/libssp/ChangeLog
	external/gpl3/gcc/dist/libstdc++-v3/ChangeLog
	external/gpl3/gcc/dist/libstdc++-v3/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/acinclude.m4
	external/gpl3/gcc/dist/libstdc++-v3/configure
	external/gpl3/gcc/dist/libstdc++-v3/configure.ac
	external/gpl3/gcc/dist/libstdc++-v3/configure.host
	external/gpl3/gcc/dist/libstdc++-v3/doc/Makefile.am
	external/gpl3/gcc/dist/libstdc++-v3/doc/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/doc/html/manual/documentation_hacking.html
	external/gpl3/gcc/dist/libstdc++-v3/doc/html/manual/memory.html
	external/gpl3/gcc/dist/libstdc++-v3/doc/html/manual/status.html
	external/gpl3/gcc/dist/libstdc++-v3/doc/xml/manual/allocator.xml
	external/gpl3/gcc/dist/libstdc++-v3/doc/xml/manual/documentation_hacking.xml
	external/gpl3/gcc/dist/libstdc++-v3/doc/xml/manual/shared_ptr.xml
	external/gpl3/gcc/dist/libstdc++-v3/doc/xml/manual/status_cxx2017.xml
	external/gpl3/gcc/dist/libstdc++-v3/include/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/include/bits/char_traits.h
	external/gpl3/gcc/dist/libstdc++-v3/include/bits/forward_list.tcc
	external/gpl3/gcc/dist/libstdc++-v3/include/bits/random.h
	external/gpl3/gcc/dist/libstdc++-v3/include/bits/stl_uninitialized.h
	external/gpl3/gcc/dist/libstdc++-v3/include/bits/unique_ptr.h
	external/gpl3/gcc/dist/libstdc++-v3/include/experimental/any
	external/gpl3/gcc/dist/libstdc++-v3/include/experimental/type_traits
	external/gpl3/gcc/dist/libstdc++-v3/include/experimental/bits/fs_path.h
	external/gpl3/gcc/dist/libstdc++-v3/include/std/any
	external/gpl3/gcc/dist/libstdc++-v3/include/std/optional
	external/gpl3/gcc/dist/libstdc++-v3/include/std/variant
	external/gpl3/gcc/dist/libstdc++-v3/libsupc++/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/libsupc++/cxxabi.h
	external/gpl3/gcc/dist/libstdc++-v3/libsupc++/guard_error.cc
	external/gpl3/gcc/dist/libstdc++-v3/libsupc++/hash_bytes.cc
	external/gpl3/gcc/dist/libstdc++-v3/libsupc++/new_opa.cc
	external/gpl3/gcc/dist/libstdc++-v3/python/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/python/libstdcxx/v6/xmethods.py
	external/gpl3/gcc/dist/libstdc++-v3/scripts/make_exports.pl
	external/gpl3/gcc/dist/libstdc++-v3/src/Makefile.am
	external/gpl3/gcc/dist/libstdc++-v3/src/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/src/c++11/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/src/c++17/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/src/c++98/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/src/filesystem/Makefile.in
	external/gpl3/gcc/dist/libstdc++-v3/src/filesystem/path.cc
	external/gpl3/gcc/dist/lto-plugin/ChangeLog
	external/gpl3/gcc/dist/maintainer-scripts/ChangeLog
	external/gpl3/gcc/lib/libgcc/arch/powerpc64/auto-target.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/aarch64/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/alpha/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/arm/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/armeb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earm/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmeb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmhf/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmhfeb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv4/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv4eb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv6/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv6eb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv6hf/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv6hfeb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv7/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv7eb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv7hf/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/earmv7hfeb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/hppa/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/i386/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/ia64/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/m68000/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/m68k/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/mips64eb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/mips64el/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/mipseb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/mipsel/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/powerpc/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/powerpc64/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/riscv32/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/riscv64/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/sh3eb/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/sh3el/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/sparc/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/sparc64/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/vax/gcov-iov.h
	external/gpl3/gcc/lib/libgcc/libgcov/arch/x86_64/gcov-iov.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/aarch64/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/aarch64/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/alpha/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/alpha/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/arm/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/arm/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/armeb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/armeb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earm/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earm/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmeb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmeb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmhf/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmhf/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmhfeb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmhfeb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv4/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv4/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv4eb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv4eb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6eb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6eb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6hf/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6hf/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6hfeb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv6hfeb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7eb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7eb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7hf/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7hf/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7hfeb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7hfeb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/hppa/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/hppa/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/i386/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/i386/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/ia64/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/ia64/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/m68000/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/m68000/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/m68k/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/m68k/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mips64eb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mips64eb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mips64el/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mips64el/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mipseb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mipseb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mipsel/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/mipsel/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/powerpc/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/powerpc/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/powerpc64/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/powerpc64/defs.mk
	external/gpl3/gcc/lib/libstdc++-v3/arch/powerpc64/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/riscv32/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/riscv32/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/riscv64/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/riscv64/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sh3eb/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sh3eb/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sh3el/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sh3el/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sparc/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sparc/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sparc64/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/sparc64/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/vax/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/vax/gstdint.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/x86_64/c++config.h
	external/gpl3/gcc/lib/libstdc++-v3/arch/x86_64/gstdint.h
	external/gpl3/gcc/usr.bin/common/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/aarch64/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/aarch64/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/aarch64/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/aarch64/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/aarch64/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/alpha/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/alpha/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/alpha/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/alpha/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/alpha/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/arm/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/arm/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/arm/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/arm/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/arm/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/armeb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/armeb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/armeb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/armeb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/armeb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earm/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earm/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earm/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earm/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earm/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmeb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmeb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmeb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmeb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmeb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmhf/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmhf/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmhf/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmhf/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmhf/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmhfeb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmhfeb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmhfeb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmhfeb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmhfeb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4eb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4eb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4eb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4eb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv4eb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6eb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6eb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6eb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6eb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6eb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hf/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hf/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hf/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hf/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hf/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hfeb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hfeb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hfeb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hfeb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv6hfeb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7eb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7eb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7eb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7eb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7eb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hf/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hf/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hf/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hf/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hf/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hfeb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hfeb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hfeb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hfeb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/earmv7hfeb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/hppa/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/hppa/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/hppa/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/hppa/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/hppa/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/i386/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/i386/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/i386/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/i386/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/i386/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/ia64/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/ia64/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/ia64/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/ia64/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/ia64/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/m68000/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/m68000/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/m68000/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/m68000/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/m68000/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/m68k/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/m68k/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/m68k/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/m68k/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/m68k/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/mips64eb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/mips64eb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/mips64eb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/mips64eb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/mips64eb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/mips64el/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/mips64el/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/mips64el/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/mips64el/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/mips64el/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/mipseb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/mipseb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/mipseb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/mipseb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/mipseb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/mipsel/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/mipsel/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/mipsel/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/mipsel/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/mipsel/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc64/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc64/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc64/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc64/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/powerpc64/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/riscv32/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/riscv32/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/riscv32/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/riscv32/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/riscv32/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/riscv64/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/riscv64/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/riscv64/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/riscv64/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/riscv64/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/sh3eb/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/sh3eb/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/sh3eb/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/sh3eb/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/sh3eb/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/sh3el/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/sh3el/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/sh3el/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/sh3el/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/sh3el/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/sparc/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/sparc/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/sparc/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/sparc/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/sparc/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/sparc64/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/sparc64/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/sparc64/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/sparc64/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/sparc64/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/vax/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/vax/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/vax/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/vax/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/vax/plugin-version.h
	external/gpl3/gcc/usr.bin/gcc/arch/x86_64/bversion.h
	external/gpl3/gcc/usr.bin/gcc/arch/x86_64/configargs.h
	external/gpl3/gcc/usr.bin/gcc/arch/x86_64/defs.mk
	external/gpl3/gcc/usr.bin/gcc/arch/x86_64/gtyp-input.list
	external/gpl3/gcc/usr.bin/gcc/arch/x86_64/plugin-version.h

Import GCC 7.5.0.
@
text
@d54 1
a54 1
#define __cpp_lib_optional 201606L
@


1.1.1.2
log
@import GCC 8.3.  it includes these new features:
- many optimisations improved: inter-procedural, profile-directed,
  LTO, loops including user-controllable unroll support, and more.
- columns numbers added to line numbers in dwarf
- gcov extended significantly
- many sanitizer updates
- many new warning messages
- many better hints and more useful error messages
- minor ABI changes on x86-64 libstdc++, and some c++17 modes
- draft c++2a features
- better c++17 experimental support
- Armv8.4-A supported, better 8.2-A and 8.3-A support, including
  32 bit arm port.  cortex a-55, a-75 and a-55.a-75 combo support.
- in the GCC bugzilla, 8.1 shows 1149 bugs fixed, 8.2 shows 100, and
  8.3 shows 158.
@
text
@d3 1
a3 1
// Copyright (C) 2013-2018 Free Software Foundation, Inc.
a84 1

d86 1
a86 1
    { return "bad optional access"; }
d101 1
a101 1
  // Payload for optionals with non-trivial destructor.
d103 5
a107 8
	    bool /*_HasTrivialDestructor*/ =
	      is_trivially_destructible_v<_Tp>,
	    bool /*_HasTrivialCopy */ =
	      is_trivially_copy_assignable_v<_Tp>
	      && is_trivially_copy_constructible_v<_Tp>,
	    bool /*_HasTrivialMove */ =
	      is_trivially_move_assignable_v<_Tp>
	      && is_trivially_move_constructible_v<_Tp>>
d110 2
a111 1
      constexpr _Optional_payload() noexcept : _M_empty() { }
d113 5
a117 4
      template <typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { }
d120 2
a121 3
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
d123 1
a123 2
	  _M_engaged(true)
	{ }
d125 1
a125 4
      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
      : _Optional_payload(__other)
      { }
d127 5
a131 4
      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
      : _Optional_payload(std::move(__other))
      { }
d133 3
a135 6
      constexpr
      _Optional_payload(const _Optional_payload& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(__other._M_payload);
      }
d137 4
a140 6
      constexpr
      _Optional_payload(_Optional_payload&& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(std::move(__other._M_payload));
      }
d142 15
a156 33
      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
      {
        if (this->_M_engaged && __other._M_engaged)
          this->_M_get() = __other._M_get();
        else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(__other._M_get());
	    else
	      this->_M_reset();
	  }
	return *this;
      }

      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
		      is_nothrow_move_assignable<_Tp>>())
      {
	if (this->_M_engaged && __other._M_engaged)
	  this->_M_get() = std::move(__other._M_get());
	else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(std::move(__other._M_get()));
	    else
	      this->_M_reset();
	  }
	return *this;
      }
a158 1

a159 1

a164 37

      ~_Optional_payload()
      {
        if (_M_engaged)
          _M_payload.~_Stored_type();
      }

      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new ((void *) std::__addressof(this->_M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_engaged = true;
        }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }

      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
      {
	if (this->_M_engaged)
	  {
	    this->_M_engaged = false;
	    this->_M_payload.~_Stored_type();
	  }
      }
d167 1
a167 1
  // Payload for potentially-constexpr optionals.
d169 1
a169 1
    struct _Optional_payload<_Tp, true, true, true>
d171 2
a172 2
      constexpr _Optional_payload() noexcept
      : _M_empty(), _M_engaged(false) { }
d174 4
a177 5
      template<typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...), _M_engaged(true)
	{ }
d180 2
a181 3
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
d183 1
a183 3
	  _M_engaged(true)
	{ }

d186 2
a187 5
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(__other._M_get());
      }
d191 2
a192 38
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(std::move(__other._M_get()));
      }

      using _Stored_type = remove_const_t<_Tp>;

      struct _Empty_byte { };

      union {
	  _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged;

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }
    };

  // Payload for optionals with non-trivial copy assignment.
  template <typename _Tp>
    struct _Optional_payload<_Tp, true, false, true>
    {
      constexpr _Optional_payload() noexcept
      : _M_empty(), _M_engaged(false) { }

      template<typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...), _M_engaged(true)
	{ }
d194 1
a194 11
      template<typename _Up, typename... _Args>
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true)
	{ }

      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
      : _M_engaged(__engaged)
d196 2
a197 2
	if (__engaged)
	  _M_construct(__other._M_get());
d200 1
a200 3
      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
      : _M_engaged(__engaged)
d202 2
a203 2
	if (__engaged)
	  _M_construct(std::move(__other._M_get()));
a205 22
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;

      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
      {
        if (this->_M_engaged && __other._M_engaged)
          this->_M_get() = __other._M_get();
        else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(__other._M_get());
	    else
	      this->_M_reset();
	  }
	return *this;
      }

      _Optional_payload&
      operator=(_Optional_payload&& __other) = default;

a206 1

a207 1

d212 1
a212 1
      bool _M_engaged;
d214 1
a214 23
      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new ((void *) std::__addressof(this->_M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_engaged = true;
        }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }

      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
d216 2
a217 5
	if (this->_M_engaged)
	  {
	    this->_M_engaged = false;
	    this->_M_payload.~_Stored_type();
	  }
a218 73
    };

  // Payload for optionals with non-trivial move assignment.
  template <typename _Tp>
    struct _Optional_payload<_Tp, true, true, false>
    {
      constexpr _Optional_payload() noexcept
      : _M_empty(), _M_engaged(false) { }

      template<typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...),
	  _M_engaged(true)
	{ }

      template<typename _Up, typename... _Args>
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true)
	{ }

      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(__other._M_get());
      }

      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(std::move(__other._M_get()));
      }

      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;

      _Optional_payload&
      operator=(const _Optional_payload& __other) = default;

      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
		      is_nothrow_move_assignable<_Tp>>())
      {
	if (this->_M_engaged && __other._M_engaged)
	  this->_M_get() = std::move(__other._M_get());
	else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(std::move(__other._M_get()));
	    else
	      this->_M_reset();
	  }
	return *this;
      }

      using _Stored_type = remove_const_t<_Tp>;

      struct _Empty_byte { };

      union {
          _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged;
a228 21

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }

      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
      {
	if (this->_M_engaged)
	  {
	    this->_M_engaged = false;
	    this->_M_payload.~_Stored_type();
	  }
      }
d231 1
a231 1
  // Payload for optionals with non-trivial copy and move assignment.
d233 1
a233 1
    struct _Optional_payload<_Tp, true, false, false>
d235 2
a236 2
      constexpr _Optional_payload() noexcept
      : _M_empty(), _M_engaged(false) {}
d238 2
a239 3
      template<typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
d241 1
a241 2
	  _M_engaged(true)
	{ }
d244 2
a245 3
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
d247 1
a247 3
	  _M_engaged(true)
	{ }

d250 2
a251 5
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(__other._M_get());
      }
d255 2
a256 5
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(std::move(__other._M_get()));
      }
d258 1
a258 6
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;

      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
d260 2
a261 10
        if (this->_M_engaged && __other._M_engaged)
          this->_M_get() = __other._M_get();
        else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(__other._M_get());
	    else
	      this->_M_reset();
	  }
	return *this;
d264 1
a264 5
      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
		      is_nothrow_move_assignable<_Tp>>())
d266 2
a267 10
	if (this->_M_engaged && __other._M_engaged)
	  this->_M_get() = std::move(__other._M_get());
	else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(std::move(__other._M_get()));
	    else
	      this->_M_reset();
	  }
	return *this;
a270 1

a271 1

d276 1
a276 1
      bool _M_engaged;
a286 21

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }

      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
      {
	if (this->_M_engaged)
	  {
	    this->_M_engaged = false;
	    this->_M_payload.~_Stored_type();
	  }
      }
a288 36
  template<typename _Tp, typename _Dp>
    class _Optional_base_impl
    {
    protected:
      using _Stored_type = remove_const_t<_Tp>;
      
      // The _M_construct operation has !_M_engaged as a precondition
      // while _M_destruct has _M_engaged as a precondition.
      template<typename... _Args>
	void
	_M_construct(_Args&&... __args)
	noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
	{
	  ::new
	    (std::__addressof(static_cast<_Dp*>(this)->_M_payload._M_payload))
	    _Stored_type(std::forward<_Args>(__args)...);
	  static_cast<_Dp*>(this)->_M_payload._M_engaged = true;
	}
      
      void
      _M_destruct() noexcept
      {
	static_cast<_Dp*>(this)->_M_payload._M_engaged = false;
	static_cast<_Dp*>(this)->_M_payload._M_payload.~_Stored_type();
      }
      
      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
      {
	if (static_cast<_Dp*>(this)->_M_payload._M_engaged)
	  static_cast<_Dp*>(this)->_M_destruct();
      }
  };

d290 2
a291 2
    * @@brief Class template that takes care of copy/move constructors
    of optional
d294 5
a298 1
    * conditionally make copy/move constructors trivial.
d301 1
a301 3
  template<typename _Tp,
	   bool = is_trivially_copy_constructible_v<_Tp>,
	   bool = is_trivially_move_constructible_v<_Tp>>
a302 2
    // protected inheritance because optional needs to reach that base too
      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
d304 5
a308 1
      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
d311 1
d313 5
a317 1
      constexpr _Optional_base() = default;
d350 2
a351 11
      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

    protected:

      constexpr bool _M_is_engaged() const noexcept
      { return this->_M_payload._M_engaged; }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
	_M_get() noexcept
d353 9
a361 3
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
      }
d363 1
a363 5
      constexpr const _Tp&
	_M_get() const noexcept
      {
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
d366 4
a369 52
    private:
      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
    class _Optional_base<_Tp, false, true>
      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {
      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
    public:

      // Constructors for disengaged optionals.
      constexpr _Optional_base() = default;

      // Constructors for engaged optionals.
      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
		     std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
		     __il, std::forward<_Args>(__args)...)
        { }

      // Copy and move constructors.
      constexpr _Optional_base(const _Optional_base& __other)
	: _M_payload(__other._M_payload._M_engaged,
		     __other._M_payload)
      { }

      constexpr _Optional_base(_Optional_base&& __other) = default;

      // Assignment operators.
      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

    protected:

      constexpr bool _M_is_engaged() const noexcept
      { return this->_M_payload._M_engaged; }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
	_M_get() noexcept
d371 10
a380 9
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
      }

      constexpr const _Tp&
	_M_get() const noexcept
      {
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
d382 2
a383 46

    private:
      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
    class _Optional_base<_Tp, true, false>
      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {
      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
    public:

      // Constructors for disengaged optionals.
      constexpr _Optional_base() = default;

      // Constructors for engaged optionals.
      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
		     std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
		     __il, std::forward<_Args>(__args)...)
        { }

      // Copy and move constructors.
      constexpr _Optional_base(const _Optional_base& __other) = default;

      constexpr _Optional_base(_Optional_base&& __other)
      noexcept(is_nothrow_move_constructible<_Tp>())
	: _M_payload(__other._M_payload._M_engaged,
		     std::move(__other._M_payload))
      { }

      // Assignment operators.
      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

a384 1

d390 2
a391 5
	_M_get() noexcept
      {
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
      }
d394 2
a395 5
	_M_get() const noexcept
      {
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
      }
d397 11
a407 3
    private:
      _Optional_payload<_Tp> _M_payload;
    };
d409 2
a410 44
  template<typename _Tp>
    class _Optional_base<_Tp, true, true>
      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {
      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
    public:

      // Constructors for disengaged optionals.
      constexpr _Optional_base() = default;

      // Constructors for engaged optionals.
      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
		     std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
		     __il, std::forward<_Args>(__args)...)
        { }

      // Copy and move constructors.
      constexpr _Optional_base(const _Optional_base& __other) = default;
      constexpr _Optional_base(_Optional_base&& __other) = default;

      // Assignment operators.
      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

    protected:

      constexpr bool _M_is_engaged() const noexcept
      { return this->_M_payload._M_engaged; }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
	_M_get() noexcept
d412 2
a413 2
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
d416 3
a418 2
      constexpr const _Tp&
	_M_get() const noexcept
d420 2
a421 2
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
d467 4
a470 3
      static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>);
      static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>);
      static_assert(!is_reference_v<_Tp>);
d480 2
a481 1
      constexpr optional(nullopt_t) noexcept { }
a694 1
      constexpr
d761 3
a763 2
	  static_assert(is_copy_constructible_v<_Tp>);
	  static_assert(is_convertible_v<_Up&&, _Tp>);
d774 3
a776 2
	  static_assert(is_move_constructible_v<_Tp>);
	  static_assert(is_convertible_v<_Up&&, _Tp>);
d1028 2
a1029 2
      using result_type [[__deprecated__]] = size_t;
      using argument_type [[__deprecated__]] = optional<_Tp>;
a1031 4
  template<typename _Tp>
    struct __is_fast_hash<hash<optional<_Tp>>> : __is_fast_hash<hash<_Tp>>
    { };

@


1.1.1.3
log
@import GCC 8.4.  it fixes at least these 210 PRs in GCC bugzilla:

90095 93348 89906 89766 86747 87770 89588 89753 88235 89762 89684 89946
89965 90010 90026 90733 90810 90840 90842 90867 91623 92930 93073 93402
93505 93576 93744 93820 93908 85762 86429 86521 87327 87480 87513 87554
87685 87748 88183 88380 88394 88419 88690 88820 89381 89422 89576 89831
89917 90951 92003 92852 93140 80791 89358 89970 90899 89212 89419 92745
93684 93789 88273 91826 92376 84746 89497 89595 89664 89711 89725 90018
90316 90900 91108 91293 91772 92763 93054 93246 90313 92420 93434 93767
88530 89517 91838 79262 84680 85459 85711 85860 86567 87008 87651 87652
88469 89546 89827 90197 93072 93241 81800 89190 85400 91472 91854 92095
92131 92575 93704 60228 61414 65782 89405 89498 89703 89752 90187 90193
90898 91401 91450 91665 92296 92384 92438 92615 92648 92723 92732 92904
93087 93228 93515 93905 82081 92859 89712 89876 92106 82645 78552 81266
85965 89102 90165 90299 90532 91436 92059 93205 93325 93562 90359 91280
91375 92674 92704 93439 92768 80938 83361 90563 92113 92961 87833 89848
89902 89903 92022 93828 78179 79221 82920 84016 87015 88075 89077 89266
90454 90634 91226 92154 92664 92886 93065 92692 92629 80590 91944 92899
92977 93463 89601 88025 91660 91845 90498 91077 84487 86119 89174 89981
91550 92569 84135 84974 90872 93714
@
text
@d54 1
a54 1
#define __cpp_lib_optional 201606L
d1259 1
a1259 1
	constexpr _Tp
@


1.1.1.4
log
@import GCC 7.5.0.  doing this here so that the vendor branch has
the code we'll merge into gcc.old and the netbsd-9 tree gcc tree.
GCC 8.4.0 will be imported immediately on top of this again,
restoring the current status.

these PRs in the GCC bugzilla are fixed with this update:

89869 80693 89795 84272 85593 86669 87148 87647 87895 88103 88107 88563
88870 88976 89002 89187 89195 89234 89303 89314 89354 89361 89403 89412
89512 89520 89590 89621 89663 89679 89704 89734 89872 89933 90090 90208
87075 85870 89009 89242 88167 80864 81933 85890 86608 87145 88857 89024
89119 89214 89511 89612 89705 89400 81740 82186 84552 86554 87609 88105
88149 88415 88739 88903 89135 89223 89296 89505 89572 89677 89698 89710
90006 90020 90071 90328 90474 91126 91162 91812 91887 90075 88998 89945
87047 87506 88074 88656 88740 91137 89008 84010 89349 91136 91347 91995
89397 87030 60702 78884 85594 87649 87725 88181 88470 88553 88568 88588
88620 88644 88906 88949 89246 89587 89726 89768 89796 89998 90108 90756
90950 91704 88825 88983 86538 51333 89446 90220 91308 92143 89392 90213
90278 91131 91200 91510 89037 91481 87673 88418 88938 88948 90547 27221
58321 61250 67183 67958 77583 83531 86215 88648 88720 88726 89091 89466
89629 90105 90329 90585 90760 90924 91087 89222 81956 71861 35031 69455
81849 82993 85798 88138 88155 88169 88205 88206 88228 88249 88269 88376
77703 80260 82077 86248 88393 90786 57048 66089 66695 67679 68009 71723
72714 84394 85544 87734 88298 90937 91557 63891 64132 65342 68649 68717
71066 71860 71935 77746 78421 78645 78865 78983 79485 79540 85953 88326
89651 90744
@
text
@d3 1
a3 1
// Copyright (C) 2013-2017 Free Software Foundation, Inc.
d85 1
d87 1
a87 1
    {return "bad optional access";}
d102 1
a102 1
  // Payload for constexpr optionals.
d104 8
a111 5
	    bool /*_TrivialCopyMove*/ =
	      is_trivially_copy_constructible<_Tp>::value
	      && is_trivially_move_constructible<_Tp>::value,
	    bool /*_ShouldProvideDestructor*/ =
	      is_trivially_destructible<_Tp>::value>
d114 1
a114 2
      constexpr _Optional_payload()
	: _M_empty() {}
d116 4
a119 5
      template<typename... _Args>
      constexpr _Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...),
	  _M_engaged(true)
      {}
d122 3
a124 2
      constexpr _Optional_payload(std::initializer_list<_Up> __il,
				  _Args&&... __args)
d126 7
a132 1
	  _M_engaged(true) {}
d134 4
a137 1
      template <class _Up> struct __ctor_tag {};
d139 6
a144 5
      constexpr _Optional_payload(__ctor_tag<bool>,
				  const _Tp& __other)
	: _M_payload(__other),
	  _M_engaged(true)
      {}
d146 6
a151 3
      constexpr _Optional_payload(__ctor_tag<void>)
	: _M_empty()
      {}
d153 15
a167 4
      constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
	: _M_payload(std::move(__other)),
	  _M_engaged(true)
      {}
d169 17
a185 15
      constexpr _Optional_payload(bool __engaged,
				  const _Optional_payload& __other)
	: _Optional_payload(__engaged ?
			    _Optional_payload(__ctor_tag<bool>{},
					      __other._M_payload) :
			    _Optional_payload(__ctor_tag<void>{}))
      {}

      constexpr _Optional_payload(bool __engaged,
				  _Optional_payload&& __other)
	: _Optional_payload(__engaged
			    ? _Optional_payload(__ctor_tag<bool>{},
						std::move(__other._M_payload))
			    : _Optional_payload(__ctor_tag<void>{}))
      {}
d188 1
d190 1
d196 37
d235 1
a235 1
  // Payload for non-constexpr optionals with non-trivial destructor.
d237 1
a237 1
    struct _Optional_payload<_Tp, false, false>
d239 2
a240 2
      constexpr _Optional_payload()
	: _M_empty() {}
d242 5
a246 4
      template <typename... _Args>
      constexpr _Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...),
	  _M_engaged(true) {}
d249 3
a251 2
      constexpr _Optional_payload(std::initializer_list<_Up> __il,
				  _Args&&... __args)
d253 3
a255 1
	  _M_engaged(true) {}
d258 5
a262 2
	: _Optional_payload(__other)
      {}
d266 54
a319 2
	: _Optional_payload(std::move(__other))
      {}
d321 3
a323 1
      constexpr _Optional_payload(const _Optional_payload& __other)
d325 2
a326 2
	if (__other._M_engaged)
	  this->_M_construct(__other._M_payload);
d329 6
a334 1
      constexpr _Optional_payload(_Optional_payload&& __other)
d336 10
a345 2
	if (__other._M_engaged)
	  this->_M_construct(std::move(__other._M_payload));
d348 3
d352 1
d354 1
d359 77
a435 1
      bool _M_engaged = false;
d437 5
a441 1
      ~_Optional_payload()
d443 10
a452 2
        if (_M_engaged)
          _M_payload.~_Stored_type();
d455 10
d474 21
d497 1
a497 1
  // Payload for non-constexpr optionals with trivial destructor.
d499 1
a499 1
    struct _Optional_payload<_Tp, false, true>
d501 2
a502 2
      constexpr _Optional_payload()
	: _M_empty() {}
d504 3
a506 2
      template <typename... _Args>
      constexpr _Optional_payload(in_place_t, _Args&&... __args)
d508 2
a509 1
	  _M_engaged(true) {}
d512 3
a514 2
      constexpr _Optional_payload(std::initializer_list<_Up> __il,
				  _Args&&... __args)
d516 3
a518 1
	  _M_engaged(true) {}
d521 5
a525 2
	: _Optional_payload(__other)
      {}
d529 8
a536 2
	: _Optional_payload(std::move(__other))
      {}
d538 3
a540 1
      constexpr _Optional_payload(const _Optional_payload& __other)
d542 10
a551 2
	if (__other._M_engaged)
	  this->_M_construct(__other._M_payload);
d554 5
a558 1
      constexpr _Optional_payload(_Optional_payload&& __other)
d560 10
a569 2
	if (__other._M_engaged)
	  this->_M_construct(std::move(__other._M_payload));
d573 1
d575 1
d580 1
a580 1
      bool _M_engaged = false;
d591 21
d614 36
d651 2
a652 2
    * @@brief Class template that holds the necessary state for @@ref optional
    * and that has the responsibility for construction and the special members.
d655 1
a655 5
    * conditionally enable the special members (e.g. copy/move constructors).
    * Note that this means that @@ref _Optional_base implements the
    * functionality for copy and move assignment, but not for converting
    * assignment.
    *
d658 3
a660 1
  template<typename _Tp>
d662 2
d665 1
a665 5
    private:
      // Remove const to avoid prohibition of reusing object storage for
      // const-qualified types in [3.8/9]. This is strictly internal
      // and even optional itself is oblivious to it.
      using _Stored_type = remove_const_t<_Tp>;
a667 1

d669 1
a669 5
      constexpr _Optional_base() noexcept
      { }

      constexpr _Optional_base(nullopt_t) noexcept
      { }
d702 18
a719 2
      _Optional_base&
      operator=(const _Optional_base& __other)
d721 52
a772 9
        if (this->_M_payload._M_engaged && __other._M_payload._M_engaged)
          this->_M_get() = __other._M_get();
        else
	  {
	    if (__other._M_payload._M_engaged)
	      this->_M_construct(__other._M_get());
	    else
	      this->_M_reset();
	  }
d774 6
a779 1
        return *this;
d782 2
a783 4
      _Optional_base&
      operator=(_Optional_base&& __other)
      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
		      is_nothrow_move_assignable<_Tp>>())
d785 2
a786 10
	if (this->_M_payload._M_engaged && __other._M_payload._M_engaged)
	  this->_M_get() = std::move(__other._M_get());
	else
	  {
	    if (__other._M_payload._M_engaged)
	      this->_M_construct(std::move(__other._M_get()));
	    else
	      this->_M_reset();
	  }
	return *this;
d788 46
a833 2
      // The following functionality is also needed by optional, hence the
      // protected accessibility.
d835 1
d841 5
a845 2
      _M_get() noexcept
      { return this->_M_payload._M_payload; }
d848 47
a894 2
      _M_get() const noexcept
      { return this->_M_payload._M_payload; }
d896 2
a897 11
      // The _M_construct operation has !_M_engaged as a precondition
      // while _M_destruct has _M_engaged as a precondition.
      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new (std::__addressof(this->_M_payload._M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_payload._M_engaged = true;
        }
d899 3
a901 2
      void
      _M_destruct()
d903 2
a904 2
        this->_M_payload._M_engaged = false;
        this->_M_payload._M_payload.~_Stored_type();
d907 2
a908 3
      // _M_reset is a 'safe' operation with no precondition.
      void
      _M_reset()
d910 2
a911 2
        if (this->_M_payload._M_engaged)
          this->_M_destruct();
d957 3
a959 4
      static_assert(__and_<__not_<is_same<remove_cv_t<_Tp>, nullopt_t>>,
			   __not_<is_same<remove_cv_t<_Tp>, in_place_t>>,
			   __not_<is_reference<_Tp>>>(),
                    "Invalid instantiation of optional<T>");
d969 1
a969 2
      constexpr optional(nullopt_t) noexcept
	: _Base(nullopt) { }
d1183 1
d1250 2
a1251 3
	  static_assert(__and_<is_copy_constructible<_Tp>,
			       is_convertible<_Up&&, _Tp>>(),
			"Cannot return value");
d1259 1
a1259 1
	_Tp
d1262 2
a1263 3
	  static_assert(__and_<is_move_constructible<_Tp>,
			       is_convertible<_Up&&, _Tp>>(),
			"Cannot return value" );
d1515 2
a1516 2
      using result_type = size_t;
      using argument_type = optional<_Tp>;
d1519 4
@


1.1.1.5
log
@re-import GCC 8.4.0.
@
text
@d3 1
a3 1
// Copyright (C) 2013-2018 Free Software Foundation, Inc.
a84 1

d86 1
a86 1
    { return "bad optional access"; }
d101 1
a101 1
  // Payload for optionals with non-trivial destructor.
d103 5
a107 8
	    bool /*_HasTrivialDestructor*/ =
	      is_trivially_destructible_v<_Tp>,
	    bool /*_HasTrivialCopy */ =
	      is_trivially_copy_assignable_v<_Tp>
	      && is_trivially_copy_constructible_v<_Tp>,
	    bool /*_HasTrivialMove */ =
	      is_trivially_move_assignable_v<_Tp>
	      && is_trivially_move_constructible_v<_Tp>>
d110 2
a111 1
      constexpr _Optional_payload() noexcept : _M_empty() { }
d113 5
a117 4
      template <typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { }
d120 2
a121 3
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
d123 1
a123 2
	  _M_engaged(true)
	{ }
d125 1
a125 4
      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
      : _Optional_payload(__other)
      { }
d127 5
a131 4
      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
      : _Optional_payload(std::move(__other))
      { }
d133 3
a135 6
      constexpr
      _Optional_payload(const _Optional_payload& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(__other._M_payload);
      }
d137 4
a140 6
      constexpr
      _Optional_payload(_Optional_payload&& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(std::move(__other._M_payload));
      }
d142 15
a156 33
      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
      {
        if (this->_M_engaged && __other._M_engaged)
          this->_M_get() = __other._M_get();
        else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(__other._M_get());
	    else
	      this->_M_reset();
	  }
	return *this;
      }

      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
		      is_nothrow_move_assignable<_Tp>>())
      {
	if (this->_M_engaged && __other._M_engaged)
	  this->_M_get() = std::move(__other._M_get());
	else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(std::move(__other._M_get()));
	    else
	      this->_M_reset();
	  }
	return *this;
      }
a158 1

a159 1

a164 37

      ~_Optional_payload()
      {
        if (_M_engaged)
          _M_payload.~_Stored_type();
      }

      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new ((void *) std::__addressof(this->_M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_engaged = true;
        }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }

      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
      {
	if (this->_M_engaged)
	  {
	    this->_M_engaged = false;
	    this->_M_payload.~_Stored_type();
	  }
      }
d167 1
a167 1
  // Payload for potentially-constexpr optionals.
d169 1
a169 1
    struct _Optional_payload<_Tp, true, true, true>
d171 2
a172 2
      constexpr _Optional_payload() noexcept
      : _M_empty(), _M_engaged(false) { }
d174 4
a177 5
      template<typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...), _M_engaged(true)
	{ }
d180 2
a181 3
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
d183 1
a183 3
	  _M_engaged(true)
	{ }

d186 2
a187 5
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(__other._M_get());
      }
d191 2
a192 38
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(std::move(__other._M_get()));
      }

      using _Stored_type = remove_const_t<_Tp>;

      struct _Empty_byte { };

      union {
	  _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged;

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }
    };

  // Payload for optionals with non-trivial copy assignment.
  template <typename _Tp>
    struct _Optional_payload<_Tp, true, false, true>
    {
      constexpr _Optional_payload() noexcept
      : _M_empty(), _M_engaged(false) { }

      template<typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...), _M_engaged(true)
	{ }
d194 1
a194 11
      template<typename _Up, typename... _Args>
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true)
	{ }

      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
      : _M_engaged(__engaged)
d196 2
a197 2
	if (__engaged)
	  _M_construct(__other._M_get());
d200 1
a200 3
      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
      : _M_engaged(__engaged)
d202 2
a203 2
	if (__engaged)
	  _M_construct(std::move(__other._M_get()));
a205 22
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;

      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
      {
        if (this->_M_engaged && __other._M_engaged)
          this->_M_get() = __other._M_get();
        else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(__other._M_get());
	    else
	      this->_M_reset();
	  }
	return *this;
      }

      _Optional_payload&
      operator=(_Optional_payload&& __other) = default;

a206 1

a207 1

d212 1
a212 1
      bool _M_engaged;
d214 1
a214 23
      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new ((void *) std::__addressof(this->_M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_engaged = true;
        }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }

      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
d216 2
a217 44
	if (this->_M_engaged)
	  {
	    this->_M_engaged = false;
	    this->_M_payload.~_Stored_type();
	  }
      }
    };

  // Payload for optionals with non-trivial move assignment.
  template <typename _Tp>
    struct _Optional_payload<_Tp, true, true, false>
    {
      constexpr _Optional_payload() noexcept
      : _M_empty(), _M_engaged(false) { }

      template<typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...),
	  _M_engaged(true)
	{ }

      template<typename _Up, typename... _Args>
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true)
	{ }

      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(__other._M_get());
      }

      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(std::move(__other._M_get()));
a219 34
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;

      _Optional_payload&
      operator=(const _Optional_payload& __other) = default;

      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
		      is_nothrow_move_assignable<_Tp>>())
      {
	if (this->_M_engaged && __other._M_engaged)
	  this->_M_get() = std::move(__other._M_get());
	else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(std::move(__other._M_get()));
	    else
	      this->_M_reset();
	  }
	return *this;
      }

      using _Stored_type = remove_const_t<_Tp>;

      struct _Empty_byte { };

      union {
          _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged;

a228 21

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }

      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
      {
	if (this->_M_engaged)
	  {
	    this->_M_engaged = false;
	    this->_M_payload.~_Stored_type();
	  }
      }
d231 1
a231 1
  // Payload for optionals with non-trivial copy and move assignment.
d233 1
a233 1
    struct _Optional_payload<_Tp, true, false, false>
d235 2
a236 2
      constexpr _Optional_payload() noexcept
      : _M_empty(), _M_engaged(false) {}
d238 2
a239 3
      template<typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
d241 1
a241 2
	  _M_engaged(true)
	{ }
d244 2
a245 3
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
d247 1
a247 3
	  _M_engaged(true)
	{ }

d250 2
a251 5
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(__other._M_get());
      }
d255 2
a256 8
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(std::move(__other._M_get()));
      }

      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;
d258 1
a258 3
      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
d260 2
a261 10
        if (this->_M_engaged && __other._M_engaged)
          this->_M_get() = __other._M_get();
        else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(__other._M_get());
	    else
	      this->_M_reset();
	  }
	return *this;
d264 1
a264 5
      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
		      is_nothrow_move_assignable<_Tp>>())
d266 2
a267 10
	if (this->_M_engaged && __other._M_engaged)
	  this->_M_get() = std::move(__other._M_get());
	else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(std::move(__other._M_get()));
	    else
	      this->_M_reset();
	  }
	return *this;
a270 1

a271 1

d276 1
a276 1
      bool _M_engaged;
a286 21

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }

      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
      {
	if (this->_M_engaged)
	  {
	    this->_M_engaged = false;
	    this->_M_payload.~_Stored_type();
	  }
      }
a288 36
  template<typename _Tp, typename _Dp>
    class _Optional_base_impl
    {
    protected:
      using _Stored_type = remove_const_t<_Tp>;
      
      // The _M_construct operation has !_M_engaged as a precondition
      // while _M_destruct has _M_engaged as a precondition.
      template<typename... _Args>
	void
	_M_construct(_Args&&... __args)
	noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
	{
	  ::new
	    (std::__addressof(static_cast<_Dp*>(this)->_M_payload._M_payload))
	    _Stored_type(std::forward<_Args>(__args)...);
	  static_cast<_Dp*>(this)->_M_payload._M_engaged = true;
	}
      
      void
      _M_destruct() noexcept
      {
	static_cast<_Dp*>(this)->_M_payload._M_engaged = false;
	static_cast<_Dp*>(this)->_M_payload._M_payload.~_Stored_type();
      }
      
      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
      {
	if (static_cast<_Dp*>(this)->_M_payload._M_engaged)
	  static_cast<_Dp*>(this)->_M_destruct();
      }
  };

d290 2
a291 2
    * @@brief Class template that takes care of copy/move constructors
    of optional
d294 5
a298 1
    * conditionally make copy/move constructors trivial.
d301 1
a301 3
  template<typename _Tp,
	   bool = is_trivially_copy_constructible_v<_Tp>,
	   bool = is_trivially_move_constructible_v<_Tp>>
a302 2
    // protected inheritance because optional needs to reach that base too
      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
d304 5
a308 1
      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
d311 1
d313 5
a317 1
      constexpr _Optional_base() = default;
d350 2
a351 11
      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

    protected:

      constexpr bool _M_is_engaged() const noexcept
      { return this->_M_payload._M_engaged; }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
	_M_get() noexcept
d353 9
a361 3
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
      }
d363 1
a363 5
      constexpr const _Tp&
	_M_get() const noexcept
      {
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
d366 4
a369 52
    private:
      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
    class _Optional_base<_Tp, false, true>
      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {
      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
    public:

      // Constructors for disengaged optionals.
      constexpr _Optional_base() = default;

      // Constructors for engaged optionals.
      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
		     std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
		     __il, std::forward<_Args>(__args)...)
        { }

      // Copy and move constructors.
      constexpr _Optional_base(const _Optional_base& __other)
	: _M_payload(__other._M_payload._M_engaged,
		     __other._M_payload)
      { }

      constexpr _Optional_base(_Optional_base&& __other) = default;

      // Assignment operators.
      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

    protected:

      constexpr bool _M_is_engaged() const noexcept
      { return this->_M_payload._M_engaged; }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
	_M_get() noexcept
d371 10
a380 2
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
d382 2
a383 53

      constexpr const _Tp&
	_M_get() const noexcept
      {
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
      }

    private:
      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
    class _Optional_base<_Tp, true, false>
      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {
      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
    public:

      // Constructors for disengaged optionals.
      constexpr _Optional_base() = default;

      // Constructors for engaged optionals.
      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
		     std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
		     __il, std::forward<_Args>(__args)...)
        { }

      // Copy and move constructors.
      constexpr _Optional_base(const _Optional_base& __other) = default;

      constexpr _Optional_base(_Optional_base&& __other)
      noexcept(is_nothrow_move_constructible<_Tp>())
	: _M_payload(__other._M_payload._M_engaged,
		     std::move(__other._M_payload))
      { }

      // Assignment operators.
      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

a384 1

d390 2
a391 5
	_M_get() noexcept
      {
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
      }
d394 2
a395 5
	_M_get() const noexcept
      {
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
      }
d397 11
a407 3
    private:
      _Optional_payload<_Tp> _M_payload;
    };
d409 2
a410 44
  template<typename _Tp>
    class _Optional_base<_Tp, true, true>
      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {
      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
    public:

      // Constructors for disengaged optionals.
      constexpr _Optional_base() = default;

      // Constructors for engaged optionals.
      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
		     std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
		     __il, std::forward<_Args>(__args)...)
        { }

      // Copy and move constructors.
      constexpr _Optional_base(const _Optional_base& __other) = default;
      constexpr _Optional_base(_Optional_base&& __other) = default;

      // Assignment operators.
      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

    protected:

      constexpr bool _M_is_engaged() const noexcept
      { return this->_M_payload._M_engaged; }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
	_M_get() noexcept
d412 2
a413 2
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
d416 3
a418 2
      constexpr const _Tp&
	_M_get() const noexcept
d420 2
a421 2
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
d467 4
a470 3
      static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>);
      static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>);
      static_assert(!is_reference_v<_Tp>);
d480 2
a481 1
      constexpr optional(nullopt_t) noexcept { }
a694 1
      constexpr
d761 3
a763 2
	  static_assert(is_copy_constructible_v<_Tp>);
	  static_assert(is_convertible_v<_Up&&, _Tp>);
d771 1
a771 1
	constexpr _Tp
d774 3
a776 2
	  static_assert(is_move_constructible_v<_Tp>);
	  static_assert(is_convertible_v<_Up&&, _Tp>);
d1028 2
a1029 2
      using result_type [[__deprecated__]] = size_t;
      using argument_type [[__deprecated__]] = optional<_Tp>;
a1031 4
  template<typename _Tp>
    struct __is_fast_hash<hash<optional<_Tp>>> : __is_fast_hash<hash<_Tp>>
    { };

@


1.1.1.6
log
@initial import of GCC 9.3.0.  changes include:

- live patching support
- shell completion help
- generally better diagnostic output (less verbose/more useful)
- diagnostics and optimisation choices can be emitted in json
- asan memory usage reduction
- many general, and specific to switch, inter-procedure,
  profile and link-time optimisations.  from the release notes:
  "Overall compile time of Firefox 66 and LibreOffice 6.2.3 on
  an 8-core machine was reduced by about 5% compared to GCC 8.3"
- OpenMP 5.0 support
- better spell-guesser
- partial experimental support for c2x and c++2a
- c++17 is no longer experimental
- arm AAPCS GCC 6-8 structure passing bug fixed, may cause
  incompatibility (restored compat with GCC 5 and earlier.)
- openrisc support
@
text
@d3 1
a3 1
// Copyright (C) 2013-2019 Free Software Foundation, Inc.
d101 12
a112 4
  // This class template manages construction/destruction of
  // the contained value for a std::optional.
  template <typename _Tp>
    struct _Optional_payload_base
d114 1
a114 4
      using _Stored_type = remove_const_t<_Tp>;

      _Optional_payload_base() = default;
      ~_Optional_payload_base() = default;
d116 1
a116 1
      template<typename... _Args>
d118 2
a119 4
	_Optional_payload_base(in_place_t __tag, _Args&&... __args)
	: _M_payload(__tag, std::forward<_Args>(__args)...),
	  _M_engaged(true)
	{ }
d123 2
a124 2
	_Optional_payload_base(std::initializer_list<_Up> __il,
			       _Args&&... __args)
a128 2
      // Constructor used by _Optional_base copy constructor when the
      // contained value is not trivially copy constructible.
d130 11
a140 2
      _Optional_payload_base(bool __engaged,
			     const _Optional_payload_base& __other)
d143 1
a143 1
	  this->_M_construct(__other._M_get());
a145 2
      // Constructor used by _Optional_base move constructor when the
      // contained value is not trivially move constructible.
d147 1
a147 2
      _Optional_payload_base(bool __engaged,
			     _Optional_payload_base&& __other)
d150 1
a150 1
	  this->_M_construct(std::move(__other._M_get()));
d153 3
a155 17
      // Copy constructor is only used to when the contained value is
      // trivially copy constructible.
      _Optional_payload_base(const _Optional_payload_base&) = default;

      // Move constructor is only used to when the contained value is
      // trivially copy constructible.
      _Optional_payload_base(_Optional_payload_base&&) = default;

      _Optional_payload_base&
      operator=(const _Optional_payload_base&) = default;

      _Optional_payload_base&
      operator=(_Optional_payload_base&&) = default;

      // used to perform non-trivial copy assignment.
      constexpr void
      _M_copy_assign(const _Optional_payload_base& __other)
d166 1
d169 5
a173 5
      // used to perform non-trivial move assignment.
      constexpr void
      _M_move_assign(_Optional_payload_base&& __other)
      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
		       is_nothrow_move_assignable<_Tp>>)
d184 1
d187 2
d191 5
a195 4
      template<typename _Up, bool = is_trivially_destructible_v<_Up>>
	union _Storage
	{
	  constexpr _Storage() noexcept : _M_empty() { }
d197 5
a201 43
	  template<typename... _Args>
	    constexpr
	    _Storage(in_place_t, _Args&&... __args)
	    : _M_value(std::forward<_Args>(__args)...)
	    { }

	  template<typename _Vp, typename... _Args>
	    constexpr
	    _Storage(std::initializer_list<_Vp> __il, _Args&&... __args)
	    : _M_value(__il, std::forward<_Args>(__args)...)
	    { }

	  _Empty_byte _M_empty;
          _Up _M_value;
	};

      template<typename _Up>
	union _Storage<_Up, false>
	{
	  constexpr _Storage() noexcept : _M_empty() { }

	  template<typename... _Args>
	    constexpr
	    _Storage(in_place_t, _Args&&... __args)
	    : _M_value(std::forward<_Args>(__args)...)
	    { }

	  template<typename _Vp, typename... _Args>
	    constexpr
	    _Storage(std::initializer_list<_Vp> __il, _Args&&... __args)
	    : _M_value(__il, std::forward<_Args>(__args)...)
	    { }

	  // User-provided destructor is needed when _Up has non-trivial dtor.
	  ~_Storage() { }

	  _Empty_byte _M_empty;
          _Up _M_value;
	};

      _Storage<_Stored_type> _M_payload;

      bool _M_engaged = false;
d206 1
a206 1
        noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
d213 1
a213 11
      constexpr void
      _M_destroy() noexcept
      {
	_M_engaged = false;
	_M_payload._M_value.~_Stored_type();
      }

      // The _M_get() operations have _M_engaged as a precondition.
      // They exist to access the contained value with the appropriate
      // const-qualification, because _M_payload has had the const removed.

d216 1
a216 1
      { return this->_M_payload._M_value; }
d220 1
a220 1
      { return this->_M_payload._M_value; }
d223 2
a224 1
      constexpr void
d228 4
a231 1
	  _M_destroy();
d235 1
a235 13
  // Class template that manages the payload for optionals.
  template <typename _Tp,
	    bool /*_HasTrivialDestructor*/ =
	      is_trivially_destructible_v<_Tp>,
	    bool /*_HasTrivialCopy */ =
	      is_trivially_copy_assignable_v<_Tp>
	      && is_trivially_copy_constructible_v<_Tp>,
	    bool /*_HasTrivialMove */ =
	      is_trivially_move_assignable_v<_Tp>
	      && is_trivially_move_constructible_v<_Tp>>
    struct _Optional_payload;

  // Payload for potentially-constexpr optionals (trivial copy/move/destroy).
a237 1
    : _Optional_payload_base<_Tp>
d239 16
a254 1
      using _Optional_payload_base<_Tp>::_Optional_payload_base;
d256 34
a289 1
      _Optional_payload() = default;
d292 1
a292 1
  // Payload for optionals with non-trivial copy construction/assignment.
a294 1
    : _Optional_payload_base<_Tp>
d296 32
a327 1
      using _Optional_payload_base<_Tp>::_Optional_payload_base;
a328 2
      _Optional_payload() = default;
      ~_Optional_payload() = default;
a330 1
      _Optional_payload& operator=(_Optional_payload&&) = default;
a331 1
      // Non-trivial copy assignment.
d336 9
a344 1
	this->_M_copy_assign(__other);
d347 44
d393 1
a393 1
  // Payload for optionals with non-trivial move construction/assignment.
a395 1
    : _Optional_payload_base<_Tp>
d397 33
a429 1
      using _Optional_payload_base<_Tp>::_Optional_payload_base;
a430 2
      _Optional_payload() = default;
      ~_Optional_payload() = default;
a432 1
      _Optional_payload& operator=(const _Optional_payload&) = default;
d434 3
a436 1
      // Non-trivial move assignment.
d440 2
a441 2
      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
		       is_nothrow_move_assignable<_Tp>>)
d443 9
a451 1
	this->_M_move_assign(std::move(__other));
d454 41
a499 1
    : _Optional_payload_base<_Tp>
d501 33
a533 1
      using _Optional_payload_base<_Tp>::_Optional_payload_base;
a534 2
      _Optional_payload() = default;
      ~_Optional_payload() = default;
a537 1
      // Non-trivial copy assignment.
d542 9
a550 1
	this->_M_copy_assign(__other);
a553 1
      // Non-trivial move assignment.
d557 2
a558 2
      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
		       is_nothrow_move_assignable<_Tp>>)
d560 9
a568 1
	this->_M_move_assign(std::move(__other));
a570 1
    };
d572 28
a599 12
  // Payload for optionals with non-trivial destructors.
  template <typename _Tp, bool _Copy, bool _Move>
    struct _Optional_payload<_Tp, false, _Copy, _Move>
    : _Optional_payload<_Tp, true, false, false>
    {
      // Base class implements all the constructors and assignment operators:
      using _Optional_payload<_Tp, true, false, false>::_Optional_payload;
      _Optional_payload() = default;
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;
      _Optional_payload& operator=(const _Optional_payload&) = default;
      _Optional_payload& operator=(_Optional_payload&&) = default;
d601 11
a611 2
      // Destructor needs to destroy the contained value:
      ~_Optional_payload() { this->_M_reset(); }
a613 2
  // Common base class for _Optional_base<T> to avoid repeating these
  // member functions in each specialization.
d619 1
a619 1

d625 1
a625 1
	noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
d632 1
a632 1

d635 5
a639 2
      { static_cast<_Dp*>(this)->_M_payload._M_destroy(); }

d641 2
a642 1
      constexpr void
a643 8
      { static_cast<_Dp*>(this)->_M_payload._M_reset(); }

      constexpr bool _M_is_engaged() const noexcept
      { return static_cast<const _Dp*>(this)->_M_payload._M_engaged; }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
d645 2
a646 2
	__glibcxx_assert(this->_M_is_engaged());
	return static_cast<_Dp*>(this)->_M_payload._M_get();
d648 1
a648 8

      constexpr const _Tp&
      _M_get() const noexcept
      {
	__glibcxx_assert(this->_M_is_engaged());
	return static_cast<const _Dp*>(this)->_M_payload._M_get();
      }
    };
d651 2
a652 1
    * @@brief Class template that provides copy/move constructors of optional.
a655 11
    *
    * When the contained value is trivally copy/move constructible,
    * the copy/move constructors of _Optional_base will invoke the
    * trivial copy/move constructor of _Optional_payload. Otherwise,
    * they will invoke _Optional_payload(bool, const _Optional_payload&)
    * or _Optional_payload(bool, _Optional_payload&&) to initialize
    * the contained value, if copying/moving an engaged optional.
    *
    * Whether the other special members are trivial is determined by the
    * _Optional_payload<_Tp> specialization used for the _M_payload member.
    *
d661 3
a663 2
    struct _Optional_base
      : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
d665 3
d696 1
a696 1
      noexcept(is_nothrow_move_constructible_v<_Tp>)
d705 21
d730 2
a731 2
    struct _Optional_base<_Tp, false, true>
      : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
d733 3
d769 21
d794 2
a795 2
    struct _Optional_base<_Tp, true, false>
      : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
d797 3
d825 1
a825 1
      noexcept(is_nothrow_move_constructible_v<_Tp>)
d834 21
d859 2
a860 2
    struct _Optional_base<_Tp, true, true>
      : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
d862 3
d894 21
d946 10
a955 10
	// Copy constructor.
	is_copy_constructible_v<_Tp>,
	// Copy assignment.
	__and_v<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>,
	// Move constructor.
	is_move_constructible_v<_Tp>,
	// Move assignment.
	__and_v<is_move_constructible<_Tp>, is_move_assignable<_Tp>>,
	// Unique tag type.
	optional<_Tp>>
a963 8
      // SFINAE helpers
      template<typename _Up>
	using __not_self = __not_<is_same<optional, __remove_cvref_t<_Up>>>;
      template<typename _Up>
	using __not_tag = __not_<is_same<in_place_t, __remove_cvref_t<_Up>>>;
      template<typename... _Cond>
	using _Requires = enable_if_t<__and_v<_Cond...>, bool>;

d972 9
a980 7
      template<typename _Up = _Tp,
	       _Requires<__not_self<_Up>, __not_tag<_Up>,
			 is_constructible<_Tp, _Up&&>,
			 is_convertible<_Up&&, _Tp>> = true>
	constexpr
	optional(_Up&& __t)
	: _Base(std::in_place, std::forward<_Up>(__t)) { }
d982 8
a989 6
      template<typename _Up = _Tp,
	       _Requires<__not_self<_Up>, __not_tag<_Up>,
			 is_constructible<_Tp, _Up&&>,
			 __not_<is_convertible<_Up&&, _Tp>>> = false>
	explicit constexpr
	optional(_Up&& __t)
d992 12
a1003 11
      template<typename _Up,
	       _Requires<__not_<is_same<_Tp, _Up>>,
			 is_constructible<_Tp, const _Up&>,
			 is_convertible<const _Up&, _Tp>,
			 __not_<__converts_from_optional<_Tp, _Up>>> = true>
	constexpr
	optional(const optional<_Up>& __t)
	{
	  if (__t)
	    emplace(*__t);
	}
d1005 12
a1016 11
      template<typename _Up,
	       _Requires<__not_<is_same<_Tp, _Up>>,
			 is_constructible<_Tp, const _Up&>,
			 __not_<is_convertible<const _Up&, _Tp>>,
			 __not_<__converts_from_optional<_Tp, _Up>>> = false>
	explicit constexpr
	optional(const optional<_Up>& __t)
	{
	  if (__t)
	    emplace(*__t);
	}
d1019 11
a1029 10
		_Requires<__not_<is_same<_Tp, _Up>>,
			  is_constructible<_Tp, _Up&&>,
			  is_convertible<_Up&&, _Tp>,
			  __not_<__converts_from_optional<_Tp, _Up>>> = true>
	constexpr
	optional(optional<_Up>&& __t)
	{
	  if (__t)
	    emplace(std::move(*__t));
	}
d1032 11
a1042 10
		_Requires<__not_<is_same<_Tp, _Up>>,
			  is_constructible<_Tp, _Up&&>,
			  __not_<is_convertible<_Up&&, _Tp>>,
			  __not_<__converts_from_optional<_Tp, _Up>>> = false>
	explicit constexpr
	optional(optional<_Up>&& __t)
	{
	  if (__t)
	    emplace(std::move(*__t));
	}
d1045 3
a1047 4
	       _Requires<is_constructible<_Tp, _Args&&...>> = false>
	explicit constexpr
	optional(in_place_t, _Args&&... __args)
	: _Base(std::in_place, std::forward<_Args>(__args)...) { }
d1050 7
a1056 6
	       _Requires<is_constructible<_Tp,
					  initializer_list<_Up>&,
					  _Args&&...>> = false>
	explicit constexpr
	optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
	: _Base(std::in_place, __il, std::forward<_Args>(__args)...) { }
d1062 2
a1063 2
	this->_M_reset();
	return *this;
d1067 6
a1072 5
	enable_if_t<__and_v<__not_self<_Up>,
			    __not_<__and_<is_scalar<_Tp>,
					  is_same<_Tp, decay_t<_Up>>>>,
			    is_constructible<_Tp, _Up>,
			    is_assignable<_Tp&, _Up>>,
d1074 6
a1079 6
	operator=(_Up&& __u)
	{
	  if (this->_M_is_engaged())
	    this->_M_get() = std::forward<_Up>(__u);
	  else
	    this->_M_construct(std::forward<_Up>(__u));
d1081 2
a1082 2
	  return *this;
	}
d1085 7
a1091 5
	enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
			    is_constructible<_Tp, const _Up&>,
			    is_assignable<_Tp&, _Up>,
			    __not_<__converts_from_optional<_Tp, _Up>>,
			    __not_<__assigns_from_optional<_Tp, _Up>>>,
d1093 15
a1107 15
	operator=(const optional<_Up>& __u)
	{
	  if (__u)
	    {
	      if (this->_M_is_engaged())
		this->_M_get() = *__u;
	      else
		this->_M_construct(*__u);
	    }
	  else
	    {
	      this->_M_reset();
	    }
	  return *this;
	}
d1110 7
a1116 5
        enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
			    is_constructible<_Tp, _Up>,
			    is_assignable<_Tp&, _Up>,
			    __not_<__converts_from_optional<_Tp, _Up>>,
			    __not_<__assigns_from_optional<_Tp, _Up>>>,
d1118 13
a1130 13
	operator=(optional<_Up>&& __u)
	{
	  if (__u)
	    {
	      if (this->_M_is_engaged())
		this->_M_get() = std::move(*__u);
	      else
		this->_M_construct(std::move(*__u));
	    }
	  else
	    {
	      this->_M_reset();
	    }
d1132 2
a1133 2
	  return *this;
	}
d1136 1
a1136 1
	enable_if_t<is_constructible_v<_Tp, _Args&&...>, _Tp&>
d1145 2
a1146 2
	enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&,
				       _Args&&...>, _Tp&>
d1159 2
a1160 2
      noexcept(is_nothrow_move_constructible_v<_Tp>
	       && is_nothrow_swappable_v<_Tp>)
d1162 1
a1162 1
	using std::swap;
d1164 3
a1166 3
	if (this->_M_is_engaged() && __other._M_is_engaged())
	  swap(this->_M_get(), __other._M_get());
	else if (this->_M_is_engaged())
d1171 1
a1171 1
	else if (__other._M_is_engaged())
d1214 3
a1216 2
	  ? this->_M_get()
	  : (__throw_bad_optional_access(), this->_M_get());
d1223 3
a1225 2
	  ? this->_M_get()
	  : (__throw_bad_optional_access(), this->_M_get());
d1232 3
a1234 2
	  ? std::move(this->_M_get())
	  : (__throw_bad_optional_access(), std::move(this->_M_get()));
d1241 3
a1243 2
	  ? std::move(this->_M_get())
	  : (__throw_bad_optional_access(), std::move(this->_M_get()));
d1254 2
a1255 1
	    ? this->_M_get() : static_cast<_Tp>(std::forward<_Up>(__u));
a1268 1

d1274 1
a1274 1
      enable_if_t<is_convertible<_Tp, bool>::value, bool>;
@


1.1.1.7
log
@initial import of GCC 10.3.0.  main changes include:

caveats:
- ABI issue between c++14 and c++17 fixed
- profile mode is removed from libstdc++
- -fno-common is now the default

new features:
- new flags -fallocation-dce, -fprofile-partial-training,
  -fprofile-reproducible, -fprofile-prefix-path, and -fanalyzer
- many new compile and link time optimisations
- enhanced drive optimisations
- openacc 2.6 support
- openmp 5.0 features
- new warnings: -Wstring-compare and -Wzero-length-bounds
- extended warnings: -Warray-bounds, -Wformat-overflow,
  -Wrestrict, -Wreturn-local-addr, -Wstringop-overflow,
  -Warith-conversion, -Wmismatched-tags, and -Wredundant-tags
- some likely C2X features implemented
- more C++20 implemented
- many new arm & intel CPUs known

hundreds of reported bugs are fixed.  full list of changes
can be found at:

   https://gcc.gnu.org/gcc-10/changes.html
@
text
@d3 1
a3 1
// Copyright (C) 2013-2020 Free Software Foundation, Inc.
d38 1
a38 1
#include <exception>
d41 1
a41 1
#include <bits/exception_defines.h>
a43 3
#if __cplusplus > 201703L
# include <compare>
#endif
d84 1
a84 2
    bad_optional_access() = default;
    virtual ~bad_optional_access() = default;
d86 1
a86 1
    const char* what() const noexcept override
d88 2
d456 1
a456 1
    * When the contained value is trivially copy/move constructible,
d891 2
a892 1
      constexpr _Tp*
a979 30
  template<typename _Tp, typename _Up>
    using __optional_eq_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() == std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_ne_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() != std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_lt_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() < std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_gt_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() > std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_le_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_ge_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>())
      >;

d984 1
a984 1
    -> __optional_eq_t<_Tp, _Up>
d993 1
a993 1
    -> __optional_ne_t<_Tp, _Up>
d1002 1
a1002 1
    -> __optional_lt_t<_Tp, _Up>
d1010 1
a1010 1
    -> __optional_gt_t<_Tp, _Up>
d1018 1
a1018 1
    -> __optional_le_t<_Tp, _Up>
d1026 1
a1026 1
    -> __optional_ge_t<_Tp, _Up>
a1030 9
#ifdef __cpp_lib_three_way_comparison
  template<typename _Tp, three_way_comparable_with<_Tp> _Up>
    constexpr compare_three_way_result_t<_Tp, _Up>
    operator<=>(const optional<_Tp>& __x, const optional<_Up>& __y)
    {
      return __x && __y ? *__x <=> *__y : bool(__x) <=> bool(__y);
    }
#endif

a1036 6
#ifdef __cpp_lib_three_way_comparison
  template<typename _Tp>
    constexpr strong_ordering
    operator<=>(const optional<_Tp>& __x, nullopt_t) noexcept
    { return bool(__x) <=> false; }
#else
a1090 1
#endif // three-way-comparison
d1096 1
a1096 1
    -> __optional_eq_t<_Tp, _Up>
d1102 1
a1102 1
    -> __optional_eq_t<_Up, _Tp>
d1108 1
a1108 1
    -> __optional_ne_t<_Tp, _Up>
d1114 1
a1114 1
    -> __optional_ne_t<_Up, _Tp>
d1120 1
a1120 1
    -> __optional_lt_t<_Tp, _Up>
d1126 1
a1126 1
    -> __optional_lt_t<_Up, _Tp>
d1132 1
a1132 1
    -> __optional_gt_t<_Tp, _Up>
d1138 1
a1138 1
    -> __optional_gt_t<_Up, _Tp>
d1144 1
a1144 1
    -> __optional_le_t<_Tp, _Up>
d1150 1
a1150 1
    -> __optional_le_t<_Up, _Tp>
d1156 1
a1156 1
    -> __optional_ge_t<_Tp, _Up>
d1162 1
a1162 1
    -> __optional_ge_t<_Up, _Tp>
a1164 7
#ifdef __cpp_lib_three_way_comparison
  template<typename _Tp, typename _Up>
    constexpr compare_three_way_result_t<_Tp, _Up>
    operator<=>(const optional<_Tp>& __x, const _Up& __v)
    { return bool(__x) ? *__x <=> __v : strong_ordering::less; }
#endif

@


1.1.1.8
log
@initial import of GCC 10.4.0 sources.

mostly a large list of PRs fixed (210 total), plus one x86-64
specific change related to MMX and 64 bit integer return.

https://gcc.gnu.org/gcc-10/changes.html links to the full list
of PRs fixed.
@
text
@d801 1
a801 1
			    is_assignable<_Tp&, const _Up&>,
a1212 5
  template<typename _Tp>
    inline constexpr bool __is_optional_v = false;
  template<typename _Tp>
    inline constexpr bool __is_optional_v<optional<_Tp>> = true;

a1213 2
    requires (!__is_optional_v<_Up>)
      && three_way_comparable_with<_Tp, _Up>
@


1.1.1.9
log
@initial import of GCC 12.3.0.

major changes in GCC 11 included:

- The default mode for C++ is now -std=gnu++17 instead of -std=gnu++14.
- When building GCC itself, the host compiler must now support C++11,
  rather than C++98.
- Some short options of the gcov tool have been renamed: -i to -j and
  -j to -H.
- ThreadSanitizer improvements.
- Introduce Hardware-assisted AddressSanitizer support.
- For targets that produce DWARF debugging information GCC now defaults
  to DWARF version 5. This can produce up to 25% more compact debug
  information compared to earlier versions.
- Many optimisations.
- The existing malloc attribute has been extended so that it can be
  used to identify allocator/deallocator API pairs. A pair of new
  -Wmismatched-dealloc and -Wmismatched-new-delete warnings are added.
- Other new warnings:
  -Wsizeof-array-div, enabled by -Wall, warns about divisions of two
    sizeof operators when the first one is applied to an array and the
    divisor does not equal the size of the array element.
  -Wstringop-overread, enabled by default, warns about calls to string
    functions reading past the end of the arrays passed to them as
    arguments.
  -Wtsan, enabled by default, warns about unsupported features in
    ThreadSanitizer (currently std::atomic_thread_fence).
- Enchanced warnings:
  -Wfree-nonheap-object detects many more instances of calls to
    deallocation functions with pointers not returned from a dynamic
    memory allocation function.
  -Wmaybe-uninitialized diagnoses passing pointers or references to
    uninitialized memory to functions taking const-qualified arguments.
  -Wuninitialized detects reads from uninitialized dynamically
    allocated memory.
  -Warray-parameter warns about functions with inconsistent array forms.
  -Wvla-parameter warns about functions with inconsistent VLA forms.
- Several new features from the upcoming C2X revision of the ISO C
  standard are supported with -std=c2x and -std=gnu2x.
- Several C++20 features have been implemented.
- The C++ front end has experimental support for some of the upcoming
  C++23 draft.
- Several new C++ warnings.
- Enhanced Arm, AArch64, x86, and RISC-V CPU support.
- The implementation of how program state is tracked within
  -fanalyzer has been completely rewritten with many enhancements.

see https://gcc.gnu.org/gcc-11/changes.html for a full list.

major changes in GCC 12 include:

- An ABI incompatibility between C and C++ when passing or returning
  by value certain aggregates containing zero width bit-fields has
  been discovered on various targets. x86-64, ARM and AArch64
  will always ignore them (so there is a C ABI incompatibility
  between GCC 11 and earlier with GCC 12 or later), PowerPC64 ELFv2
  always take them into account (so there is a C++ ABI
  incompatibility, GCC 4.4 and earlier compatible with GCC 12 or
  later, incompatible with GCC 4.5 through GCC 11). RISC-V has
  changed the handling of these already starting with GCC 10. As
  the ABI requires, MIPS takes them into account handling function
  return values so there is a C++ ABI incompatibility with GCC 4.5
  through 11.
- STABS: Support for emitting the STABS debugging format is
  deprecated and will be removed in the next release. All ports now
  default to emit DWARF (version 2 or later) debugging info or are
  obsoleted.
- Vectorization is enabled at -O2 which is now equivalent to the
  original -O2 -ftree-vectorize -fvect-cost-model=very-cheap.
- GCC now supports the ShadowCallStack sanitizer.
- Support for __builtin_shufflevector compatible with the clang
  language extension was added.
- Support for attribute unavailable was added.
- Support for __builtin_dynamic_object_size compatible with the
  clang language extension was added.
- New warnings:
  -Wbidi-chars warns about potentially misleading UTF-8
    bidirectional control characters.
  -Warray-compare warns about comparisons between two operands of
    array type.
- Some new features from the upcoming C2X revision of the ISO C
  standard are supported with -std=c2x and -std=gnu2x.
- Several C++23 features have been implemented.
- Many C++ enhancements across warnings and -f options.

see https://gcc.gnu.org/gcc-12/changes.html for a full list.
@
text
@d3 1
a3 2
// Copyright (C) 2013-2022 Free Software Foundation, Inc.
// Copyright The GNU Toolchain Authors.
d36 1
a40 1
#include <bits/enable_special_members.h>
d43 1
a43 2
#include <bits/stl_construct.h> // _Construct
#include <bits/utility.h> // in_place_t
a45 4
# include <bits/invoke.h> // std::__invoke
#endif
#if __cplusplus > 202002L
# include <concepts>
d57 1
a57 7
#if __cplusplus > 202002L && __cpp_lib_concepts
# define __cpp_lib_optional 202110L
#elif __cplusplus >= 202002L
# define __cpp_lib_optional 202106L
#else
# define __cpp_lib_optional 201606L
#endif
d73 1
a73 1
    explicit constexpr nullopt_t(_Construct) noexcept { }
a78 2
  template<typename _Fn> struct _Optional_func { _Fn& _M_f; };

d94 4
d99 1
a99 1
  [[__noreturn__]] inline void
d166 3
a168 3
	if (this->_M_engaged && __other._M_engaged)
	  this->_M_get() = __other._M_get();
	else
a212 9
#if __cplusplus >= 202002L
	  template<typename _Fn, typename _Arg>
	    constexpr
	    _Storage(_Optional_func<_Fn> __f, _Arg&& __arg)
	    : _M_value(std::__invoke(std::forward<_Fn>(__f._M_f),
				     std::forward<_Arg>(__arg)))
	    { }
#endif

d214 1
a214 1
	  _Up _M_value;
a233 9
#if __cplusplus >= 202002L
	  template<typename _Fn, typename _Arg>
	    constexpr
	    _Storage(_Optional_func<_Fn> __f, _Arg&& __arg)
	    : _M_value(std::__invoke(std::forward<_Fn>(__f._M_f),
				     std::forward<_Arg>(__arg)))
	    { }
#endif

d235 1
a235 1
	  _GLIBCXX20_CONSTEXPR ~_Storage() { }
d238 1
a238 1
	  _Up _M_value;
d246 8
a253 8
	constexpr void
	_M_construct(_Args&&... __args)
	noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
	{
	  std::_Construct(std::__addressof(this->_M_payload._M_value),
			  std::forward<_Args>(__args)...);
	  this->_M_engaged = true;
	}
a261 11
#if __cplusplus >= 202002L
      template<typename _Fn, typename _Up>
	constexpr void
	_M_apply(_Optional_func<_Fn> __f, _Up&& __x)
	{
	  std::construct_at(std::__addressof(this->_M_payload),
			    __f, std::forward<_Up>(__x));
	  _M_engaged = true;
	}
#endif

d400 1
a400 1
      _GLIBCXX20_CONSTEXPR ~_Optional_payload() { this->_M_reset(); }
d414 1
a414 1
	constexpr void
d418 4
a421 2
	  static_cast<_Dp*>(this)->_M_payload._M_construct(
	    std::forward<_Args>(__args)...);
d424 1
a424 1
      constexpr void
d474 1
a474 1
    : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
d481 4
a484 5
	       enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false>
	constexpr explicit
	_Optional_base(in_place_t, _Args&&... __args)
	: _M_payload(in_place, std::forward<_Args>(__args)...)
	{ }
d487 1
a487 1
	       enable_if_t<is_constructible_v<_Tp,
d489 7
a495 7
					      _Args...>, bool> = false>
	constexpr explicit
	_Optional_base(in_place_t,
		       initializer_list<_Up> __il,
		       _Args&&... __args)
	: _M_payload(in_place, __il, std::forward<_Args>(__args)...)
	{ }
d498 3
a500 3
      constexpr
      _Optional_base(const _Optional_base& __other)
      : _M_payload(__other._M_payload._M_engaged, __other._M_payload)
d503 1
a503 2
      constexpr
      _Optional_base(_Optional_base&& __other)
d505 2
a506 2
      : _M_payload(__other._M_payload._M_engaged,
		   std::move(__other._M_payload))
d518 1
a518 1
    : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
d525 4
a528 5
	       enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false>
	constexpr explicit
	_Optional_base(in_place_t, _Args&&... __args)
	: _M_payload(in_place, std::forward<_Args>(__args)...)
	{ }
d531 1
a531 1
	       enable_if_t<is_constructible_v<_Tp,
d533 7
a539 7
					      _Args...>, bool> = false>
	constexpr explicit
	_Optional_base(in_place_t,
		       initializer_list<_Up> __il,
		       _Args... __args)
	: _M_payload(in_place, __il, std::forward<_Args>(__args)...)
	{ }
d543 2
a544 1
      : _M_payload(__other._M_payload._M_engaged, __other._M_payload)
d558 1
a558 1
    : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
d565 4
a568 5
	       enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false>
	constexpr explicit
	_Optional_base(in_place_t, _Args&&... __args)
	: _M_payload(in_place, std::forward<_Args>(__args)...)
	{ }
d571 1
a571 1
	       enable_if_t<is_constructible_v<_Tp,
d573 7
a579 7
					      _Args...>, bool> = false>
	constexpr explicit
	_Optional_base(in_place_t,
		       initializer_list<_Up> __il,
		       _Args&&... __args)
	: _M_payload(in_place, __il, std::forward<_Args>(__args)...)
	{ }
d584 1
a584 2
      constexpr
      _Optional_base(_Optional_base&& __other)
d586 2
a587 2
      : _M_payload(__other._M_payload._M_engaged,
		   std::move(__other._M_payload))
d599 1
a599 1
    : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
d606 4
a609 5
	       enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false>
	constexpr explicit
	_Optional_base(in_place_t, _Args&&... __args)
	: _M_payload(in_place, std::forward<_Args>(__args)...)
	{ }
d612 1
a612 1
	       enable_if_t<is_constructible_v<_Tp,
d614 7
a620 7
					      _Args...>, bool> = false>
	constexpr explicit
	_Optional_base(in_place_t,
		       initializer_list<_Up> __il,
		       _Args&&... __args)
	: _M_payload(in_place, __il, std::forward<_Args>(__args)...)
	{ }
a635 5
  template<typename _Tp>
    inline constexpr bool __is_optional_v = false;
  template<typename _Tp>
    inline constexpr bool __is_optional_v<optional<_Tp>> = true;

d690 1
a690 1
      constexpr optional() noexcept { }
d697 2
a698 2
			 is_constructible<_Tp, _Up>,
			 is_convertible<_Up, _Tp>> = true>
a700 1
	noexcept(is_nothrow_constructible_v<_Tp, _Up>)
d705 2
a706 2
			 is_constructible<_Tp, _Up>,
			 __not_<is_convertible<_Up, _Tp>>> = false>
d709 1
a709 2
	noexcept(is_nothrow_constructible_v<_Tp, _Up>)
	: _Base(std::in_place, std::forward<_Up>(__t)) { }
a717 1
	noexcept(is_nothrow_constructible_v<_Tp, const _Up&>)
a729 1
	noexcept(is_nothrow_constructible_v<_Tp, const _Up&>)
d735 5
a739 5
      template<typename _Up,
	       _Requires<__not_<is_same<_Tp, _Up>>,
			 is_constructible<_Tp, _Up>,
			 is_convertible<_Up, _Tp>,
			 __not_<__converts_from_optional<_Tp, _Up>>> = true>
a741 1
	noexcept(is_nothrow_constructible_v<_Tp, _Up>)
d747 5
a751 5
      template<typename _Up,
	       _Requires<__not_<is_same<_Tp, _Up>>,
			 is_constructible<_Tp, _Up>,
			 __not_<is_convertible<_Up, _Tp>>,
			 __not_<__converts_from_optional<_Tp, _Up>>> = false>
a753 1
	noexcept(is_nothrow_constructible_v<_Tp, _Up>)
d760 1
a760 1
	       _Requires<is_constructible<_Tp, _Args...>> = false>
a762 1
	noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
d768 1
a768 1
					  _Args...>> = false>
a770 2
	noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
					    _Args...>)
a772 1

d774 1
a774 1
      _GLIBCXX20_CONSTEXPR optional&
a781 1
	_GLIBCXX20_CONSTEXPR
a788 2
	noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>,
			 is_nothrow_assignable<_Tp&, _Up>>)
a798 1
	_GLIBCXX20_CONSTEXPR
a805 2
	noexcept(__and_v<is_nothrow_constructible<_Tp, const _Up&>,
			 is_nothrow_assignable<_Tp&, const _Up&>>)
d822 1
a822 2
	_GLIBCXX20_CONSTEXPR
	enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
a828 2
	noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>,
			 is_nothrow_assignable<_Tp&, _Up>>)
d846 1
a846 2
	_GLIBCXX20_CONSTEXPR
	enable_if_t<is_constructible_v<_Tp, _Args...>, _Tp&>
a847 1
	noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
d855 2
a856 3
	_GLIBCXX20_CONSTEXPR
	enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
		    _Tp&>
a857 2
	noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
					    _Args...>)
d867 1
a867 1
      _GLIBCXX20_CONSTEXPR void
d890 1
a890 1
      operator->() const noexcept
d894 1
a894 1
      operator->() noexcept
d898 1
a898 1
      operator*() const& noexcept
d902 1
a902 1
      operator*()& noexcept
d906 1
a906 1
      operator*()&& noexcept
d910 1
a910 1
      operator*() const&& noexcept
d922 3
a924 3
	if (this->_M_is_engaged())
	  return this->_M_get();
	__throw_bad_optional_access();
d930 3
a932 3
	if (this->_M_is_engaged())
	  return this->_M_get();
	__throw_bad_optional_access();
d938 3
a940 3
	if (this->_M_is_engaged())
	  return std::move(this->_M_get());
	__throw_bad_optional_access();
d946 3
a948 3
	if (this->_M_is_engaged())
	  return std::move(this->_M_get());
	__throw_bad_optional_access();
d958 2
a959 4
	  if (this->_M_is_engaged())
	    return this->_M_get();
	  else
	    return static_cast<_Tp>(std::forward<_Up>(__u));
d969 3
a971 19
	  if (this->_M_is_engaged())
	    return std::move(this->_M_get());
	  else
	    return static_cast<_Tp>(std::forward<_Up>(__u));
	}

#if __cpp_lib_optional >= 202110L
      // [optional.monadic]

      template<typename _Fn>
	constexpr auto
	and_then(_Fn&& __f) &
	{
	  using _Up = remove_cvref_t<invoke_result_t<_Fn, _Tp&>>;
	  static_assert(__is_optional_v<remove_cvref_t<_Up>>);
	  if (has_value())
	    return std::__invoke(std::forward<_Fn>(__f), **this);
	  else
	    return _Up();
d974 1
a974 120
      template<typename _Fn>
	constexpr auto
	and_then(_Fn&& __f) const &
	{
	  using _Up = remove_cvref_t<invoke_result_t<_Fn, const _Tp&>>;
	  static_assert(__is_optional_v<_Up>);
	  if (has_value())
	    return std::__invoke(std::forward<_Fn>(__f), **this);
	  else
	    return _Up();
	}

      template<typename _Fn>
	constexpr auto
	and_then(_Fn&& __f) &&
	{
	  using _Up = remove_cvref_t<invoke_result_t<_Fn, _Tp>>;
	  static_assert(__is_optional_v<remove_cvref_t<_Up>>);
	  if (has_value())
	    return std::__invoke(std::forward<_Fn>(__f), std::move(**this));
	  else
	    return _Up();
	}

      template<typename _Fn>
	constexpr auto
	and_then(_Fn&& __f) const &&
	{
	  using _Up = remove_cvref_t<invoke_result_t<_Fn, const _Tp>>;
	  static_assert(__is_optional_v<remove_cvref_t<_Up>>);
	  if (has_value())
	    return std::__invoke(std::forward<_Fn>(__f), std::move(**this));
	  else
	    return _Up();
	}

      template<typename _Fn>
	constexpr auto
	transform(_Fn&& __f) &
	{
	  using _Up = remove_cv_t<invoke_result_t<_Fn, _Tp&>>;
	  if (has_value())
	    return optional<_Up>(_Optional_func<_Fn>{__f}, **this);
	  else
	    return optional<_Up>();
	}

      template<typename _Fn>
	constexpr auto
	transform(_Fn&& __f) const &
	{
	  using _Up = remove_cv_t<invoke_result_t<_Fn, const _Tp&>>;
	  if (has_value())
	    return optional<_Up>(_Optional_func<_Fn>{__f}, **this);
	  else
	    return optional<_Up>();
	}

      template<typename _Fn>
	constexpr auto
	transform(_Fn&& __f) &&
	{
	  using _Up = remove_cv_t<invoke_result_t<_Fn, _Tp>>;
	  if (has_value())
	    return optional<_Up>(_Optional_func<_Fn>{__f}, std::move(**this));
	  else
	    return optional<_Up>();
	}

      template<typename _Fn>
	constexpr auto
	transform(_Fn&& __f) const &&
	{
	  using _Up = remove_cv_t<invoke_result_t<_Fn, const _Tp>>;
	  if (has_value())
	    return optional<_Up>(_Optional_func<_Fn>{__f}, std::move(**this));
	  else
	    return optional<_Up>();
	}

      template<typename _Fn> requires invocable<_Fn> && copy_constructible<_Tp>
	constexpr optional
	or_else(_Fn&& __f) const&
	{
	  using _Up = invoke_result_t<_Fn>;
	  static_assert( is_same_v<remove_cvref_t<_Up>, optional> );

	  if (has_value())
	    return *this;
	  else
	    return std::forward<_Fn>(__f)();
	}

      template<typename _Fn> requires invocable<_Fn> && move_constructible<_Tp>
	constexpr optional
	or_else(_Fn&& __f) &&
	{
	  using _Up = invoke_result_t<_Fn>;
	  static_assert( is_same_v<remove_cvref_t<_Up>, optional> );

	  if (has_value())
	    return std::move(*this);
	  else
	    return std::forward<_Fn>(__f)();
	}
#endif

      _GLIBCXX20_CONSTEXPR void reset() noexcept { this->_M_reset(); }

    private:
#if __cplusplus >= 202002L
      template<typename _Up> friend class optional;

      template<typename _Fn, typename _Value>
	explicit constexpr
	optional(_Optional_func<_Fn> __f, _Value&& __v)
	{
	  this->_M_payload._M_apply(__f, std::forward<_Value>(__v));
	}
#endif
d1213 5
a1230 1
    _GLIBCXX20_CONSTEXPR
d1241 1
a1241 3
    constexpr
    enable_if_t<is_constructible_v<decay_t<_Tp>, _Tp>,
		optional<decay_t<_Tp>>>
d1243 1
a1243 2
    noexcept(is_nothrow_constructible_v<optional<decay_t<_Tp>>, _Tp>)
    { return optional<decay_t<_Tp>>{ std::forward<_Tp>(__t) }; }
d1245 2
a1246 4
  template<typename _Tp, typename... _Args>
    constexpr
    enable_if_t<is_constructible_v<_Tp, _Args...>,
		optional<_Tp>>
d1248 1
a1248 2
    noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
    { return optional<_Tp>{ in_place, std::forward<_Args>(__args)... }; }
d1250 2
a1251 4
  template<typename _Tp, typename _Up, typename... _Args>
    constexpr
    enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
		optional<_Tp>>
d1253 1
a1253 2
    noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>)
    { return optional<_Tp>{ in_place, __il, std::forward<_Args>(__args)... }; }
d1258 1
a1258 1
	   bool = __poison_hash<_Up>::__enable_hash_call>
d1265 4
a1268 4
	// We pick an arbitrary hash for disengaged optionals which hopefully
	// usual values of _Tp won't typically hash to.
	constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333);
	return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash;
@


1.1.1.9.2.1
log
@Sync with HEAD.
@
text
@d1423 1
a1423 1
      && three_way_comparable_with<_Up, _Tp>
@


1.1.1.10
log
@import GCC 12.4.0.

this includes at least 85 GCC PRs fixed, 2 C, 17 C++, 16 libstdc++-v3,
at least 13 target-specific (x86, arm64, riscv mostly), and at least
24 optimisation PRs.
@
text
@d1423 1
a1423 1
      && three_way_comparable_with<_Up, _Tp>
@


1.1.1.11
log
@initial import of GCC 14.3.0.

major changes in GCC 13:
- improved sanitizer
- zstd debug info compression
- LTO improvements
- SARIF based diagnostic support
- new warnings: -Wxor-used-as-pow, -Wenum-int-mismatch, -Wself-move,
  -Wdangling-reference
- many new -Wanalyzer* specific warnings
- enhanced warnings: -Wpessimizing-move, -Wredundant-move
- new attributes to mark file descriptors, c++23 "assume"
- several C23 features added
- several C++23 features added
- many new features for Arm, x86, RISC-V

major changes in GCC 14:
- more strict C99 or newer support
- ia64* marked deprecated (but seemingly still in GCC 15.)
- several new hardening features
- support for "hardbool", which can have user supplied values of true/false
- explicit support for stack scrubbing upon function exit
- better auto-vectorisation support
- added clang-compatible __has_feature and __has_extension
- more C23, including -std=c23
- several C++26 features added
- better diagnostics in C++ templates
- new warnings: -Wnrvo, Welaborated-enum-base
- many new features for Arm, x86, RISC-V
- possible ABI breaking change for SPARC64 and small structures with arrays
  of floats.
@
text
@d3 1
a3 1
// Copyright (C) 2013-2024 Free Software Foundation, Inc.
d35 1
a35 5
#define __glibcxx_want_freestanding_optional
#define __glibcxx_want_optional
#include <bits/version.h>

#ifdef __cpp_lib_optional // C++ >= 17
d63 8
d141 1
a141 1
      _Optional_payload_base(bool /* __engaged */,
d151 1
a151 1
      _Optional_payload_base(bool /* __engaged */,
a318 2
	else // This seems redundant but improves codegen, see PR 112480.
	  this->_M_engaged = false;
d721 1
a721 1
      static_assert(is_object_v<_Tp> && !is_array_v<_Tp>);
d1056 1
a1056 3
	  static_assert(__is_optional_v<remove_cvref_t<_Up>>,
			"the function passed to std::optional<T>::and_then "
			"must return a std::optional");
d1068 1
a1068 3
	  static_assert(__is_optional_v<_Up>,
			"the function passed to std::optional<T>::and_then "
			"must return a std::optional");
d1080 1
a1080 3
	  static_assert(__is_optional_v<remove_cvref_t<_Up>>,
			"the function passed to std::optional<T>::and_then "
			"must return a std::optional");
d1092 1
a1092 3
	  static_assert(__is_optional_v<remove_cvref_t<_Up>>,
			"the function passed to std::optional<T>::and_then "
			"must return a std::optional");
d1148 1
a1148 3
	  static_assert(is_same_v<remove_cvref_t<_Up>, optional>,
			"the function passed to std::optional<T>::or_else "
			"must return a std::optional<T>");
d1161 1
a1161 3
	  static_assert(is_same_v<remove_cvref_t<_Up>, optional>,
			"the function passed to std::optional<T>::or_else "
			"must return a std::optional<T>");
d1423 1
a1423 2
      && requires { typename compare_three_way_result_t<_Tp, _Up>; }
      && three_way_comparable_with<_Tp, _Up>
d1510 1
a1510 1
#endif // __cpp_lib_optional
@


1.1.1.1.4.1
log
@file optional was added on branch phil-wifi on 2019-06-10 21:54:58 +0000
@
text
@d1 1043
@


1.1.1.1.4.2
log
@Sync with HEAD
@
text
@a0 1043
// <optional> -*- C++ -*-

// Copyright (C) 2013-2017 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @@file include/optional
 *  This is a Standard C++ Library header.
 */

#ifndef _GLIBCXX_OPTIONAL
#define _GLIBCXX_OPTIONAL 1

#pragma GCC system_header

#if __cplusplus >= 201703L

#include <utility>
#include <type_traits>
#include <stdexcept>
#include <new>
#include <initializer_list>
#include <bits/functexcept.h>
#include <bits/functional_hash.h>
#include <bits/enable_special_members.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /**
   *  @@addtogroup utilities
   *  @@{
   */

#define __cpp_lib_optional 201603

  template<typename _Tp>
    class optional;

  /// Tag type to disengage optional objects.
  struct nullopt_t
  {
    // Do not user-declare default constructor at all for
    // optional_value = {} syntax to work.
    // nullopt_t() = delete;

    // Used for constructing nullopt.
    enum class _Construct { _Token };

    // Must be constexpr for nullopt_t to be literal.
    explicit constexpr nullopt_t(_Construct) { }
  };

  /// Tag to disengage optional objects.
  inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token };

  /**
   *  @@brief Exception class thrown when a disengaged optional object is
   *  dereferenced.
   *  @@ingroup exceptions
   */
  class bad_optional_access : public exception
  {
  public:
    bad_optional_access() { }
    virtual const char* what() const noexcept override
    {return "bad optional access";}

    virtual ~bad_optional_access() noexcept = default;
  };

  void
  __throw_bad_optional_access()
  __attribute__((__noreturn__));

  // XXX Does not belong here.
  inline void
  __throw_bad_optional_access()
  { _GLIBCXX_THROW_OR_ABORT(bad_optional_access()); }


  // Payload for constexpr optionals.
  template <typename _Tp,
	    bool /*_TrivialCopyMove*/ =
	      is_trivially_copy_constructible<_Tp>::value
	      && is_trivially_move_constructible<_Tp>::value,
	    bool /*_ShouldProvideDestructor*/ =
	      is_trivially_destructible<_Tp>::value>
    struct _Optional_payload
    {
      constexpr _Optional_payload()
	: _M_empty() {}

      template<typename... _Args>
      constexpr _Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...),
	  _M_engaged(true)
      {}

      template<typename _Up, typename... _Args>
      constexpr _Optional_payload(std::initializer_list<_Up> __il,
				  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true) {}

      template <class _Up> struct __ctor_tag {};

      constexpr _Optional_payload(__ctor_tag<bool>,
				  const _Tp& __other)
	: _M_payload(__other),
	  _M_engaged(true)
      {}

      constexpr _Optional_payload(__ctor_tag<void>)
	: _M_empty()
      {}

      constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
	: _M_payload(std::move(__other)),
	  _M_engaged(true)
      {}

      constexpr _Optional_payload(bool __engaged,
				  const _Optional_payload& __other)
	: _Optional_payload(__engaged ?
			    _Optional_payload(__ctor_tag<bool>{},
					      __other._M_payload) :
			    _Optional_payload(__ctor_tag<void>{}))
      {}

      constexpr _Optional_payload(bool __engaged,
				  _Optional_payload&& __other)
	: _Optional_payload(__engaged
			    ? _Optional_payload(__ctor_tag<bool>{},
						std::move(__other._M_payload))
			    : _Optional_payload(__ctor_tag<void>{}))
      {}

      using _Stored_type = remove_const_t<_Tp>;
      struct _Empty_byte { };
      union {
          _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged = false;
    };

  // Payload for non-constexpr optionals with non-trivial destructor.
  template <typename _Tp>
    struct _Optional_payload<_Tp, false, false>
    {
      constexpr _Optional_payload()
	: _M_empty() {}

      template <typename... _Args>
      constexpr _Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...),
	  _M_engaged(true) {}

      template<typename _Up, typename... _Args>
      constexpr _Optional_payload(std::initializer_list<_Up> __il,
				  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true) {}
      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
	: _Optional_payload(__other)
      {}

      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
	: _Optional_payload(std::move(__other))
      {}

      constexpr _Optional_payload(const _Optional_payload& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(__other._M_payload);
      }

      constexpr _Optional_payload(_Optional_payload&& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(std::move(__other._M_payload));
      }

      using _Stored_type = remove_const_t<_Tp>;
      struct _Empty_byte { };
      union {
          _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged = false;

      ~_Optional_payload()
      {
        if (_M_engaged)
          _M_payload.~_Stored_type();
      }

      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new ((void *) std::__addressof(this->_M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_engaged = true;
        }
    };

  // Payload for non-constexpr optionals with trivial destructor.
  template <typename _Tp>
    struct _Optional_payload<_Tp, false, true>
    {
      constexpr _Optional_payload()
	: _M_empty() {}

      template <typename... _Args>
      constexpr _Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...),
	  _M_engaged(true) {}

      template<typename _Up, typename... _Args>
      constexpr _Optional_payload(std::initializer_list<_Up> __il,
				  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true) {}
      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
	: _Optional_payload(__other)
      {}

      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
	: _Optional_payload(std::move(__other))
      {}

      constexpr _Optional_payload(const _Optional_payload& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(__other._M_payload);
      }

      constexpr _Optional_payload(_Optional_payload&& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(std::move(__other._M_payload));
      }

      using _Stored_type = remove_const_t<_Tp>;
      struct _Empty_byte { };
      union {
          _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged = false;

      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new ((void *) std::__addressof(this->_M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_engaged = true;
        }
    };

  /**
    * @@brief Class template that holds the necessary state for @@ref optional
    * and that has the responsibility for construction and the special members.
    *
    * Such a separate base class template is necessary in order to
    * conditionally enable the special members (e.g. copy/move constructors).
    * Note that this means that @@ref _Optional_base implements the
    * functionality for copy and move assignment, but not for converting
    * assignment.
    *
    * @@see optional, _Enable_special_members
    */
  template<typename _Tp>
    class _Optional_base
    {
    private:
      // Remove const to avoid prohibition of reusing object storage for
      // const-qualified types in [3.8/9]. This is strictly internal
      // and even optional itself is oblivious to it.
      using _Stored_type = remove_const_t<_Tp>;

    public:

      // Constructors for disengaged optionals.
      constexpr _Optional_base() noexcept
      { }

      constexpr _Optional_base(nullopt_t) noexcept
      { }

      // Constructors for engaged optionals.
      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
		     std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
		     __il, std::forward<_Args>(__args)...)
        { }

      // Copy and move constructors.
      constexpr _Optional_base(const _Optional_base& __other)
	: _M_payload(__other._M_payload._M_engaged,
		     __other._M_payload)
      { }

      constexpr _Optional_base(_Optional_base&& __other)
      noexcept(is_nothrow_move_constructible<_Tp>())
	: _M_payload(__other._M_payload._M_engaged,
		     std::move(__other._M_payload))
      { }

      // Assignment operators.
      _Optional_base&
      operator=(const _Optional_base& __other)
      {
        if (this->_M_payload._M_engaged && __other._M_payload._M_engaged)
          this->_M_get() = __other._M_get();
        else
	  {
	    if (__other._M_payload._M_engaged)
	      this->_M_construct(__other._M_get());
	    else
	      this->_M_reset();
	  }

        return *this;
      }

      _Optional_base&
      operator=(_Optional_base&& __other)
      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
		      is_nothrow_move_assignable<_Tp>>())
      {
	if (this->_M_payload._M_engaged && __other._M_payload._M_engaged)
	  this->_M_get() = std::move(__other._M_get());
	else
	  {
	    if (__other._M_payload._M_engaged)
	      this->_M_construct(std::move(__other._M_get()));
	    else
	      this->_M_reset();
	  }
	return *this;
      }
      // The following functionality is also needed by optional, hence the
      // protected accessibility.
    protected:
      constexpr bool _M_is_engaged() const noexcept
      { return this->_M_payload._M_engaged; }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload._M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload._M_payload; }

      // The _M_construct operation has !_M_engaged as a precondition
      // while _M_destruct has _M_engaged as a precondition.
      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new (std::__addressof(this->_M_payload._M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_payload._M_engaged = true;
        }

      void
      _M_destruct()
      {
        this->_M_payload._M_engaged = false;
        this->_M_payload._M_payload.~_Stored_type();
      }

      // _M_reset is a 'safe' operation with no precondition.
      void
      _M_reset()
      {
        if (this->_M_payload._M_engaged)
          this->_M_destruct();
      }

    private:
      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
  class optional;

  template<typename _Tp, typename _Up>
    using __converts_from_optional =
      __or_<is_constructible<_Tp, const optional<_Up>&>,
	    is_constructible<_Tp, optional<_Up>&>,
	    is_constructible<_Tp, const optional<_Up>&&>,
	    is_constructible<_Tp, optional<_Up>&&>,
	    is_convertible<const optional<_Up>&, _Tp>,
	    is_convertible<optional<_Up>&, _Tp>,
	    is_convertible<const optional<_Up>&&, _Tp>,
	    is_convertible<optional<_Up>&&, _Tp>>;

  template<typename _Tp, typename _Up>
    using __assigns_from_optional =
      __or_<is_assignable<_Tp&, const optional<_Up>&>,
	    is_assignable<_Tp&, optional<_Up>&>,
	    is_assignable<_Tp&, const optional<_Up>&&>,
	    is_assignable<_Tp&, optional<_Up>&&>>;

  /**
    * @@brief Class template for optional values.
    */
  template<typename _Tp>
    class optional
    : private _Optional_base<_Tp>,
      private _Enable_copy_move<
        // Copy constructor.
        is_copy_constructible<_Tp>::value,
        // Copy assignment.
        __and_<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>::value,
        // Move constructor.
        is_move_constructible<_Tp>::value,
        // Move assignment.
        __and_<is_move_constructible<_Tp>, is_move_assignable<_Tp>>::value,
        // Unique tag type.
        optional<_Tp>>
    {
      static_assert(__and_<__not_<is_same<remove_cv_t<_Tp>, nullopt_t>>,
			   __not_<is_same<remove_cv_t<_Tp>, in_place_t>>,
			   __not_<is_reference<_Tp>>>(),
                    "Invalid instantiation of optional<T>");

    private:
      using _Base = _Optional_base<_Tp>;

    public:
      using value_type = _Tp;

      constexpr optional() = default;

      constexpr optional(nullopt_t) noexcept
	: _Base(nullopt) { }

      // Converting constructors for engaged optionals.
      template <typename _Up = _Tp,
                enable_if_t<__and_<
			      __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
			      __not_<is_same<in_place_t, decay_t<_Up>>>,
			      is_constructible<_Tp, _Up&&>,
			      is_convertible<_Up&&, _Tp>
			      >::value, bool> = true>
      constexpr optional(_Up&& __t)
        : _Base(std::in_place, std::forward<_Up>(__t)) { }

      template <typename _Up = _Tp,
                enable_if_t<__and_<
			      __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
			      __not_<is_same<in_place_t, decay_t<_Up>>>,
			      is_constructible<_Tp, _Up&&>,
			      __not_<is_convertible<_Up&&, _Tp>>
			      >::value, bool> = false>
      explicit constexpr optional(_Up&& __t)
        : _Base(std::in_place, std::forward<_Up>(__t)) { }

      template <typename _Up,
                enable_if_t<__and_<
			    __not_<is_same<_Tp, _Up>>,
			    is_constructible<_Tp, const _Up&>,
			    is_convertible<const _Up&, _Tp>,
			    __not_<__converts_from_optional<_Tp, _Up>>
			    >::value, bool> = true>
      constexpr optional(const optional<_Up>& __t)
      {
	if (__t)
	  emplace(*__t);
      }

      template <typename _Up,
                 enable_if_t<__and_<
			       __not_<is_same<_Tp, _Up>>,
			       is_constructible<_Tp, const _Up&>,
			       __not_<is_convertible<const _Up&, _Tp>>,
			       __not_<__converts_from_optional<_Tp, _Up>>
			       >::value, bool> = false>
      explicit constexpr optional(const optional<_Up>& __t)
      {
	if (__t)
	  emplace(*__t);
      }

      template <typename _Up,
                enable_if_t<__and_<
			      __not_<is_same<_Tp, _Up>>,
			      is_constructible<_Tp, _Up&&>,
			      is_convertible<_Up&&, _Tp>,
			      __not_<__converts_from_optional<_Tp, _Up>>
			      >::value, bool> = true>
      constexpr optional(optional<_Up>&& __t)
      {
	if (__t)
	  emplace(std::move(*__t));
      }

      template <typename _Up,
                enable_if_t<__and_<
			    __not_<is_same<_Tp, _Up>>,
			    is_constructible<_Tp, _Up&&>,
			    __not_<is_convertible<_Up&&, _Tp>>,
			    __not_<__converts_from_optional<_Tp, _Up>>
			    >::value, bool> = false>
      explicit constexpr optional(optional<_Up>&& __t)
      {
	if (__t)
	  emplace(std::move(*__t));
      }

      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
      explicit constexpr optional(in_place_t, _Args&&... __args)
        : _Base(std::in_place, std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
      explicit constexpr optional(in_place_t,
				  initializer_list<_Up> __il,
				  _Args&&... __args)
        : _Base(std::in_place, __il, std::forward<_Args>(__args)...) { }

      // Assignment operators.
      optional&
      operator=(nullopt_t) noexcept
      {
        this->_M_reset();
        return *this;
      }

      template<typename _Up = _Tp>
        enable_if_t<__and_<
		      __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
		      is_constructible<_Tp, _Up>,
		      __not_<__and_<is_scalar<_Tp>,
				    is_same<_Tp, decay_t<_Up>>>>,
		      is_assignable<_Tp&, _Up>>::value,
		    optional&>
        operator=(_Up&& __u)
        {
          if (this->_M_is_engaged())
            this->_M_get() = std::forward<_Up>(__u);
          else
            this->_M_construct(std::forward<_Up>(__u));

          return *this;
        }

      template<typename _Up>
	enable_if_t<__and_<
		      __not_<is_same<_Tp, _Up>>,
		      is_constructible<_Tp, const _Up&>,
		      is_assignable<_Tp&, _Up>,
		      __not_<__converts_from_optional<_Tp, _Up>>,
		      __not_<__assigns_from_optional<_Tp, _Up>>
		      >::value,
		    optional&>
        operator=(const optional<_Up>& __u)
        {
          if (__u)
            {
              if (this->_M_is_engaged())
                this->_M_get() = *__u;
              else
                this->_M_construct(*__u);
            }
          else
            {
              this->_M_reset();
            }
          return *this;
        }

      template<typename _Up>
	enable_if_t<__and_<
		      __not_<is_same<_Tp, _Up>>,
		      is_constructible<_Tp, _Up>,
		      is_assignable<_Tp&, _Up>,
		      __not_<__converts_from_optional<_Tp, _Up>>,
		      __not_<__assigns_from_optional<_Tp, _Up>>
		      >::value,
		    optional&>
        operator=(optional<_Up>&& __u)
        {
          if (__u)
            {
              if (this->_M_is_engaged())
                this->_M_get() = std::move(*__u);
              else
                this->_M_construct(std::move(*__u));
            }
          else
            {
              this->_M_reset();
            }

          return *this;
        }

      template<typename... _Args>
	enable_if_t<is_constructible<_Tp, _Args&&...>::value, _Tp&>
	emplace(_Args&&... __args)
	{
	  this->_M_reset();
	  this->_M_construct(std::forward<_Args>(__args)...);
	  return this->_M_get();
	}

      template<typename _Up, typename... _Args>
	enable_if_t<is_constructible<_Tp, initializer_list<_Up>&,
				     _Args&&...>::value, _Tp&>
	emplace(initializer_list<_Up> __il, _Args&&... __args)
	{
	  this->_M_reset();
	  this->_M_construct(__il, std::forward<_Args>(__args)...);
	  return this->_M_get();
	}

      // Destructor is implicit, implemented in _Optional_base.

      // Swap.
      void
      swap(optional& __other)
      noexcept(is_nothrow_move_constructible<_Tp>()
               && is_nothrow_swappable_v<_Tp>)
      {
        using std::swap;

        if (this->_M_is_engaged() && __other._M_is_engaged())
          swap(this->_M_get(), __other._M_get());
        else if (this->_M_is_engaged())
	  {
	    __other._M_construct(std::move(this->_M_get()));
	    this->_M_destruct();
	  }
        else if (__other._M_is_engaged())
	  {
	    this->_M_construct(std::move(__other._M_get()));
	    __other._M_destruct();
	  }
      }

      // Observers.
      constexpr const _Tp*
      operator->() const
      { return std::__addressof(this->_M_get()); }

      _Tp*
      operator->()
      { return std::__addressof(this->_M_get()); }

      constexpr const _Tp&
      operator*() const&
      { return this->_M_get(); }

      constexpr _Tp&
      operator*()&
      { return this->_M_get(); }

      constexpr _Tp&&
      operator*()&&
      { return std::move(this->_M_get()); }

      constexpr const _Tp&&
      operator*() const&&
      { return std::move(this->_M_get()); }

      constexpr explicit operator bool() const noexcept
      { return this->_M_is_engaged(); }

      constexpr bool has_value() const noexcept
      { return this->_M_is_engaged(); }

      constexpr const _Tp&
      value() const&
      {
	return this->_M_is_engaged()
	  ?  this->_M_get()
	  : (__throw_bad_optional_access(),
	     this->_M_get());
      }

      constexpr _Tp&
      value()&
      {
	return this->_M_is_engaged()
	  ?  this->_M_get()
	  : (__throw_bad_optional_access(),
	     this->_M_get());
      }

      constexpr _Tp&&
      value()&&
      {
	return this->_M_is_engaged()
	  ?  std::move(this->_M_get())
	  : (__throw_bad_optional_access(),
	     std::move(this->_M_get()));
      }

      constexpr const _Tp&&
      value() const&&
      {
	return this->_M_is_engaged()
	  ?  std::move(this->_M_get())
	  : (__throw_bad_optional_access(),
	     std::move(this->_M_get()));
      }

      template<typename _Up>
	constexpr _Tp
	value_or(_Up&& __u) const&
	{
	  static_assert(__and_<is_copy_constructible<_Tp>,
			       is_convertible<_Up&&, _Tp>>(),
			"Cannot return value");

	  return this->_M_is_engaged()
	    ? this->_M_get()
	    : static_cast<_Tp>(std::forward<_Up>(__u));
	}

      template<typename _Up>
	_Tp
	value_or(_Up&& __u) &&
	{
	  static_assert(__and_<is_move_constructible<_Tp>,
			       is_convertible<_Up&&, _Tp>>(),
			"Cannot return value" );

	  return this->_M_is_engaged()
	    ? std::move(this->_M_get())
	    : static_cast<_Tp>(std::forward<_Up>(__u));
	}
      void reset() noexcept { this->_M_reset(); }
    };

  template<typename _Tp>
    using __optional_relop_t =
    enable_if_t<is_convertible<_Tp, bool>::value, bool>;

  // Comparisons between optional values.
  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
    {
      return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
	     && (!__lhs || *__lhs == *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
    {
      return static_cast<bool>(__lhs) != static_cast<bool>(__rhs)
	|| (static_cast<bool>(__lhs) && *__lhs != *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
    {
      return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
    {
      return static_cast<bool>(__lhs) && (!__rhs || *__lhs > *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
    {
      return !__lhs || (static_cast<bool>(__rhs) && *__lhs <= *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
    {
      return !__rhs || (static_cast<bool>(__lhs) && *__lhs >= *__rhs);
    }

  // Comparisons with nullopt.
  template<typename _Tp>
    constexpr bool
    operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return !__lhs; }

  template<typename _Tp>
    constexpr bool
    operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return !__rhs; }

  template<typename _Tp>
    constexpr bool
    operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return static_cast<bool>(__lhs); }

  template<typename _Tp>
    constexpr bool
    operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return static_cast<bool>(__rhs); }

  template<typename _Tp>
    constexpr bool
    operator<(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept
    { return false; }

  template<typename _Tp>
    constexpr bool
    operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return static_cast<bool>(__rhs); }

  template<typename _Tp>
    constexpr bool
    operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return static_cast<bool>(__lhs); }

  template<typename _Tp>
    constexpr bool
    operator>(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept
    { return false; }

  template<typename _Tp>
    constexpr bool
    operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return !__lhs; }

  template<typename _Tp>
    constexpr bool
    operator<=(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept
    { return true; }

  template<typename _Tp>
    constexpr bool
    operator>=(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept
    { return true; }

  template<typename _Tp>
    constexpr bool
    operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return !__rhs; }

  // Comparisons with value type.
  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
    { return __lhs && *__lhs == __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() == declval<_Tp>())>
    { return __rhs && __lhs == *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
    { return !__lhs || *__lhs != __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() != declval<_Tp>())>
    { return !__rhs || __lhs != *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
    { return !__lhs || *__lhs < __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() < declval<_Tp>())>
    { return __rhs && __lhs < *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
    { return __lhs && *__lhs > __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() > declval<_Tp>())>
    { return !__rhs || __lhs > *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
    { return !__lhs || *__lhs <= __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() <= declval<_Tp>())>
    { return __rhs && __lhs <= *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
    { return __lhs && *__lhs >= __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() >= declval<_Tp>())>
    { return !__rhs || __lhs >= *__rhs; }

  // Swap and creation functions.

  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 2748. swappable traits for optionals
  template<typename _Tp>
    inline enable_if_t<is_move_constructible_v<_Tp> && is_swappable_v<_Tp>>
    swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs)
    noexcept(noexcept(__lhs.swap(__rhs)))
    { __lhs.swap(__rhs); }

  template<typename _Tp>
    enable_if_t<!(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)>
    swap(optional<_Tp>&, optional<_Tp>&) = delete;

  template<typename _Tp>
    constexpr optional<decay_t<_Tp>>
    make_optional(_Tp&& __t)
    { return optional<decay_t<_Tp>> { std::forward<_Tp>(__t) }; }

  template<typename _Tp, typename ..._Args>
    constexpr optional<_Tp>
    make_optional(_Args&&... __args)
    { return optional<_Tp> { in_place, std::forward<_Args>(__args)... }; }

  template<typename _Tp, typename _Up, typename ..._Args>
    constexpr optional<_Tp>
    make_optional(initializer_list<_Up> __il, _Args&&... __args)
    { return optional<_Tp> { in_place, __il, std::forward<_Args>(__args)... }; }

  // Hash.

  template<typename _Tp, typename _Up = remove_const_t<_Tp>,
           bool = __poison_hash<_Up>::__enable_hash_call>
    struct __optional_hash_call_base
    {
      size_t
      operator()(const optional<_Tp>& __t) const
      noexcept(noexcept(hash<_Up>{}(*__t)))
      {
        // We pick an arbitrary hash for disengaged optionals which hopefully
        // usual values of _Tp won't typically hash to.
        constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333);
        return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash;
      }
    };

  template<typename _Tp, typename _Up>
    struct __optional_hash_call_base<_Tp, _Up, false> {};

  template<typename _Tp>
    struct hash<optional<_Tp>>
    : private __poison_hash<remove_const_t<_Tp>>,
      public __optional_hash_call_base<_Tp>
    {
      using result_type = size_t;
      using argument_type = optional<_Tp>;
    };

  /// @@}

#if __cpp_deduction_guides >= 201606
  template <typename _Tp> optional(_Tp) -> optional<_Tp>;
#endif

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // C++17

#endif // _GLIBCXX_OPTIONAL
@


1.1.1.1.4.3
log
@Merge changes from current as of 20200406
@
text
@d54 1
a54 1
#define __cpp_lib_optional 201606L
d771 1
a771 1
	constexpr _Tp
@


1.1.1.1.4.4
log
@Mostly merge changes from HEAD upto 20200411
@
text
@d3 1
a3 1
// Copyright (C) 2013-2018 Free Software Foundation, Inc.
a84 1

d86 1
a86 1
    { return "bad optional access"; }
d101 1
a101 1
  // Payload for optionals with non-trivial destructor.
d103 5
a107 8
	    bool /*_HasTrivialDestructor*/ =
	      is_trivially_destructible_v<_Tp>,
	    bool /*_HasTrivialCopy */ =
	      is_trivially_copy_assignable_v<_Tp>
	      && is_trivially_copy_constructible_v<_Tp>,
	    bool /*_HasTrivialMove */ =
	      is_trivially_move_assignable_v<_Tp>
	      && is_trivially_move_constructible_v<_Tp>>
d110 2
a111 1
      constexpr _Optional_payload() noexcept : _M_empty() { }
d113 5
a117 4
      template <typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { }
d120 2
a121 3
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
d123 1
a123 2
	  _M_engaged(true)
	{ }
d125 1
a125 4
      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
      : _Optional_payload(__other)
      { }
d127 5
a131 4
      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
      : _Optional_payload(std::move(__other))
      { }
d133 3
a135 6
      constexpr
      _Optional_payload(const _Optional_payload& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(__other._M_payload);
      }
d137 4
a140 6
      constexpr
      _Optional_payload(_Optional_payload&& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(std::move(__other._M_payload));
      }
d142 15
a156 33
      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
      {
        if (this->_M_engaged && __other._M_engaged)
          this->_M_get() = __other._M_get();
        else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(__other._M_get());
	    else
	      this->_M_reset();
	  }
	return *this;
      }

      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
		      is_nothrow_move_assignable<_Tp>>())
      {
	if (this->_M_engaged && __other._M_engaged)
	  this->_M_get() = std::move(__other._M_get());
	else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(std::move(__other._M_get()));
	    else
	      this->_M_reset();
	  }
	return *this;
      }
a158 1

a159 1

a164 37

      ~_Optional_payload()
      {
        if (_M_engaged)
          _M_payload.~_Stored_type();
      }

      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new ((void *) std::__addressof(this->_M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_engaged = true;
        }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }

      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
      {
	if (this->_M_engaged)
	  {
	    this->_M_engaged = false;
	    this->_M_payload.~_Stored_type();
	  }
      }
d167 1
a167 1
  // Payload for potentially-constexpr optionals.
d169 1
a169 1
    struct _Optional_payload<_Tp, true, true, true>
d171 2
a172 2
      constexpr _Optional_payload() noexcept
      : _M_empty(), _M_engaged(false) { }
d174 4
a177 5
      template<typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...), _M_engaged(true)
	{ }
d180 2
a181 3
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
d183 1
a183 3
	  _M_engaged(true)
	{ }

d186 2
a187 5
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(__other._M_get());
      }
d191 2
a192 38
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(std::move(__other._M_get()));
      }

      using _Stored_type = remove_const_t<_Tp>;

      struct _Empty_byte { };

      union {
	  _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged;

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }
    };

  // Payload for optionals with non-trivial copy assignment.
  template <typename _Tp>
    struct _Optional_payload<_Tp, true, false, true>
    {
      constexpr _Optional_payload() noexcept
      : _M_empty(), _M_engaged(false) { }

      template<typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...), _M_engaged(true)
	{ }
d194 1
a194 11
      template<typename _Up, typename... _Args>
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true)
	{ }

      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
      : _M_engaged(__engaged)
d196 2
a197 2
	if (__engaged)
	  _M_construct(__other._M_get());
d200 1
a200 3
      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
      : _M_engaged(__engaged)
d202 2
a203 2
	if (__engaged)
	  _M_construct(std::move(__other._M_get()));
a205 22
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;

      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
      {
        if (this->_M_engaged && __other._M_engaged)
          this->_M_get() = __other._M_get();
        else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(__other._M_get());
	    else
	      this->_M_reset();
	  }
	return *this;
      }

      _Optional_payload&
      operator=(_Optional_payload&& __other) = default;

a206 1

a207 1

d212 1
a212 1
      bool _M_engaged;
d214 1
a214 23
      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new ((void *) std::__addressof(this->_M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_engaged = true;
        }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }

      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
d216 2
a217 5
	if (this->_M_engaged)
	  {
	    this->_M_engaged = false;
	    this->_M_payload.~_Stored_type();
	  }
a218 73
    };

  // Payload for optionals with non-trivial move assignment.
  template <typename _Tp>
    struct _Optional_payload<_Tp, true, true, false>
    {
      constexpr _Optional_payload() noexcept
      : _M_empty(), _M_engaged(false) { }

      template<typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...),
	  _M_engaged(true)
	{ }

      template<typename _Up, typename... _Args>
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true)
	{ }

      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(__other._M_get());
      }

      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(std::move(__other._M_get()));
      }

      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;

      _Optional_payload&
      operator=(const _Optional_payload& __other) = default;

      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
		      is_nothrow_move_assignable<_Tp>>())
      {
	if (this->_M_engaged && __other._M_engaged)
	  this->_M_get() = std::move(__other._M_get());
	else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(std::move(__other._M_get()));
	    else
	      this->_M_reset();
	  }
	return *this;
      }

      using _Stored_type = remove_const_t<_Tp>;

      struct _Empty_byte { };

      union {
          _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged;
a228 21

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }

      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
      {
	if (this->_M_engaged)
	  {
	    this->_M_engaged = false;
	    this->_M_payload.~_Stored_type();
	  }
      }
d231 1
a231 1
  // Payload for optionals with non-trivial copy and move assignment.
d233 1
a233 1
    struct _Optional_payload<_Tp, true, false, false>
d235 2
a236 2
      constexpr _Optional_payload() noexcept
      : _M_empty(), _M_engaged(false) {}
d238 2
a239 3
      template<typename... _Args>
	constexpr
	_Optional_payload(in_place_t, _Args&&... __args)
d241 1
a241 2
	  _M_engaged(true)
	{ }
d244 2
a245 3
	constexpr
	_Optional_payload(std::initializer_list<_Up> __il,
			  _Args&&... __args)
d247 1
a247 3
	  _M_engaged(true)
	{ }

d250 2
a251 5
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(__other._M_get());
      }
d255 2
a256 5
      : _M_engaged(__engaged)
      {
	if (__engaged)
	  _M_construct(std::move(__other._M_get()));
      }
d258 1
a258 6
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;

      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
d260 2
a261 10
        if (this->_M_engaged && __other._M_engaged)
          this->_M_get() = __other._M_get();
        else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(__other._M_get());
	    else
	      this->_M_reset();
	  }
	return *this;
d264 1
a264 5
      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
		      is_nothrow_move_assignable<_Tp>>())
d266 2
a267 10
	if (this->_M_engaged && __other._M_engaged)
	  this->_M_get() = std::move(__other._M_get());
	else
	  {
	    if (__other._M_engaged)
	      this->_M_construct(std::move(__other._M_get()));
	    else
	      this->_M_reset();
	  }
	return *this;
a270 1

a271 1

d276 1
a276 1
      bool _M_engaged;
a286 21

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload; }

      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
      {
	if (this->_M_engaged)
	  {
	    this->_M_engaged = false;
	    this->_M_payload.~_Stored_type();
	  }
      }
a288 36
  template<typename _Tp, typename _Dp>
    class _Optional_base_impl
    {
    protected:
      using _Stored_type = remove_const_t<_Tp>;
      
      // The _M_construct operation has !_M_engaged as a precondition
      // while _M_destruct has _M_engaged as a precondition.
      template<typename... _Args>
	void
	_M_construct(_Args&&... __args)
	noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
	{
	  ::new
	    (std::__addressof(static_cast<_Dp*>(this)->_M_payload._M_payload))
	    _Stored_type(std::forward<_Args>(__args)...);
	  static_cast<_Dp*>(this)->_M_payload._M_engaged = true;
	}
      
      void
      _M_destruct() noexcept
      {
	static_cast<_Dp*>(this)->_M_payload._M_engaged = false;
	static_cast<_Dp*>(this)->_M_payload._M_payload.~_Stored_type();
      }
      
      // _M_reset is a 'safe' operation with no precondition.
      constexpr
      void
      _M_reset() noexcept
      {
	if (static_cast<_Dp*>(this)->_M_payload._M_engaged)
	  static_cast<_Dp*>(this)->_M_destruct();
      }
  };

d290 2
a291 2
    * @@brief Class template that takes care of copy/move constructors
    of optional
d294 5
a298 1
    * conditionally make copy/move constructors trivial.
d301 1
a301 3
  template<typename _Tp,
	   bool = is_trivially_copy_constructible_v<_Tp>,
	   bool = is_trivially_move_constructible_v<_Tp>>
a302 2
    // protected inheritance because optional needs to reach that base too
      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
d304 5
a308 1
      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
d311 1
d313 5
a317 1
      constexpr _Optional_base() = default;
d350 2
a351 11
      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

    protected:

      constexpr bool _M_is_engaged() const noexcept
      { return this->_M_payload._M_engaged; }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
	_M_get() noexcept
d353 9
a361 3
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
      }
d363 1
a363 5
      constexpr const _Tp&
	_M_get() const noexcept
      {
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
d366 4
a369 52
    private:
      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
    class _Optional_base<_Tp, false, true>
      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {
      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
    public:

      // Constructors for disengaged optionals.
      constexpr _Optional_base() = default;

      // Constructors for engaged optionals.
      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
		     std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
		     __il, std::forward<_Args>(__args)...)
        { }

      // Copy and move constructors.
      constexpr _Optional_base(const _Optional_base& __other)
	: _M_payload(__other._M_payload._M_engaged,
		     __other._M_payload)
      { }

      constexpr _Optional_base(_Optional_base&& __other) = default;

      // Assignment operators.
      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

    protected:

      constexpr bool _M_is_engaged() const noexcept
      { return this->_M_payload._M_engaged; }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
	_M_get() noexcept
d371 10
a380 9
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
      }

      constexpr const _Tp&
	_M_get() const noexcept
      {
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
d382 2
a383 46

    private:
      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
    class _Optional_base<_Tp, true, false>
      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {
      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
    public:

      // Constructors for disengaged optionals.
      constexpr _Optional_base() = default;

      // Constructors for engaged optionals.
      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
		     std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
		     __il, std::forward<_Args>(__args)...)
        { }

      // Copy and move constructors.
      constexpr _Optional_base(const _Optional_base& __other) = default;

      constexpr _Optional_base(_Optional_base&& __other)
      noexcept(is_nothrow_move_constructible<_Tp>())
	: _M_payload(__other._M_payload._M_engaged,
		     std::move(__other._M_payload))
      { }

      // Assignment operators.
      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

a384 1

d390 2
a391 5
	_M_get() noexcept
      {
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
      }
d394 2
a395 5
	_M_get() const noexcept
      {
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
      }
d397 11
a407 3
    private:
      _Optional_payload<_Tp> _M_payload;
    };
d409 2
a410 44
  template<typename _Tp>
    class _Optional_base<_Tp, true, true>
      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {
      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
    public:

      // Constructors for disengaged optionals.
      constexpr _Optional_base() = default;

      // Constructors for engaged optionals.
      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
		     std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
		     __il, std::forward<_Args>(__args)...)
        { }

      // Copy and move constructors.
      constexpr _Optional_base(const _Optional_base& __other) = default;
      constexpr _Optional_base(_Optional_base&& __other) = default;

      // Assignment operators.
      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

    protected:

      constexpr bool _M_is_engaged() const noexcept
      { return this->_M_payload._M_engaged; }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
	_M_get() noexcept
d412 2
a413 2
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
d416 3
a418 2
      constexpr const _Tp&
	_M_get() const noexcept
d420 2
a421 2
	__glibcxx_assert(this->_M_is_engaged());
	return this->_M_payload._M_payload;
d467 4
a470 3
      static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>);
      static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>);
      static_assert(!is_reference_v<_Tp>);
d480 2
a481 1
      constexpr optional(nullopt_t) noexcept { }
a694 1
      constexpr
d761 3
a763 2
	  static_assert(is_copy_constructible_v<_Tp>);
	  static_assert(is_convertible_v<_Up&&, _Tp>);
d774 3
a776 2
	  static_assert(is_move_constructible_v<_Tp>);
	  static_assert(is_convertible_v<_Up&&, _Tp>);
d1028 2
a1029 2
      using result_type [[__deprecated__]] = size_t;
      using argument_type [[__deprecated__]] = optional<_Tp>;
a1031 4
  template<typename _Tp>
    struct __is_fast_hash<hash<optional<_Tp>>> : __is_fast_hash<hash<_Tp>>
    { };

@


1.1.1.1.2.1
log
@file optional was added on branch pgoyette-compat on 2019-01-26 21:59:38 +0000
@
text
@d1 1043
@


1.1.1.1.2.2
log
@Sync with HEAD
@
text
@a0 1043
// <optional> -*- C++ -*-

// Copyright (C) 2013-2017 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @@file include/optional
 *  This is a Standard C++ Library header.
 */

#ifndef _GLIBCXX_OPTIONAL
#define _GLIBCXX_OPTIONAL 1

#pragma GCC system_header

#if __cplusplus >= 201703L

#include <utility>
#include <type_traits>
#include <stdexcept>
#include <new>
#include <initializer_list>
#include <bits/functexcept.h>
#include <bits/functional_hash.h>
#include <bits/enable_special_members.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /**
   *  @@addtogroup utilities
   *  @@{
   */

#define __cpp_lib_optional 201603

  template<typename _Tp>
    class optional;

  /// Tag type to disengage optional objects.
  struct nullopt_t
  {
    // Do not user-declare default constructor at all for
    // optional_value = {} syntax to work.
    // nullopt_t() = delete;

    // Used for constructing nullopt.
    enum class _Construct { _Token };

    // Must be constexpr for nullopt_t to be literal.
    explicit constexpr nullopt_t(_Construct) { }
  };

  /// Tag to disengage optional objects.
  inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token };

  /**
   *  @@brief Exception class thrown when a disengaged optional object is
   *  dereferenced.
   *  @@ingroup exceptions
   */
  class bad_optional_access : public exception
  {
  public:
    bad_optional_access() { }
    virtual const char* what() const noexcept override
    {return "bad optional access";}

    virtual ~bad_optional_access() noexcept = default;
  };

  void
  __throw_bad_optional_access()
  __attribute__((__noreturn__));

  // XXX Does not belong here.
  inline void
  __throw_bad_optional_access()
  { _GLIBCXX_THROW_OR_ABORT(bad_optional_access()); }


  // Payload for constexpr optionals.
  template <typename _Tp,
	    bool /*_TrivialCopyMove*/ =
	      is_trivially_copy_constructible<_Tp>::value
	      && is_trivially_move_constructible<_Tp>::value,
	    bool /*_ShouldProvideDestructor*/ =
	      is_trivially_destructible<_Tp>::value>
    struct _Optional_payload
    {
      constexpr _Optional_payload()
	: _M_empty() {}

      template<typename... _Args>
      constexpr _Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...),
	  _M_engaged(true)
      {}

      template<typename _Up, typename... _Args>
      constexpr _Optional_payload(std::initializer_list<_Up> __il,
				  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true) {}

      template <class _Up> struct __ctor_tag {};

      constexpr _Optional_payload(__ctor_tag<bool>,
				  const _Tp& __other)
	: _M_payload(__other),
	  _M_engaged(true)
      {}

      constexpr _Optional_payload(__ctor_tag<void>)
	: _M_empty()
      {}

      constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
	: _M_payload(std::move(__other)),
	  _M_engaged(true)
      {}

      constexpr _Optional_payload(bool __engaged,
				  const _Optional_payload& __other)
	: _Optional_payload(__engaged ?
			    _Optional_payload(__ctor_tag<bool>{},
					      __other._M_payload) :
			    _Optional_payload(__ctor_tag<void>{}))
      {}

      constexpr _Optional_payload(bool __engaged,
				  _Optional_payload&& __other)
	: _Optional_payload(__engaged
			    ? _Optional_payload(__ctor_tag<bool>{},
						std::move(__other._M_payload))
			    : _Optional_payload(__ctor_tag<void>{}))
      {}

      using _Stored_type = remove_const_t<_Tp>;
      struct _Empty_byte { };
      union {
          _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged = false;
    };

  // Payload for non-constexpr optionals with non-trivial destructor.
  template <typename _Tp>
    struct _Optional_payload<_Tp, false, false>
    {
      constexpr _Optional_payload()
	: _M_empty() {}

      template <typename... _Args>
      constexpr _Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...),
	  _M_engaged(true) {}

      template<typename _Up, typename... _Args>
      constexpr _Optional_payload(std::initializer_list<_Up> __il,
				  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true) {}
      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
	: _Optional_payload(__other)
      {}

      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
	: _Optional_payload(std::move(__other))
      {}

      constexpr _Optional_payload(const _Optional_payload& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(__other._M_payload);
      }

      constexpr _Optional_payload(_Optional_payload&& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(std::move(__other._M_payload));
      }

      using _Stored_type = remove_const_t<_Tp>;
      struct _Empty_byte { };
      union {
          _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged = false;

      ~_Optional_payload()
      {
        if (_M_engaged)
          _M_payload.~_Stored_type();
      }

      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new ((void *) std::__addressof(this->_M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_engaged = true;
        }
    };

  // Payload for non-constexpr optionals with trivial destructor.
  template <typename _Tp>
    struct _Optional_payload<_Tp, false, true>
    {
      constexpr _Optional_payload()
	: _M_empty() {}

      template <typename... _Args>
      constexpr _Optional_payload(in_place_t, _Args&&... __args)
	: _M_payload(std::forward<_Args>(__args)...),
	  _M_engaged(true) {}

      template<typename _Up, typename... _Args>
      constexpr _Optional_payload(std::initializer_list<_Up> __il,
				  _Args&&... __args)
	: _M_payload(__il, std::forward<_Args>(__args)...),
	  _M_engaged(true) {}
      constexpr
      _Optional_payload(bool __engaged, const _Optional_payload& __other)
	: _Optional_payload(__other)
      {}

      constexpr
      _Optional_payload(bool __engaged, _Optional_payload&& __other)
	: _Optional_payload(std::move(__other))
      {}

      constexpr _Optional_payload(const _Optional_payload& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(__other._M_payload);
      }

      constexpr _Optional_payload(_Optional_payload&& __other)
      {
	if (__other._M_engaged)
	  this->_M_construct(std::move(__other._M_payload));
      }

      using _Stored_type = remove_const_t<_Tp>;
      struct _Empty_byte { };
      union {
          _Empty_byte _M_empty;
          _Stored_type _M_payload;
      };
      bool _M_engaged = false;

      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new ((void *) std::__addressof(this->_M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_engaged = true;
        }
    };

  /**
    * @@brief Class template that holds the necessary state for @@ref optional
    * and that has the responsibility for construction and the special members.
    *
    * Such a separate base class template is necessary in order to
    * conditionally enable the special members (e.g. copy/move constructors).
    * Note that this means that @@ref _Optional_base implements the
    * functionality for copy and move assignment, but not for converting
    * assignment.
    *
    * @@see optional, _Enable_special_members
    */
  template<typename _Tp>
    class _Optional_base
    {
    private:
      // Remove const to avoid prohibition of reusing object storage for
      // const-qualified types in [3.8/9]. This is strictly internal
      // and even optional itself is oblivious to it.
      using _Stored_type = remove_const_t<_Tp>;

    public:

      // Constructors for disengaged optionals.
      constexpr _Optional_base() noexcept
      { }

      constexpr _Optional_base(nullopt_t) noexcept
      { }

      // Constructors for engaged optionals.
      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
		     std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
		     __il, std::forward<_Args>(__args)...)
        { }

      // Copy and move constructors.
      constexpr _Optional_base(const _Optional_base& __other)
	: _M_payload(__other._M_payload._M_engaged,
		     __other._M_payload)
      { }

      constexpr _Optional_base(_Optional_base&& __other)
      noexcept(is_nothrow_move_constructible<_Tp>())
	: _M_payload(__other._M_payload._M_engaged,
		     std::move(__other._M_payload))
      { }

      // Assignment operators.
      _Optional_base&
      operator=(const _Optional_base& __other)
      {
        if (this->_M_payload._M_engaged && __other._M_payload._M_engaged)
          this->_M_get() = __other._M_get();
        else
	  {
	    if (__other._M_payload._M_engaged)
	      this->_M_construct(__other._M_get());
	    else
	      this->_M_reset();
	  }

        return *this;
      }

      _Optional_base&
      operator=(_Optional_base&& __other)
      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
		      is_nothrow_move_assignable<_Tp>>())
      {
	if (this->_M_payload._M_engaged && __other._M_payload._M_engaged)
	  this->_M_get() = std::move(__other._M_get());
	else
	  {
	    if (__other._M_payload._M_engaged)
	      this->_M_construct(std::move(__other._M_get()));
	    else
	      this->_M_reset();
	  }
	return *this;
      }
      // The following functionality is also needed by optional, hence the
      // protected accessibility.
    protected:
      constexpr bool _M_is_engaged() const noexcept
      { return this->_M_payload._M_engaged; }

      // The _M_get operations have _M_engaged as a precondition.
      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload._M_payload; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload._M_payload; }

      // The _M_construct operation has !_M_engaged as a precondition
      // while _M_destruct has _M_engaged as a precondition.
      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
        {
          ::new (std::__addressof(this->_M_payload._M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_payload._M_engaged = true;
        }

      void
      _M_destruct()
      {
        this->_M_payload._M_engaged = false;
        this->_M_payload._M_payload.~_Stored_type();
      }

      // _M_reset is a 'safe' operation with no precondition.
      void
      _M_reset()
      {
        if (this->_M_payload._M_engaged)
          this->_M_destruct();
      }

    private:
      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
  class optional;

  template<typename _Tp, typename _Up>
    using __converts_from_optional =
      __or_<is_constructible<_Tp, const optional<_Up>&>,
	    is_constructible<_Tp, optional<_Up>&>,
	    is_constructible<_Tp, const optional<_Up>&&>,
	    is_constructible<_Tp, optional<_Up>&&>,
	    is_convertible<const optional<_Up>&, _Tp>,
	    is_convertible<optional<_Up>&, _Tp>,
	    is_convertible<const optional<_Up>&&, _Tp>,
	    is_convertible<optional<_Up>&&, _Tp>>;

  template<typename _Tp, typename _Up>
    using __assigns_from_optional =
      __or_<is_assignable<_Tp&, const optional<_Up>&>,
	    is_assignable<_Tp&, optional<_Up>&>,
	    is_assignable<_Tp&, const optional<_Up>&&>,
	    is_assignable<_Tp&, optional<_Up>&&>>;

  /**
    * @@brief Class template for optional values.
    */
  template<typename _Tp>
    class optional
    : private _Optional_base<_Tp>,
      private _Enable_copy_move<
        // Copy constructor.
        is_copy_constructible<_Tp>::value,
        // Copy assignment.
        __and_<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>::value,
        // Move constructor.
        is_move_constructible<_Tp>::value,
        // Move assignment.
        __and_<is_move_constructible<_Tp>, is_move_assignable<_Tp>>::value,
        // Unique tag type.
        optional<_Tp>>
    {
      static_assert(__and_<__not_<is_same<remove_cv_t<_Tp>, nullopt_t>>,
			   __not_<is_same<remove_cv_t<_Tp>, in_place_t>>,
			   __not_<is_reference<_Tp>>>(),
                    "Invalid instantiation of optional<T>");

    private:
      using _Base = _Optional_base<_Tp>;

    public:
      using value_type = _Tp;

      constexpr optional() = default;

      constexpr optional(nullopt_t) noexcept
	: _Base(nullopt) { }

      // Converting constructors for engaged optionals.
      template <typename _Up = _Tp,
                enable_if_t<__and_<
			      __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
			      __not_<is_same<in_place_t, decay_t<_Up>>>,
			      is_constructible<_Tp, _Up&&>,
			      is_convertible<_Up&&, _Tp>
			      >::value, bool> = true>
      constexpr optional(_Up&& __t)
        : _Base(std::in_place, std::forward<_Up>(__t)) { }

      template <typename _Up = _Tp,
                enable_if_t<__and_<
			      __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
			      __not_<is_same<in_place_t, decay_t<_Up>>>,
			      is_constructible<_Tp, _Up&&>,
			      __not_<is_convertible<_Up&&, _Tp>>
			      >::value, bool> = false>
      explicit constexpr optional(_Up&& __t)
        : _Base(std::in_place, std::forward<_Up>(__t)) { }

      template <typename _Up,
                enable_if_t<__and_<
			    __not_<is_same<_Tp, _Up>>,
			    is_constructible<_Tp, const _Up&>,
			    is_convertible<const _Up&, _Tp>,
			    __not_<__converts_from_optional<_Tp, _Up>>
			    >::value, bool> = true>
      constexpr optional(const optional<_Up>& __t)
      {
	if (__t)
	  emplace(*__t);
      }

      template <typename _Up,
                 enable_if_t<__and_<
			       __not_<is_same<_Tp, _Up>>,
			       is_constructible<_Tp, const _Up&>,
			       __not_<is_convertible<const _Up&, _Tp>>,
			       __not_<__converts_from_optional<_Tp, _Up>>
			       >::value, bool> = false>
      explicit constexpr optional(const optional<_Up>& __t)
      {
	if (__t)
	  emplace(*__t);
      }

      template <typename _Up,
                enable_if_t<__and_<
			      __not_<is_same<_Tp, _Up>>,
			      is_constructible<_Tp, _Up&&>,
			      is_convertible<_Up&&, _Tp>,
			      __not_<__converts_from_optional<_Tp, _Up>>
			      >::value, bool> = true>
      constexpr optional(optional<_Up>&& __t)
      {
	if (__t)
	  emplace(std::move(*__t));
      }

      template <typename _Up,
                enable_if_t<__and_<
			    __not_<is_same<_Tp, _Up>>,
			    is_constructible<_Tp, _Up&&>,
			    __not_<is_convertible<_Up&&, _Tp>>,
			    __not_<__converts_from_optional<_Tp, _Up>>
			    >::value, bool> = false>
      explicit constexpr optional(optional<_Up>&& __t)
      {
	if (__t)
	  emplace(std::move(*__t));
      }

      template<typename... _Args,
	       enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
      explicit constexpr optional(in_place_t, _Args&&... __args)
        : _Base(std::in_place, std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
					      initializer_list<_Up>&,
					      _Args&&...>, bool> = false>
      explicit constexpr optional(in_place_t,
				  initializer_list<_Up> __il,
				  _Args&&... __args)
        : _Base(std::in_place, __il, std::forward<_Args>(__args)...) { }

      // Assignment operators.
      optional&
      operator=(nullopt_t) noexcept
      {
        this->_M_reset();
        return *this;
      }

      template<typename _Up = _Tp>
        enable_if_t<__and_<
		      __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
		      is_constructible<_Tp, _Up>,
		      __not_<__and_<is_scalar<_Tp>,
				    is_same<_Tp, decay_t<_Up>>>>,
		      is_assignable<_Tp&, _Up>>::value,
		    optional&>
        operator=(_Up&& __u)
        {
          if (this->_M_is_engaged())
            this->_M_get() = std::forward<_Up>(__u);
          else
            this->_M_construct(std::forward<_Up>(__u));

          return *this;
        }

      template<typename _Up>
	enable_if_t<__and_<
		      __not_<is_same<_Tp, _Up>>,
		      is_constructible<_Tp, const _Up&>,
		      is_assignable<_Tp&, _Up>,
		      __not_<__converts_from_optional<_Tp, _Up>>,
		      __not_<__assigns_from_optional<_Tp, _Up>>
		      >::value,
		    optional&>
        operator=(const optional<_Up>& __u)
        {
          if (__u)
            {
              if (this->_M_is_engaged())
                this->_M_get() = *__u;
              else
                this->_M_construct(*__u);
            }
          else
            {
              this->_M_reset();
            }
          return *this;
        }

      template<typename _Up>
	enable_if_t<__and_<
		      __not_<is_same<_Tp, _Up>>,
		      is_constructible<_Tp, _Up>,
		      is_assignable<_Tp&, _Up>,
		      __not_<__converts_from_optional<_Tp, _Up>>,
		      __not_<__assigns_from_optional<_Tp, _Up>>
		      >::value,
		    optional&>
        operator=(optional<_Up>&& __u)
        {
          if (__u)
            {
              if (this->_M_is_engaged())
                this->_M_get() = std::move(*__u);
              else
                this->_M_construct(std::move(*__u));
            }
          else
            {
              this->_M_reset();
            }

          return *this;
        }

      template<typename... _Args>
	enable_if_t<is_constructible<_Tp, _Args&&...>::value, _Tp&>
	emplace(_Args&&... __args)
	{
	  this->_M_reset();
	  this->_M_construct(std::forward<_Args>(__args)...);
	  return this->_M_get();
	}

      template<typename _Up, typename... _Args>
	enable_if_t<is_constructible<_Tp, initializer_list<_Up>&,
				     _Args&&...>::value, _Tp&>
	emplace(initializer_list<_Up> __il, _Args&&... __args)
	{
	  this->_M_reset();
	  this->_M_construct(__il, std::forward<_Args>(__args)...);
	  return this->_M_get();
	}

      // Destructor is implicit, implemented in _Optional_base.

      // Swap.
      void
      swap(optional& __other)
      noexcept(is_nothrow_move_constructible<_Tp>()
               && is_nothrow_swappable_v<_Tp>)
      {
        using std::swap;

        if (this->_M_is_engaged() && __other._M_is_engaged())
          swap(this->_M_get(), __other._M_get());
        else if (this->_M_is_engaged())
	  {
	    __other._M_construct(std::move(this->_M_get()));
	    this->_M_destruct();
	  }
        else if (__other._M_is_engaged())
	  {
	    this->_M_construct(std::move(__other._M_get()));
	    __other._M_destruct();
	  }
      }

      // Observers.
      constexpr const _Tp*
      operator->() const
      { return std::__addressof(this->_M_get()); }

      _Tp*
      operator->()
      { return std::__addressof(this->_M_get()); }

      constexpr const _Tp&
      operator*() const&
      { return this->_M_get(); }

      constexpr _Tp&
      operator*()&
      { return this->_M_get(); }

      constexpr _Tp&&
      operator*()&&
      { return std::move(this->_M_get()); }

      constexpr const _Tp&&
      operator*() const&&
      { return std::move(this->_M_get()); }

      constexpr explicit operator bool() const noexcept
      { return this->_M_is_engaged(); }

      constexpr bool has_value() const noexcept
      { return this->_M_is_engaged(); }

      constexpr const _Tp&
      value() const&
      {
	return this->_M_is_engaged()
	  ?  this->_M_get()
	  : (__throw_bad_optional_access(),
	     this->_M_get());
      }

      constexpr _Tp&
      value()&
      {
	return this->_M_is_engaged()
	  ?  this->_M_get()
	  : (__throw_bad_optional_access(),
	     this->_M_get());
      }

      constexpr _Tp&&
      value()&&
      {
	return this->_M_is_engaged()
	  ?  std::move(this->_M_get())
	  : (__throw_bad_optional_access(),
	     std::move(this->_M_get()));
      }

      constexpr const _Tp&&
      value() const&&
      {
	return this->_M_is_engaged()
	  ?  std::move(this->_M_get())
	  : (__throw_bad_optional_access(),
	     std::move(this->_M_get()));
      }

      template<typename _Up>
	constexpr _Tp
	value_or(_Up&& __u) const&
	{
	  static_assert(__and_<is_copy_constructible<_Tp>,
			       is_convertible<_Up&&, _Tp>>(),
			"Cannot return value");

	  return this->_M_is_engaged()
	    ? this->_M_get()
	    : static_cast<_Tp>(std::forward<_Up>(__u));
	}

      template<typename _Up>
	_Tp
	value_or(_Up&& __u) &&
	{
	  static_assert(__and_<is_move_constructible<_Tp>,
			       is_convertible<_Up&&, _Tp>>(),
			"Cannot return value" );

	  return this->_M_is_engaged()
	    ? std::move(this->_M_get())
	    : static_cast<_Tp>(std::forward<_Up>(__u));
	}
      void reset() noexcept { this->_M_reset(); }
    };

  template<typename _Tp>
    using __optional_relop_t =
    enable_if_t<is_convertible<_Tp, bool>::value, bool>;

  // Comparisons between optional values.
  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
    {
      return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
	     && (!__lhs || *__lhs == *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
    {
      return static_cast<bool>(__lhs) != static_cast<bool>(__rhs)
	|| (static_cast<bool>(__lhs) && *__lhs != *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
    {
      return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
    {
      return static_cast<bool>(__lhs) && (!__rhs || *__lhs > *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
    {
      return !__lhs || (static_cast<bool>(__rhs) && *__lhs <= *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
    {
      return !__rhs || (static_cast<bool>(__lhs) && *__lhs >= *__rhs);
    }

  // Comparisons with nullopt.
  template<typename _Tp>
    constexpr bool
    operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return !__lhs; }

  template<typename _Tp>
    constexpr bool
    operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return !__rhs; }

  template<typename _Tp>
    constexpr bool
    operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return static_cast<bool>(__lhs); }

  template<typename _Tp>
    constexpr bool
    operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return static_cast<bool>(__rhs); }

  template<typename _Tp>
    constexpr bool
    operator<(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept
    { return false; }

  template<typename _Tp>
    constexpr bool
    operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return static_cast<bool>(__rhs); }

  template<typename _Tp>
    constexpr bool
    operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return static_cast<bool>(__lhs); }

  template<typename _Tp>
    constexpr bool
    operator>(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept
    { return false; }

  template<typename _Tp>
    constexpr bool
    operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return !__lhs; }

  template<typename _Tp>
    constexpr bool
    operator<=(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept
    { return true; }

  template<typename _Tp>
    constexpr bool
    operator>=(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept
    { return true; }

  template<typename _Tp>
    constexpr bool
    operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return !__rhs; }

  // Comparisons with value type.
  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
    { return __lhs && *__lhs == __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() == declval<_Tp>())>
    { return __rhs && __lhs == *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
    { return !__lhs || *__lhs != __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() != declval<_Tp>())>
    { return !__rhs || __lhs != *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
    { return !__lhs || *__lhs < __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() < declval<_Tp>())>
    { return __rhs && __lhs < *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
    { return __lhs && *__lhs > __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() > declval<_Tp>())>
    { return !__rhs || __lhs > *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
    { return !__lhs || *__lhs <= __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() <= declval<_Tp>())>
    { return __rhs && __lhs <= *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
    { return __lhs && *__lhs >= __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() >= declval<_Tp>())>
    { return !__rhs || __lhs >= *__rhs; }

  // Swap and creation functions.

  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 2748. swappable traits for optionals
  template<typename _Tp>
    inline enable_if_t<is_move_constructible_v<_Tp> && is_swappable_v<_Tp>>
    swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs)
    noexcept(noexcept(__lhs.swap(__rhs)))
    { __lhs.swap(__rhs); }

  template<typename _Tp>
    enable_if_t<!(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)>
    swap(optional<_Tp>&, optional<_Tp>&) = delete;

  template<typename _Tp>
    constexpr optional<decay_t<_Tp>>
    make_optional(_Tp&& __t)
    { return optional<decay_t<_Tp>> { std::forward<_Tp>(__t) }; }

  template<typename _Tp, typename ..._Args>
    constexpr optional<_Tp>
    make_optional(_Args&&... __args)
    { return optional<_Tp> { in_place, std::forward<_Args>(__args)... }; }

  template<typename _Tp, typename _Up, typename ..._Args>
    constexpr optional<_Tp>
    make_optional(initializer_list<_Up> __il, _Args&&... __args)
    { return optional<_Tp> { in_place, __il, std::forward<_Args>(__args)... }; }

  // Hash.

  template<typename _Tp, typename _Up = remove_const_t<_Tp>,
           bool = __poison_hash<_Up>::__enable_hash_call>
    struct __optional_hash_call_base
    {
      size_t
      operator()(const optional<_Tp>& __t) const
      noexcept(noexcept(hash<_Up>{}(*__t)))
      {
        // We pick an arbitrary hash for disengaged optionals which hopefully
        // usual values of _Tp won't typically hash to.
        constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333);
        return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash;
      }
    };

  template<typename _Tp, typename _Up>
    struct __optional_hash_call_base<_Tp, _Up, false> {};

  template<typename _Tp>
    struct hash<optional<_Tp>>
    : private __poison_hash<remove_const_t<_Tp>>,
      public __optional_hash_call_base<_Tp>
    {
      using result_type = size_t;
      using argument_type = optional<_Tp>;
    };

  /// @@}

#if __cpp_deduction_guides >= 201606
  template <typename _Tp> optional(_Tp) -> optional<_Tp>;
#endif

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // C++17

#endif // _GLIBCXX_OPTIONAL
@