// Payload for constexpr optionals.
template <typename _Tp,
- bool /*_TrivialCopyMove*/ =
- is_trivially_copy_constructible<_Tp>::value
- && is_trivially_move_constructible<_Tp>::value,
- bool /*_ShouldProvideDestructor*/ =
+ bool /*_HasTrivialDestructor*/ =
is_trivially_destructible<_Tp>::value>
struct _Optional_payload
{
constexpr _Optional_payload()
- : _M_empty() {}
+ : _M_empty(), _M_engaged(false) {}
template<typename... _Args>
constexpr _Optional_payload(in_place_t, _Args&&... __args)
{}
constexpr _Optional_payload(__ctor_tag<void>)
- : _M_empty()
+ : _M_empty(), _M_engaged(false)
{}
constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
_Empty_byte _M_empty;
_Stored_type _M_payload;
};
- bool _M_engaged = false;
+ bool _M_engaged;
};
- // Payload for non-constexpr optionals with non-trivial destructor.
+ // Payload for optionals with non-trivial destructor.
template <typename _Tp>
- struct _Optional_payload<_Tp, false, false>
+ struct _Optional_payload<_Tp, false>
{
constexpr _Optional_payload()
: _M_empty() {}
this->_M_construct(std::move(__other._M_payload));
}
+ _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)
+ 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 {
_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)
+ // The _M_get operations have _M_engaged as a precondition.
+ constexpr _Tp&
+ _M_get() noexcept
{
- if (__other._M_engaged)
- this->_M_construct(__other._M_payload);
+ return this->_M_payload;
}
- constexpr _Optional_payload(_Optional_payload&& __other)
+ constexpr const _Tp&
+ _M_get() const noexcept
{
- if (__other._M_engaged)
- this->_M_construct(std::move(__other._M_payload));
+ return this->_M_payload;
}
+ // _M_reset is a 'safe' operation with no precondition.
+ void
+ _M_reset() noexcept
+ {
+ if (this->_M_engaged)
+ {
+ this->_M_engaged = false;
+ this->_M_payload.~_Stored_type();
+ }
+ }
+ };
+
+ template<typename _Tp, typename _Dp>
+ class _Optional_base_impl
+ {
+ protected:
using _Stored_type = remove_const_t<_Tp>;
- struct _Empty_byte { };
- union {
- _Empty_byte _M_empty;
- _Stored_type _M_payload;
- };
- bool _M_engaged = false;
-
+
+ // 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 ((void *) std::__addressof(this->_M_payload))
- _Stored_type(std::forward<_Args>(__args)...);
- this->_M_engaged = true;
- }
- };
+ 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.
+ void
+ _M_reset() noexcept
+ {
+ if (static_cast<_Dp*>(this)->_M_payload._M_engaged)
+ static_cast<_Dp*>(this)->_M_destruct();
+ }
+ };
/**
- * @brief Class template that holds the necessary state for @ref optional
- * and that has the responsibility for construction and the special members.
+ * @brief Class template that takes care of copy/move constructors
+ of optional
*
* 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.
- *
+ * conditionally make copy/move constructors trivial.
* @see optional, _Enable_special_members
*/
- template<typename _Tp>
+ template<typename _Tp,
+ bool = is_trivially_copy_constructible_v<_Tp>,
+ bool = is_trivially_move_constructible_v<_Tp>>
class _Optional_base
+ // protected inheritance because optional needs to reach that base too
+ : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
{
- 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>;
-
+ friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
public:
// Constructors for disengaged optionals.
- constexpr _Optional_base() noexcept
- { }
-
- constexpr _Optional_base(nullopt_t) noexcept
- { }
+ constexpr _Optional_base() = default;
// Constructors for engaged optionals.
template<typename... _Args,
{ }
// Assignment operators.
- _Optional_base&
- operator=(const _Optional_base& __other)
+ _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
{
- 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();
- }
+ __glibcxx_assert(this->_M_is_engaged());
+ return this->_M_payload._M_payload;
+ }
- return *this;
+ constexpr const _Tp&
+ _M_get() const noexcept
+ {
+ __glibcxx_assert(this->_M_is_engaged());
+ return this->_M_payload._M_payload;
}
- _Optional_base&
- operator=(_Optional_base&& __other)
- noexcept(__and_<is_nothrow_move_constructible<_Tp>,
- is_nothrow_move_assignable<_Tp>>())
+ 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
{
- 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;
+ __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;
}
- // The following functionality is also needed by optional, hence the
- // protected accessibility.
+
+ 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;
+
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
+ _M_get() noexcept
{
- __glibcxx_assert(_M_is_engaged());
+ __glibcxx_assert(this->_M_is_engaged());
return this->_M_payload._M_payload;
}
constexpr const _Tp&
- _M_get() const noexcept
+ _M_get() const noexcept
{
- __glibcxx_assert(_M_is_engaged());
+ __glibcxx_assert(this->_M_is_engaged());
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;
- }
+ private:
+ _Optional_payload<_Tp> _M_payload;
+ };
- void
- _M_destruct()
+ 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
{
- this->_M_payload._M_engaged = false;
- this->_M_payload._M_payload.~_Stored_type();
+ __glibcxx_assert(this->_M_is_engaged());
+ return this->_M_payload._M_payload;
}
- // _M_reset is a 'safe' operation with no precondition.
- void
- _M_reset()
+ constexpr const _Tp&
+ _M_get() const noexcept
{
- if (this->_M_payload._M_engaged)
- this->_M_destruct();
+ __glibcxx_assert(this->_M_is_engaged());
+ return this->_M_payload._M_payload;
}
private:
constexpr optional() = default;
- constexpr optional(nullopt_t) noexcept
- : _Base(nullopt) { }
+ constexpr optional(nullopt_t) noexcept { }
// Converting constructors for engaged optionals.
template <typename _Up = _Tp,
projects / gcc.git / commitdiff