GlobalVariable.h

Go to the documentation of this file.

/**********************************************************************
 
 Audacity: A Digital Audio Editor
 
 @file GlobalVariable.h
 
 Paul Licameli
 
 **********************************************************************/
#ifndef __AUDACITY_GLOBAL_VARIABLE__
#define __AUDACITY_GLOBAL_VARIABLE__
 
#include <functional>
#include <memory>
#include <optional>
#include <type_traits>
#include <utility>
 
 
template <typename Tag, typename Type, auto initializer = nullptr,
   bool ScopedOnly = true>
class GlobalVariable {
   struct dummy{ explicit dummy(){} };
public:
   using variable_type = GlobalVariable;
   using stored_type = Type;
   using mutable_type = std::remove_const_t<Type>;
 
   static stored_type& Get()
   {
      // Force generation of non-inline Assign, in case it needs dllexport linkage
      &GlobalVariable::Assign;
      return Instance();
   }
 
 
   [[nodiscard]]
   static auto Set(  std::conditional_t<ScopedOnly, dummy,
      mutable_type> replacement)  -> std::conditional_t<ScopedOnly, void,
         mutable_type>
   {
      if constexpr (!ScopedOnly)
         return Assign(std::move(replacement));
   }
 
 
   class Scope
   {
   public:
      explicit Scope(mutable_type value)
         : m_previous{ Assign(std::move(value)) }
      {}
      Scope(Scope &&other) = default;
      Scope &operator=(Scope &&other) = default;
      ~Scope()
      {
         if constexpr (ScopedOnly)
            Assign(std::move(m_previous));
         else if (m_previous)
            Assign(std::move(*m_previous));
      }
      void Commit()
      {
         static_assert(!ScopedOnly);
         m_previous.reset();
      }
      bool HasValue() const
      {
         if constexpr (ScopedOnly)
            return true;
         else
            return m_previous.has_value();
      }
 
   private:
      std::conditional_t<ScopedOnly, mutable_type, std::optional<mutable_type>>
         m_previous;
   };
 
   struct Initializer { Initializer() { Instance(); } };
 
private:
   GlobalVariable() = delete;
 
   static mutable_type &Instance()
   {
      static_assert(!std::is_reference_v<stored_type>);
      if constexpr (std::is_convertible_v<
        decltype(initializer), mutable_type
      >) {
         static mutable_type instance{ initializer };
         return instance;
      }
      else if constexpr (initializer != nullptr) {
         static mutable_type instance{ initializer() };
         return instance;
      }
      else {
         static mutable_type instance;
         return instance;
      }
   }
 
   static mutable_type Assign(mutable_type &&replacement)
   {
      auto &instance = Instance();
      auto result = std::move(instance);
      instance = std::move(replacement);
      return result;
   }
};
 
template<typename Tag, typename Signature, auto Default = nullptr,
   auto... Options>
class GlobalHook : public GlobalVariable<Tag,
   const std::function<Signature>, Default, Options...
>
{
public:
   using result_type = typename std::function<Signature>::result_type;
   using Scope = typename GlobalVariable<Tag,
      const std::function<Signature>, Default, Options...
   >::Scope;
 
 
   template<typename... Arguments>
   static result_type Call(Arguments &&...arguments)
   {
      auto &fn = GlobalHook::Get();
      if (fn)
         return fn(std::forward<Arguments>(arguments)...);
      else if constexpr (std::is_void_v<result_type>)
         return;
      else
         return result_type{};
   }
 
   template<typename Derived>
   struct SubstituteInUnique : Scope { SubstituteInUnique() : Scope{
      // Generic lambda is coerced to the needed pointer-to-function type
      [](auto &&...args) -> result_type { return
         std::make_unique<Derived>(std::forward<decltype(args)>(args)...);
      }
   }{}};
 
   template<typename Derived>
   struct SubstituteInShared : Scope { SubstituteInShared() : Scope{
      // Generic lambda is coerced to the needed pointer-to-function type
      [](auto &&...args) -> result_type { return
         std::make_shared<Derived>(std::forward<decltype(args)>(args)...);
      }
   }{}};
};
 
 
template<typename Tag, auto DefaultFunction, auto... Options>
class DefaultedGlobalHook : public GlobalHook< Tag,
   std::remove_pointer_t<decltype(DefaultFunction)>, DefaultFunction,
   Options...
>
{
};
 
#endif