libcruft-util/scoped.hpp
Danny Robson d74fca4e98 scoped: simplify universal references
this avoids problems with use after stack unwind discovered using
sanitizers.
2018-06-18 13:51:59 +10:00

110 lines
2.9 KiB
C++

/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Copyright 2012-2018, Danny Robson <danny@nerdcruft.net>
*/
#pragma once
#include <functional>
namespace util::scoped {
///////////////////////////////////////////////////////////////////////////
/// restores a referenced target variable to its original value at
/// destruction time. the type must be copyable.
template <typename ValueT>
class restore {
public:
explicit restore (ValueT &_target):
m_target (_target),
m_value (_target)
{ ; }
~restore ()
{
m_target = m_value;
}
private:
ValueT &m_target;
ValueT const m_value;
};
//-------------------------------------------------------------------------
template <typename ValueT>
restore (ValueT&) -> restore<ValueT>;
///////////////////////////////////////////////////////////////////////////
/// increments the referenced variable at construction time, and
/// decrements at destruction time.
template <typename ValueT>
class increment {
public:
explicit increment (ValueT &_target):
m_target (_target)
{
++m_target;
}
~increment ()
{
--m_target;
}
private:
ValueT &m_target;
};
//-------------------------------------------------------------------------
template <typename ValueT>
increment (ValueT&) -> increment<ValueT>;
///////////////////////////////////////////////////////////////////////////
/// calls a function with the supplied arguments at destruction time
template <typename FuncT, typename ...Args>
class function {
public:
explicit function (FuncT &&_function, Args&& ..._args):
m_function (std::forward<FuncT> (_function)),
m_args (std::forward<Args> (_args)...)
{ ; }
function (function&&);
function (const function&);
~function ()
{
if (m_enabled)
std::apply (m_function, m_args);
}
void disable (void) { m_enabled = false; }
private:
bool m_enabled = true;
FuncT m_function;
std::tuple<Args...> m_args;
};
//-------------------------------------------------------------------------
template <typename FuncT, typename ...Args>
function (FuncT,Args...) -> function<FuncT,Args...>;
};