gdb/common/gdb_optional.h

   1 /* An optional object.
   2
   3    Copyright (C) 2017 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef GDB_OPTIONAL_H
  21 #define GDB_OPTIONAL_H
  22
  23 namespace gdb
  24 {
  25
  26 /* This class attempts to be a compatible subset of std::optional,
  27    which is slated to be available in C++17.  This class optionally
  28    holds an object of some type -- by default it is constructed not
  29    holding an object, but later the object can be "emplaced".  This is
  30    similar to using std::unique_ptr, but in-object allocation is
  31    guaranteed.  */
  32 template<typename T>
  33 class optional
  34 {
  35 public:
  36
  37   optional ()
  38     : m_instantiated (false)
  39   {
  40   }
  41
  42   ~optional ()
  43   {
  44     if (m_instantiated)
  45       destroy ();
  46   }
  47
  48   /* These aren't deleted in std::optional, but it was simpler to
  49      delete them here, because currently the users of this class don't
  50      need them, and making them depend on the definition of T is
  51      somewhat complicated.  */
  52   optional (const optional &other) = delete;
  53   optional<T> &operator= (const optional &other) = delete;
  54
  55   template<typename... Args>
  56   void emplace (Args &&... args)
  57   {
  58     if (m_instantiated)
  59       destroy ();
  60     new (&m_item) T (std::forward<Args>(args)...);
  61     m_instantiated = true;
  62   }
  63
  64   /* Observers.  */
  65   constexpr const T *operator-> () const
  66   { return std::addressof (this->get ()); }
  67
  68   T *operator-> ()
  69   { return std::addressof (this->get ()); }
  70
  71   constexpr const T &operator* () const &
  72   { return this->get (); }
  73
  74   T &operator* () &
  75   { return this->get (); }
  76
  77   T &&operator* () &&
  78   { return std::move (this->get ()); }
  79
  80   constexpr const T &&operator* () const &&
  81   { return std::move (this->get ()); }
  82
  83   constexpr explicit operator bool () const noexcept
  84   { return m_instantiated; }
  85
  86   constexpr bool has_value () const noexcept
  87   { return m_instantiated; }
  88
  89 private:
  90
  91   /* Destroy the object.  */
  92   void destroy ()
  93   {
  94     gdb_assert (m_instantiated);
  95     m_instantiated = false;
  96     m_item.~T ();
  97   }
  98
  99   /* The get operations have m_instantiated as a precondition.  */
 100   T &get () noexcept { return m_item; }
 101   constexpr const T &get () const noexcept { return m_item; }
 102
 103   /* The object.  */
 104   union
 105   {
 106     struct { } m_dummy;
 107     T m_item;
 108   };
 109
 110   /* True if the object was ever emplaced.  */
 111   bool m_instantiated;
 112 };
 113
 114 }
 115
 116 #endif /* GDB_OPTIONAL_H */