ScopeGuard.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2018 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Martin Ritter                                            *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <functional>
#include <ios>
#include <TSystem.h>
#include <TROOT.h>
#include <string>
 
namespace Belle2 {
  class ScopeGuard {
  private:
    std::function<void()> m_exitfunc;
    bool m_engaged{true};
  public:
    template<class Callable> explicit ScopeGuard(Callable&& f): m_exitfunc{std::forward<Callable>(f)} {}
    ScopeGuard(const ScopeGuard&) = delete;
    ScopeGuard(ScopeGuard&& sg) = delete;
    ScopeGuard& operator=(const ScopeGuard&) = delete;
    ScopeGuard& operator=(ScopeGuard&&) = delete;
    ~ScopeGuard() { if (m_engaged) m_exitfunc(); }
    void release() { m_engaged = false; }
 
    template<class T> [[nodiscard]] static ScopeGuard guardValue(T& reference)
    {
      // the [[nodiscard]] will issue warnings when users just call this
      // function and don't assign the ScopeGuard
      const T old = reference;
      // This works even without any assignment or move constructors since
      // C++17 guarantees that this temporary object will be constructed in
      // place and no movement is required (tags: RVO, copy elision)
      return ScopeGuard([&reference, old]() { reference = old; });
    }
 
    template<class T, class V> [[nodiscard]] static ScopeGuard guardValue(T& reference, const V& newValue)
    {
      const T old = reference;
      reference = newValue;
      return ScopeGuard([&reference, old]() { reference = old; });
    }
 
    template<class Getter, class Setter> [[nodiscard]]
    static ScopeGuard guardGetterSetter(Getter getter, Setter setter)
    {
      const auto old = getter();
      return ScopeGuard([setter, old]() { setter(old); });
    }
 
    template<class Getter, class Setter> [[nodiscard]]
    static ScopeGuard guardGetterSetter(const Getter& getter, Setter setter,
                                        const typename std::result_of<Getter()>::type newValue)
    {
      const auto old = getter();
      setter(newValue);
      return ScopeGuard([setter, old]() { setter(old); });
    }
 
    template<class Functor> [[nodiscard]] static ScopeGuard guardFunctor(Functor functor)
    {
      typedef typename std::result_of<Functor()>::type value_type;
      std::function<void(const value_type&)> setter(functor);
      const auto old = functor();
      return ScopeGuard([setter, old] {setter(old);});
    }
 
    template<class Functor> [[nodiscard]]
    static ScopeGuard guardFunctor(Functor functor, const typename std::result_of<Functor()>::type& newValue)
    {
      typedef typename std::result_of<Functor()>::type value_type;
      std::function<void(const value_type&)> setter(functor);
      const auto old = functor();
      setter(newValue);
      return ScopeGuard([setter, old] {setter(old);});
    }
 
    template <class T> [[nodiscard]] static ScopeGuard guardDeletion(T*& pointer)
    {
      return ScopeGuard([&pointer]() { delete pointer; pointer = nullptr; });
    }
 
    template<class CharT, class Traits = typename std::char_traits<CharT>> [[nodiscard]]
    static ScopeGuard guardStreamState(std::basic_ios<CharT, Traits>& stream)
    {
      const std::ios::fmtflags flags{stream.flags()};
      const std::streamsize precision{stream.precision()};
      const std::streamsize width{stream.width()};
      const CharT fill{stream.fill()};
 
      return ScopeGuard([ =, &stream]() {
        stream.flags(flags);
        stream.precision(precision);
        stream.width(width);
        stream.fill(fill);
      });
    }
 
    [[nodiscard]] static ScopeGuard guardWorkingDirectory()
    {
      const std::string old{gSystem->GetWorkingDirectory()};
      return ScopeGuard([old]() {gSystem->ChangeDirectory(old.c_str());});
    }
 
    [[nodiscard]] static ScopeGuard guardWorkingDirectory(const std::string& newDirectory)
    {
      const std::string old{gSystem->GetWorkingDirectory()};
      gSystem->ChangeDirectory(newDirectory.c_str());
      return ScopeGuard([old]() {gSystem->ChangeDirectory(old.c_str());});
    }
 
    [[nodiscard]] static ScopeGuard guardBatchMode(bool batchMode = true)
    {
      auto getBatchMode = []() {
        return gROOT->IsBatch();
      };
 
      auto setBatchMode = [](bool batchMode_) {
        gROOT->SetBatch(batchMode_);
      };
 
      return guardGetterSetter(getBatchMode, setBatchMode, batchMode);
    }
  };
}