ScopeGuard.h

#pragma once
 
#include <type_traits>
#include <utility>
 
namespace CesiumUtility {
template <typename ExitFunction> class ScopeGuard {
public:
  template <
      typename ExitFunctionArg,
      typename std::enable_if_t<
          !std::is_same_v<
              std::remove_reference_t<std::remove_const_t<ExitFunctionArg>>,
              ScopeGuard<ExitFunction>>,
          int> = 0>
  explicit ScopeGuard(ExitFunctionArg&& exitFunc)
      : _callExitFuncOnDestruct{true},
        _exitFunc{std::forward<ExitFunctionArg>(exitFunc)} {}
 
  ScopeGuard(const ScopeGuard& rhs) = delete;
 
  ScopeGuard(ScopeGuard&& rhs) noexcept
      : _callExitFuncOnDestruct{rhs._callExitFuncOnDestruct},
        _exitFunc{std::move(rhs._exitFunc)} {
    rhs.release();
  }
 
  ScopeGuard& operator=(const ScopeGuard& rhs) = delete;
 
  ScopeGuard& operator=(ScopeGuard&& rhs) noexcept {
    if (&rhs != this) {
      _callExitFuncOnDestruct = rhs._callExitFuncOnDestruct;
      _exitFunc = std::move(rhs._exitFunc);
      rhs.release();
    }
 
    return *this;
  }
 
  ~ScopeGuard() noexcept {
    if (_callExitFuncOnDestruct) {
      _exitFunc();
    }
  }
 
  void release() noexcept { _callExitFuncOnDestruct = false; }
 
private:
  bool _callExitFuncOnDestruct;
  ExitFunction _exitFunc;
};
 
template <typename ExitFunction>
ScopeGuard(ExitFunction) -> ScopeGuard<ExitFunction>;
} // namespace CesiumUtility