__throw_bad_optional_access()
{ _GLIBCXX_THROW_OR_ABORT(bad_optional_access()); }
- /**
- * @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, bool _ShouldProvideDestructor =
- !is_trivially_destructible<_Tp>::value>
- 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:
+ // 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() {}
- // Constructors for disengaged optionals.
- constexpr _Optional_base() noexcept
- : _M_empty{} { }
+ template<typename... _Args>
+ constexpr _Optional_payload(in_place_t, _Args&&... __args)
+ : _M_payload(std::forward<_Args>(__args)...),
+ _M_engaged(true)
+ {}
- constexpr _Optional_base(nullopt_t) noexcept
- : _Optional_base{} { }
+ 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>{}))
+ {}
- // 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(std::forward<_Args>(__args)...), _M_engaged(true) { }
+ 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 _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(__il, std::forward<_Args>(__args)...),
- _M_engaged(true) { }
+ // Payload for non-constexpr optionals with non-trivial destructor.
+ template <typename _Tp>
+ struct _Optional_payload<_Tp, false, false>
+ {
+ constexpr _Optional_payload()
+ : _M_empty() {}
- // Copy and move constructors.
- _Optional_base(const _Optional_base& __other)
- {
- if (__other._M_engaged)
- this->_M_construct(__other._M_get());
- }
+ template <typename... _Args>
+ constexpr _Optional_payload(in_place_t, _Args&&... __args)
+ : _M_payload(std::forward<_Args>(__args)...),
+ _M_engaged(true) {}
- _Optional_base(_Optional_base&& __other)
- noexcept(is_nothrow_move_constructible<_Tp>())
+ 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(std::move(__other._M_get()));
+ if (__other._M_engaged)
+ this->_M_construct(__other._M_payload);
}
- // Assignment operators.
- _Optional_base&
- operator=(const _Optional_base& __other)
+ constexpr _Optional_payload(_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;
+ if (__other._M_engaged)
+ this->_M_construct(std::move(__other._M_payload));
}
- _Optional_base&
- operator=(_Optional_base&& __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 = false;
- // Destructor.
- ~_Optional_base()
+ ~_Optional_payload()
{
- if (this->_M_engaged)
- this->_M_payload.~_Stored_type();
+ if (_M_engaged)
+ _M_payload.~_Stored_type();
}
- // The following functionality is also needed by optional, hence the
- // protected accessibility.
- protected:
- constexpr bool _M_is_engaged() const noexcept
- { return this->_M_engaged; }
-
- // The _M_get operations have _M_engaged as a precondition.
- constexpr _Tp&
- _M_get() noexcept
- { return _M_payload; }
-
- constexpr const _Tp&
- _M_get() const noexcept
- { return _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))
+ ::new ((void *) std::__addressof(this->_M_payload))
_Stored_type(std::forward<_Args>(__args)...);
this->_M_engaged = true;
}
+ };
- void
- _M_destruct()
+ // 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)
{
- this->_M_engaged = false;
- this->_M_payload.~_Stored_type();
+ if (__other._M_engaged)
+ this->_M_construct(__other._M_payload);
}
- // _M_reset is a 'safe' operation with no precondition.
- void
- _M_reset()
+ constexpr _Optional_payload(_Optional_payload&& __other)
{
- if (this->_M_engaged)
- this->_M_destruct();
+ if (__other._M_engaged)
+ this->_M_construct(std::move(__other._M_payload));
}
- private:
+ 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;
+ }
};
- /// Partial specialization that is exactly identical to the primary template
- /// save for not providing a destructor, to fulfill triviality requirements.
+ /**
+ * @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<_Tp, false>
+ 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
- : _M_empty{} { }
+ { }
constexpr _Optional_base(nullopt_t) noexcept
- : _Optional_base{} { }
+ { }
+ // 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(std::forward<_Args>(__args)...), _M_engaged(true) { }
+ : _M_payload(in_place,
+ std::forward<_Args>(__args)...) { }
template<typename _Up, typename... _Args,
enable_if_t<is_constructible_v<_Tp,
constexpr explicit _Optional_base(in_place_t,
initializer_list<_Up> __il,
_Args&&... __args)
- : _M_payload(__il, std::forward<_Args>(__args)...),
- _M_engaged(true) { }
+ : _M_payload(in_place,
+ __il, std::forward<_Args>(__args)...)
+ { }
- _Optional_base(const _Optional_base& __other)
- {
- if (__other._M_engaged)
- this->_M_construct(__other._M_get());
- }
+ // Copy and move constructors.
+ constexpr _Optional_base(const _Optional_base& __other)
+ : _M_payload(__other._M_payload._M_engaged,
+ __other._M_payload)
+ { }
- _Optional_base(_Optional_base&& __other)
+ constexpr _Optional_base(_Optional_base&& __other)
noexcept(is_nothrow_move_constructible<_Tp>())
- {
- if (__other._M_engaged)
- this->_M_construct(std::move(__other._M_get()));
- }
+ : _M_payload(__other._M_payload._M_engaged,
+ std::move(__other._M_payload))
+ { }
+ // Assignment operators.
_Optional_base&
operator=(const _Optional_base& __other)
{
- if (this->_M_engaged && __other._M_engaged)
- this->_M_get() = __other._M_get();
- else
+ if (this->_M_payload._M_engaged && __other._M_payload._M_engaged)
+ this->_M_get() = __other._M_get();
+ else
{
- if (__other._M_engaged)
+ if (__other._M_payload._M_engaged)
this->_M_construct(__other._M_get());
else
this->_M_reset();
}
- return *this;
+
+ return *this;
}
_Optional_base&
noexcept(__and_<is_nothrow_move_constructible<_Tp>,
is_nothrow_move_assignable<_Tp>>())
{
- if (this->_M_engaged && __other._M_engaged)
+ if (this->_M_payload._M_engaged && __other._M_payload._M_engaged)
this->_M_get() = std::move(__other._M_get());
else
{
- if (__other._M_engaged)
+ if (__other._M_payload._M_engaged)
this->_M_construct(std::move(__other._M_get()));
else
this->_M_reset();
}
return *this;
}
-
- // Sole difference
- // ~_Optional_base() noexcept = default;
-
+ // The following functionality is also needed by optional, hence the
+ // protected accessibility.
protected:
constexpr bool _M_is_engaged() const noexcept
- { return this->_M_engaged; }
+ { return this->_M_payload._M_engaged; }
+ // The _M_get operations have _M_engaged as a precondition.
constexpr _Tp&
_M_get() noexcept
- { return _M_payload; }
+ { return this->_M_payload._M_payload; }
constexpr const _Tp&
_M_get() const noexcept
- { return _M_payload; }
+ { 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))
+ ::new (std::__addressof(this->_M_payload._M_payload))
_Stored_type(std::forward<_Args>(__args)...);
- this->_M_engaged = true;
+ this->_M_payload._M_engaged = true;
}
void
_M_destruct()
{
- this->_M_engaged = false;
- this->_M_payload.~_Stored_type();
+ 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_engaged)
+ if (this->_M_payload._M_engaged)
this->_M_destruct();
}
private:
- struct _Empty_byte { };
- union
- {
- _Empty_byte _M_empty;
- _Stored_type _M_payload;
- };
- bool _M_engaged = false;
+ _Optional_payload<_Tp> _M_payload;
};
template<typename _Tp>
projects / gcc.git / commitdiff