<h2>Editing File: /usr/include/mysql/server/private/scope.h</h2><form method='post'><textarea name='content' class='file-edit'>/*
   Copyright (c) 2020, MariaDB

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; version 2 of
   the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335  USA
*/

#pragma once

#include &lt;type_traits&gt;
#include &lt;utility&gt;

namespace detail
{

template &lt;typename Callable&gt; class scope_exit
{
public:
  template &lt;typename F&gt;
  explicit scope_exit(F &amp;&amp;f) : function_(std::forward&lt;F&gt;(f))
  {
  }

  template &lt;typename F&gt;
  scope_exit(F &amp;&amp;f, bool engaged) : function_(std::forward&lt;F&gt;(f)), engaged_(engaged)
  {
  }

  scope_exit(scope_exit &amp;&amp;rhs)
      : function_(std::move(rhs.function_)), engaged_(rhs.engaged_)
  {
    rhs.release();
  }

  scope_exit(const scope_exit &amp;)= delete;
  scope_exit &amp;operator=(scope_exit &amp;&amp;)= delete;
  scope_exit &amp;operator=(const scope_exit &amp;)= delete;

  void release() { engaged_= false; }
  void engage() { DBUG_ASSERT(!engaged_); engaged_= true; }

  ~scope_exit()
  {
    if (engaged_)
      function_();
  }

private:
  Callable function_;
  bool engaged_= true;
};

} // end namespace detail

template &lt;typename Callable&gt;
inline
::detail::scope_exit&lt;typename std::decay&lt;Callable&gt;::type&gt;
make_scope_exit(Callable &amp;&amp;f, bool engaged= true)
{
  return ::detail::scope_exit&lt;typename std::decay&lt;Callable&gt;::type&gt;(
      std::forward&lt;Callable&gt;(f), engaged);
}

#define CONCAT_IMPL(x, y) x##y
#define CONCAT(x, y) CONCAT_IMPL(x, y)
#define ANONYMOUS_VARIABLE CONCAT(_anonymous_variable, __LINE__)

#define SCOPE_EXIT auto ANONYMOUS_VARIABLE= make_scope_exit

#define IF_CLASS(C) typename std::enable_if&lt;std::is_class&lt;C&gt;::value&gt;::type
#define IF_NOT_CLASS(C) typename std::enable_if&lt;!std::is_class&lt;C&gt;::value&gt;::type

namespace detail
{

template &lt;typename T&gt;
class Scope_value
{
public:
  // Use SFINAE for passing structs by reference and plain types by value.
  // This ctor is defined only if T is a class or struct:
  template &lt;typename U = T, typename = IF_CLASS(U)&gt;
  Scope_value(T &amp;variable, const T &amp;scope_value)
      : variable_(&amp;variable), saved_value_(variable)
  {
    variable= scope_value;
  }

  // This ctor is defined only if T is NOT a class or struct:
  template &lt;typename U = T, typename = IF_NOT_CLASS(U)&gt;
  Scope_value(T &amp;variable, const T scope_value)
      : variable_(&amp;variable), saved_value_(variable)
  {
    variable= scope_value;
  }

  Scope_value(Scope_value &amp;&amp;rhs)
      : variable_(rhs.variable_), saved_value_(rhs.saved_value_)
  {
    rhs.variable_= NULL;
  }

  Scope_value(const Scope_value &amp;)= delete;
  Scope_value &amp;operator=(const Scope_value &amp;)= delete;
  Scope_value &amp;operator=(Scope_value &amp;&amp;)= delete;

  ~Scope_value()
  {
    if (variable_)
      *variable_= saved_value_;
  }

private:
  T *variable_;
  T saved_value_;
};

} // namespace detail

// Use like this:
// auto _= make_scope_value(var, tmp_value);

template &lt;typename T, typename = IF_CLASS(T)&gt;
inline
::detail::Scope_value&lt;T&gt; make_scope_value(T &amp;variable, const T &amp;scope_value)
{
  return ::detail::Scope_value&lt;T&gt;(variable, scope_value);
}

template &lt;typename T, typename = IF_NOT_CLASS(T)&gt;
inline
::detail::Scope_value&lt;T&gt; make_scope_value(T &amp;variable, T scope_value)
{
  return ::detail::Scope_value&lt;T&gt;(variable, scope_value);
}

/*
  Note: perfect forwarding version can not pass const:

  template &lt;typename T, typename U&gt;
  inline
  detail::Scope_value&lt;T&gt; make_scope_value(T &amp;variable, U &amp;&amp;scope_value)
  {
      return detail::Scope_value&lt;T&gt;(variable, std::forward&lt;U&gt;(scope_value));
  }

  as `const U &amp;&amp;` fails with error `expects an rvalue for 2nd argument`. That
  happens because const U &amp;&amp; is treated as rvalue only (this is the exact syntax
  for declaring rvalues).
*/


#define SCOPE_VALUE auto ANONYMOUS_VARIABLE= make_scope_value
#define SCOPE_SET(VAR, MASK) auto ANONYMOUS_VARIABLE= make_scope_value(VAR, VAR | MASK)
#define SCOPE_CLEAR(VAR, MASK) auto ANONYMOUS_VARIABLE= make_scope_value(VAR, VAR &amp; ~MASK)
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Finclude%2Fmysql%2Fserver%2Fprivate'>Back to Directory</a>