Home | History | Annotate | Line # | Download | only in gdbsupport 
      1 /* scoped_restore, a simple class for saving and restoring a value
      2 
      3    Copyright (C) 2016-2024 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 COMMON_SCOPED_RESTORE_H
     21 #define COMMON_SCOPED_RESTORE_H
     22 
     23 /* Base class for scoped_restore_tmpl.  */
     24 class scoped_restore_base
     25 {
     26 public:
     27   /* This informs the (scoped_restore_tmpl<T>) dtor that you no longer
     28      want the original value restored.  */
     29   void release () const
     30   { m_saved_var = NULL; }
     31 
     32 protected:
     33   scoped_restore_base (void *saved_var)
     34     : m_saved_var (saved_var)
     35   {}
     36 
     37   /* The type-erased saved variable.  This is here so that clients can
     38      call release() on a "scoped_restore" local, which is a typedef to
     39      a scoped_restore_base.  See below.  */
     40   mutable void *m_saved_var;
     41 };
     42 
     43 /* A convenience typedef.  Users of make_scoped_restore declare the
     44    local RAII object as having this type.  */
     45 typedef const scoped_restore_base &scoped_restore;
     46 
     47 /* An RAII-based object that saves a variable's value, and then
     48    restores it again when this object is destroyed. */
     49 template<typename T>
     50 class scoped_restore_tmpl : public scoped_restore_base
     51 {
     52  public:
     53 
     54   /* Create a new scoped_restore object that saves the current value
     55      of *VAR.  *VAR will be restored when this scoped_restore object
     56      is destroyed.  */
     57   scoped_restore_tmpl (T *var)
     58     : scoped_restore_base (var),
     59       m_saved_value (*var)
     60   {
     61   }
     62 
     63   /* Create a new scoped_restore object that saves the current value
     64      of *VAR, and sets *VAR to VALUE.  *VAR will be restored when this
     65      scoped_restore object is destroyed.  This is templated on T2 to
     66      allow passing VALUEs of types convertible to T.
     67      E.g.: T='base'; T2='derived'.  */
     68   template <typename T2>
     69   scoped_restore_tmpl (T *var, T2 value)
     70     : scoped_restore_base (var),
     71       m_saved_value (*var)
     72   {
     73     *var = value;
     74   }
     75 
     76   scoped_restore_tmpl (const scoped_restore_tmpl<T> &other)
     77     : scoped_restore_base {other.m_saved_var},
     78       m_saved_value (other.m_saved_value)
     79   {
     80     other.m_saved_var = NULL;
     81   }
     82 
     83   ~scoped_restore_tmpl ()
     84   {
     85     if (saved_var () != NULL)
     86       *saved_var () = m_saved_value;
     87   }
     88 
     89 private:
     90   /* Return a pointer to the saved variable with its type
     91      restored.  */
     92   T *saved_var ()
     93   { return static_cast<T *> (m_saved_var); }
     94 
     95   /* No need for this.  It is intentionally not defined anywhere.  */
     96   scoped_restore_tmpl &operator= (const scoped_restore_tmpl &);
     97 
     98   /* The saved value.  */
     99   const T m_saved_value;
    100 };
    101 
    102 /* Make a scoped_restore.  This is useful because it lets template
    103    argument deduction work.  */
    104 template<typename T>
    105 scoped_restore_tmpl<T> make_scoped_restore (T *var)
    106 {
    107   return scoped_restore_tmpl<T> (var);
    108 }
    109 
    110 /* Make a scoped_restore.  This is useful because it lets template
    111    argument deduction work.  */
    112 template<typename T, typename T2>
    113 scoped_restore_tmpl<T> make_scoped_restore (T *var, T2 value)
    114 {
    115   return scoped_restore_tmpl<T> (var, value);
    116 }
    117 
    118 #endif /* COMMON_SCOPED_RESTORE_H */
    119