diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 85ab1aef53..f0001126db 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,26 @@ +2017-04-18 Pedro Alves + + * common/gdb_optional.h: Include common/traits.h. + (in_place_t): New type. + (in_place): New constexpr variable. + (optional::optional): Remove member initialization of + m_instantiated. + (optional::optional(in_place_t...)): New constructor. + (optional::~optional): Use reset. + (optional::optional(const optional&)): New. + (optional::optional(const optional&&)): New. + (optional::optional(T &)): New. + (optional::optional(T &&)): New. + (operator::operator=(const optional &)): New. + (operator::operator=(optional &&)): New. + (operator::operator= (const T &)) + (operator::operator= (T &&)) + (operator::emplace (Args &&... args)): Return a T&. Use reset. + (operator::reset): New. + (operator::m_instantiated):: Add in-class initializer. + * common/traits.h: Include . + (struct And): New types. + 2017-04-18 Pedro Alves * xml-support.c: Include . diff --git a/gdb/common/gdb_optional.h b/gdb/common/gdb_optional.h index ad1119f2e8..c30fa5ba67 100644 --- a/gdb/common/gdb_optional.h +++ b/gdb/common/gdb_optional.h @@ -20,46 +20,141 @@ #ifndef GDB_OPTIONAL_H #define GDB_OPTIONAL_H +#include "common/traits.h" + namespace gdb { +struct in_place_t +{ + explicit in_place_t () = default; +}; + +constexpr gdb::in_place_t in_place {}; + /* This class attempts to be a compatible subset of std::optional, which is slated to be available in C++17. This class optionally holds an object of some type -- by default it is constructed not holding an object, but later the object can be "emplaced". This is similar to using std::unique_ptr, but in-object allocation is - guaranteed. */ + guaranteed. + + Unlike std::optional, we currently only support copy/move + construction/assignment of an optional from either exactly + optional or T. I.e., we don't support copy/move + construction/assignment from optional or U, when U is a type + convertible to T. Making that work depending on the definitions of + T and U is somewhat complicated, and currently the users of this + class don't need it. */ + template class optional { public: constexpr optional () - : m_dummy (), - m_instantiated (false) - { - } - - ~optional () - { - if (m_instantiated) - destroy (); - } - - /* These aren't deleted in std::optional, but it was simpler to - delete them here, because currently the users of this class don't - need them, and making them depend on the definition of T is - somewhat complicated. */ - optional (const optional &other) = delete; - optional &operator= (const optional &other) = delete; + : m_dummy () + {} template - void emplace (Args &&... args) + constexpr optional (in_place_t, Args &&... args) + : m_item (std::forward (args)...), + m_instantiated (true) + {} + + ~optional () + { this->reset (); } + + /* Copy and move constructors. */ + + optional (const optional &other) + { + if (other.m_instantiated) + this->emplace (other.get ()); + } + + optional (optional &&other) + noexcept(std::is_nothrow_move_constructible ()) + { + if (other.m_instantiated) + this->emplace (std::move (other.get ())); + } + + constexpr optional (const T &other) + : m_item (other), + m_instantiated (true) + {} + + constexpr optional (T &&other) + noexcept (std::is_nothrow_move_constructible ()) + : m_item (std::move (other)), + m_instantiated (true) + {} + + /* Assignment operators. */ + + optional & + operator= (const optional &other) + { + if (m_instantiated && other.m_instantiated) + this->get () = other.get (); + else + { + if (other.m_instantiated) + this->emplace (other.get ()); + else + this->reset (); + } + + return *this; + } + + optional & + operator= (optional &&other) + noexcept (And, + std::is_nothrow_move_assignable> ()) + { + if (m_instantiated && other.m_instantiated) + this->get () = std::move (other.get ()); + else + { + if (other.m_instantiated) + this->emplace (std::move (other.get ())); + else + this->reset (); + } + return *this; + } + + optional & + operator= (const T &other) { if (m_instantiated) - destroy (); + this->get () = other; + else + this->emplace (other); + return *this; + } + + optional & + operator= (T &&other) + noexcept (And, + std::is_nothrow_move_assignable> ()) + { + if (m_instantiated) + this->get () = std::move (other); + else + this->emplace (std::move (other)); + return *this; + } + + template + T &emplace (Args &&... args) + { + this->reset (); new (&m_item) T (std::forward(args)...); m_instantiated = true; + return this->get (); } /* Observers. */ @@ -87,6 +182,13 @@ public: constexpr bool has_value () const noexcept { return m_instantiated; } + /* 'reset' is a 'safe' operation with no precondition. */ + void reset () noexcept + { + if (m_instantiated) + this->destroy (); + } + private: /* Destroy the object. */ @@ -109,7 +211,7 @@ private: }; /* True if the object was ever emplaced. */ - bool m_instantiated; + bool m_instantiated = false; }; } diff --git a/gdb/common/traits.h b/gdb/common/traits.h index 4b7bac37fe..c8f29cccbe 100644 --- a/gdb/common/traits.h +++ b/gdb/common/traits.h @@ -18,6 +18,8 @@ #ifndef COMMON_TRAITS_H #define COMMON_TRAITS_H +#include + namespace gdb { /* Pre C++14-safe (CWG 1558) version of C++17's std::void_t. See @@ -29,6 +31,30 @@ struct make_void { typedef void type; }; template using void_t = typename make_void::type; +/* A few trait helpers, mainly stolen from libstdc++. Uppercase + because "and" is a keyword. */ + +template +struct And; + +template<> +struct And<> : public std::true_type +{}; + +template +struct And : public B1 +{}; + +template +struct And + : public std::conditional::type +{}; + +template +struct And + : public std::conditional, B1>::type +{}; + } #endif /* COMMON_TRAITS_H */