Registry.h

Go to the documentation of this file.

/**********************************************************************
 
Audacity: A Digital Audio Editor
 
Registry.h
 
Paul Licameli split from CommandManager.h
 
**********************************************************************/
 
#ifndef __AUDACITY_REGISTRY__
#define __AUDACITY_REGISTRY__
 
#include "Prefs.h"
#include "Composite.h"
#include "TypeSwitch.h"
#include "Variant.h"
#include <functional>
#include <type_traits>
#include <utility>
 
// Define classes and functions that associate parts of the user interface
// with path names
namespace Registry {
   struct REGISTRIES_API EmptyContext{
      static EmptyContext Instance;
   };
   struct DefaultTraits {
      template<typename... T> using List = TypeList::List<T...>;
      using ComputedItemContextType = EmptyContext;
      using LeafTypes = TypeList::Nil;
      using NodeTypes = TypeList::Nil;
   };
 
   // Items in the registry form an unordered tree, but each may also describe a
   // desired insertion point among its peers.  The request might not be honored
   // (as when the other name is not found, or when more than one item requests
   // the same ordering), but this is not treated as an error.
   struct OrderingHint
   {
      enum Type : int {
         Before, After,
         Begin, End,
         Unspecified // keep this last
      } type;
 
      // name of some other BaseItem; significant only when type is Before or
      // After:
      Identifier name;
 
      OrderingHint(Type type = Unspecified, const wxString &name = {})
         : type{ type }, name{ name } {}
 
      bool operator == ( const OrderingHint &other ) const
      { return name == other.name && type == other.type; }
 
      bool operator < ( const OrderingHint &other ) const
      {
         // This sorts unspecified placements later
         return std::make_pair( type, name ) <
            std::make_pair( other.type, other.name );
      }
   };
 
   template<typename RegistryTraits> struct GroupItem;
   using Path = std::vector<Identifier>;
   struct Placement;
   struct SingleItem;
 
namespace detail { using namespace TypeList;
   struct GroupItemBase;
 
   struct REGISTRIES_API BaseItem {
      // declare at least one virtual function so dynamic_cast will work
      explicit
      BaseItem( const Identifier &internalName )
         : name{ internalName }
      {}
      virtual ~BaseItem();
 
      const Identifier name;
 
      OrderingHint orderingHint;
   };
 
   using BaseItemPtr = std::unique_ptr<BaseItem>;
 
   using BaseItemSharedPtr = std::shared_ptr<BaseItem>;
 
   struct REGISTRIES_API IndirectItemBase : BaseItem {
      explicit IndirectItemBase(const BaseItemSharedPtr &ptr)
         : BaseItem{ wxEmptyString }
         , ptr{ ptr }
      {}
      ~IndirectItemBase() override;
 
      BaseItemSharedPtr ptr;
   };
 
   struct ComputedItemBase;
 
   template<typename Type, typename List> struct ConsUnique {
      template<typename L> struct NotAlready {
         static constexpr bool value = !std::is_same_v<Type, Head_t<L>>;
      };
      using type = std::conditional_t<
         std::disjunction<Null<List>, NotAlready<List>>::value,
         Cons_t<Type, List>, List
      >;
   };
   template<typename Type, typename List> using ConsUnique_t
      = typename ConsUnique<Type, List>::type;
 
   template<typename RegistryTraits> using VisitedNodeTypes =
      ConsUnique_t<const GroupItem<RegistryTraits>, Map_t<Fn<std::add_const_t>,
         typename RegistryTraits::NodeTypes>>;
   template<typename RegistryTraits> using VisitedLeafTypes =
      ConsUnique_t<const SingleItem, Map_t<Fn<std::add_const_t>,
         typename RegistryTraits::LeafTypes>>;
   template<typename Types> using VisitorFunction =
      std::function<void(Head_t<Types> &, const Path &)>;
}
 
   using BaseItemTypes = TypeList::List<
      detail::IndirectItemBase, detail::ComputedItemBase,
      // see below
      struct SingleItem, struct detail::GroupItemBase
   >;
   template<typename Item> using AcceptableBaseItem =
      TypeList::HasBaseIn<Item, BaseItemTypes>;
   template<typename Item> constexpr auto AcceptableBaseItem_v =
      AcceptableBaseItem<Item>::value;
 
   template<typename RegistryTraits> struct AllTypes {
      using type = TypeList::Append_t<
         typename RegistryTraits::LeafTypes,
         typename RegistryTraits::NodeTypes
      >;
   };
   template<typename RegistryTraits> using AllTypes_t =
      typename AllTypes<RegistryTraits>::type;
 
   template<typename RegistryTraits> constexpr auto AcceptableTraits_v =
      TypeList::Every_v<TypeList::Fn<AcceptableBaseItem>,
         AllTypes_t<RegistryTraits>> &&
      TypeSwitch::TypeListCheck_v<detail::VisitedNodeTypes<RegistryTraits>> &&
      TypeSwitch::TypeListCheck_v<detail::VisitedLeafTypes<RegistryTraits>>;
 
namespace detail {
 
   template<typename Item>
   struct IndirectItem final : IndirectItemBase {
      using ItemType = Item;
      static_assert(AcceptableBaseItem_v<ItemType>);
      explicit IndirectItem(const std::shared_ptr<Item> &ptr)
         : IndirectItemBase{ ptr }
      {}
   };
}
 
   template<typename Item>
   inline std::unique_ptr<detail::IndirectItem<Item>> Indirect(
      const std::shared_ptr<Item> &ptr)
   {
      return std::make_unique<detail::IndirectItem<Item>>( ptr );
   }
 
namespace detail {
   struct REGISTRIES_API ComputedItemBase : BaseItem {
      using TypeErasedFactory = std::function<BaseItemSharedPtr(void*)>;
 
      explicit ComputedItemBase(const TypeErasedFactory &factory)
         : BaseItem(wxEmptyString)
         , factory{ move(factory) }
      {}
      ~ComputedItemBase() override;
 
      TypeErasedFactory factory;
   };
 
 
   template<typename Context, typename Item>
   struct ComputedItem final : ComputedItemBase {
      using ItemType = Item;
      static_assert(AcceptableBaseItem_v<ItemType>);
 
 
      template<typename Factory> ComputedItem(const Factory &factory)
         : ComputedItemBase{ [factory](void *p) -> BaseItemSharedPtr {
            // p comes from the compute item context argument of
            // Registry::Visit, passed by reference
            assert(p);
            return factory(*static_cast<Context *>(p));
         } }
      {}
   };
}
 
   struct REGISTRIES_API SingleItem : detail::BaseItem {
      using BaseItem::BaseItem;
      ~SingleItem() override = 0;
   };
 
namespace detail {
   REGISTRIES_API void RegisterItem(GroupItemBase &registry,
      const Placement &placement, BaseItemPtr pItem);
 
   struct REGISTRIES_API GroupItemBase : Composite::Base<
      BaseItem, std::unique_ptr<BaseItem>, const Identifier &
   > {
      using Base::Base;
   
      GroupItemBase(const GroupItemBase&) = delete;
      GroupItemBase& operator=(const GroupItemBase&) = delete;
      ~GroupItemBase() override = 0;
 
      enum Ordering {
         Anonymous,
         Weak,
         Strong,
      };
 
      virtual Ordering GetOrdering() const;
 
   private:
      friend REGISTRIES_API void RegisterItem(GroupItemBase &registry,
         const Placement &placement, BaseItemPtr pItem);
   };
}
 
   // Forward declarations necessary before customizing Composite::Traits
   template<typename RegistryTraits> struct GroupItem;
   namespace detail {
      template<typename RegistryTraits> struct Builder;
   }
}
 
template<typename RegistryTraits> struct Composite::Traits<
   Registry::detail::GroupItemBase, Registry::GroupItem<RegistryTraits>
> {
   static constexpr auto ItemBuilder =
   Registry::detail::Builder<RegistryTraits>{};
   template<typename T> static constexpr auto enables_item_type_v =
      !std::is_same_v<T, Registry::detail::BaseItemPtr>;
};
 
namespace Registry {
 
   template<typename RegistryTraits>
   struct GroupItem : Composite::Builder<
      detail::GroupItemBase, GroupItem<RegistryTraits>, const Identifier &
   > {
      ~GroupItem() override = default;
      using Composite::Builder<
         detail::GroupItemBase, GroupItem<RegistryTraits>, const Identifier &
      >::Builder;
   };
 
   // The /-separated path is relative to the GroupItem supplied to
   // RegisterItem.
   // For instance, wxT("Transport/Cursor") to locate an item under a sub-menu
   // of a main menu
   struct Placement {
      wxString path;
      OrderingHint hint;
 
      Placement(const wxString &path = {}, const OrderingHint &hint = {})
         : path{ path }, hint{ hint }
      {}
      Placement(const wxChar *path, const OrderingHint &hint = {})
         : path{ path }, hint{ hint }
      {}
   };
 
   template<typename T> struct ActualItem{ using type = T; };
   template<typename T> using ActualItem_t = typename ActualItem<T>::type;
   template<typename T> struct ActualItem<detail::IndirectItem<T>>
      { using type = ActualItem_t<T>; };
   template<typename C, typename T>
   struct ActualItem<detail::ComputedItem<C, T>>
      { using type = ActualItem_t<T>; };
 
   template<typename Item, typename TypeList> struct AcceptableItemType {
      static constexpr auto value =
         ::TypeList::HasBaseIn_v<ActualItem_t<Item>, TypeList>;
   };
 
   template<typename RegistryTraits, typename Item> using AcceptableType =
      AcceptableItemType<Item, AllTypes_t<RegistryTraits>>;
   template<typename RegistryTraits, typename Item>
   constexpr auto AcceptableType_v =
      AcceptableType<RegistryTraits, Item>::value;
 
namespace detail {
   template<typename RegistryTraits>
   struct Builder {
      using Context = typename RegistryTraits::ComputedItemContextType;
 
      template<typename ItemType>
      auto operator () (std::unique_ptr<ItemType> ptr) const {
         static_assert(AcceptableType_v<RegistryTraits, ItemType>);
         return move(ptr);
      }
      template<typename Factory,
         typename ItemType =
         typename std::invoke_result_t<Factory, Context&>::element_type
      >
      auto operator () (const Factory &factory) const {
         static_assert(AcceptableType_v<RegistryTraits, ItemType>);
         return std::make_unique<ComputedItem<Context, ItemType>>(factory);
      }
      template<typename ItemType>
      auto operator () (const std::shared_ptr<ItemType> &ptr) const {
         static_assert(AcceptableType_v<RegistryTraits, ItemType>);
         return std::make_unique<IndirectItem<ItemType>>(ptr);
      }
   };
}
 
   // registry collects items, before consulting preferences and ordering
   // hints, and applying the merge procedure to them.
   // This function puts one more item into the registry.
   // The sequence of calls to RegisterItem has no significance for
   // determining the visitation ordering.  When sequence is important, register
   // a GroupItem.
   template<typename RegistryTraits, typename Item>
   void RegisterItem(GroupItem<RegistryTraits> &registry,
      const Placement &placement, std::unique_ptr<Item> pItem)
   {
      static_assert(AcceptableTraits_v<RegistryTraits>);
      static_assert(AcceptableType_v<RegistryTraits, Item>,
         "Registered item must be of one of the types listed in the registry's "
         "traits");
      detail::RegisterItem(registry, placement, move(pItem));
   }
   
 
   template<typename RegistryClass>
   class RegisteredItem {
   public:
      template<typename Ptr>
      RegisteredItem(Ptr pItem, const Placement &placement = {})
      {
         if (pItem)
            RegisterItem(RegistryClass::Registry(), placement, move(pItem));
      }
   };
 
namespace detail {
   // Helpers allowing a single callable instead of a tuple
   template<typename V> auto ForwardTuple_(const V &visitor, std::false_type) {
      // Visitor is not a tuple
      return std::tuple<const V&>{ visitor };
   }
   template<typename V> auto ForwardTuple_(const V &visitor, std::true_type) {
      // Visitor is a tuple
      return Tuple::ForwardAll(visitor);
   }
   template<typename V> auto ForwardTuple(const V &visitor) {
      return ForwardTuple_(visitor,
         std::bool_constant<Tuple::is_tuple_like_v<V>>{});
   }
 
   template<typename V> auto MakeTuple_(const V &visitor, std::false_type) {
      // Visitor is not a tuple
      return std::tuple<V>{ visitor };
   }
   template<typename V> auto MakeTuple_(const V &visitor, std::true_type) {
      // Visitor is a tuple
      return Tuple::All(visitor);
   }
   template<typename V> auto MakeTuple(const V &visitor) {
      return MakeTuple_(visitor,
         std::bool_constant<Tuple::is_tuple_like_v<V>>{});
   }
 
   template<typename V> auto CaptureTuple_(const V &visitor, std::true_type) {
      // Capture by reference
      return ForwardTuple(visitor);
   }
   template<typename V> auto CaptureTuple_(const V &visitor, std::false_type) {
      // Capture by value
      return MakeTuple(visitor);
   }
   template<bool Reference, typename V> auto CaptureTuple(const V &visitor) {
      return CaptureTuple_(visitor, std::bool_constant<Reference>{});
   }
 
   template<typename Types, bool Reference, typename Visitor>
   VisitorFunction<Types> MakeVisitorFunction(const Visitor &visitor) {
      return [visitor = CaptureTuple<Reference>(visitor)](
         Head_t<Types> &object, const Path &path
      ){
         // The compile time checking of reachability of cases still applies
         // before the visitor is wrapped
         TypeSwitch::Dispatch<void, Types>(object, visitor, path);
      };
   }
 
   template<typename Visitors> static constexpr auto TupleSize =
      std::conditional_t<
         Tuple::is_tuple_like_v<Visitors>,
         std::tuple_size<Visitors>,
         std::integral_constant<size_t, 1>
      >::value;
 
   template<typename RegistryTraits> using NodeVisitorFunction =
      VisitorFunction<VisitedNodeTypes<RegistryTraits>>;
   template<typename RegistryTraits> using LeafVisitorFunction =
      VisitorFunction<VisitedLeafTypes<RegistryTraits>>;
   template<typename RegistryTraits> using VisitorFunctionTriple = std::tuple<
      NodeVisitorFunction<RegistryTraits>,
      LeafVisitorFunction<RegistryTraits>,
      NodeVisitorFunction<RegistryTraits>
   >;
}
 
 
   template<typename RegistryTraits, bool Reference = false>
   struct VisitorFunctions : std::variant<
      detail::LeafVisitorFunction<RegistryTraits>,
      detail::VisitorFunctionTriple<RegistryTraits>
   >{
      using NodeTypes = detail::VisitedNodeTypes<RegistryTraits>;
      using LeafTypes = detail::VisitedLeafTypes<RegistryTraits>;
 
 
      template<typename Visitors> VisitorFunctions(Visitors &&visitors) {
         using namespace detail;
         using namespace std;
         decltype(auto) forwarded = forward<Visitors>(visitors);
         static constexpr auto size = TupleSize<std::decay_t<Visitors>>;
         static_assert(size == 1 || size == 3);
         if constexpr (size == 1)
            this->template emplace<0>(
               MakeVisitorFunction<LeafTypes, Reference>(forwarded));
         else if constexpr (size == 3)
            this->template emplace<1>(
               MakeVisitorFunction<NodeTypes, Reference>(get<0>(forwarded)),
               MakeVisitorFunction<LeafTypes, Reference>(get<1>(forwarded)),
               MakeVisitorFunction<NodeTypes, Reference>(get<2>(forwarded)));
      }
      void BeginGroup(const GroupItem<RegistryTraits> &item, const Path &path)
      const {
         if (const auto *pTriple = std::get_if<1>(this))
            (std::get<0>(*pTriple))(item, path);
      }
      void Visit(const SingleItem &item, const Path &path) const {
         using Function = detail::LeafVisitorFunction<RegistryTraits>;
         static const auto selector = Callable::OverloadSet{
            [](const Function& fn) -> const Function & { return fn; },
            [](auto &&self) -> const Function & {
               return std::get<1>(self); }
         };
         const auto &function = Variant::Visit(selector, *this);
         function(item, path);
      }
      void EndGroup(const GroupItem<RegistryTraits> &item, const Path &path)
      const {
         if (const auto *pTriple = std::get_if<1>(this))
            (std::get<2>(*pTriple))(item, path);
      }
   };
 
   constexpr auto NoOp = [](auto&, auto&){};
 
namespace detail {
   class REGISTRIES_API VisitorBase
   {
   public:
      virtual ~VisitorBase();
      virtual void BeginGroup(const GroupItemBase &item, const Path &path)
         const = 0;
      virtual void Visit(const SingleItem &item, const Path &path)
         const = 0;
      virtual void EndGroup(const GroupItemBase &item, const Path &path)
         const = 0;
   };
 
   REGISTRIES_API void Visit(
      VisitorBase &visitor,
      const GroupItemBase *pTopItem,
      const GroupItemBase *pRegistry,
      void *pComputedItemContext);
 
 
   template<typename RegistryTraits, typename Visitors>
   struct Visitor : VisitorBase {
      using NodeTypes = ConsUnique_t<const GroupItemBase,
         VisitedNodeTypes<RegistryTraits>>;
      using LeafTypes = VisitedLeafTypes<RegistryTraits>;
      static constexpr auto size = TupleSize<Visitors>;
      static_assert(size == 1 || size == 3);
      Visitor(const Visitors &visitors) : visitors{ visitors } {}
 
      void BeginGroup(const GroupItemBase &item, const Path &path)
      const override {
         if constexpr (size == 3)
            TypeSwitch::Dispatch<void, NodeTypes>(item,
               ForwardTuple(std::get<0>(visitors)), path);
      }
      void Visit(const SingleItem &item, const Path &path) const override {
         TypeSwitch::Dispatch<void, LeafTypes>(item,
            ForwardTuple(std::get<size == 1 ? 0 : 1>(ForwardTuple(visitors))),
            path);
      }
      void EndGroup(const GroupItemBase &item, const Path &path)
      const override {
         if constexpr (size == 3)
            TypeSwitch::Dispatch<void, NodeTypes>(item,
               ForwardTuple(std::get<2>(visitors)), path);
      }
      const Visitors &visitors;
   };
}
 
 
   template<typename RegistryTraits, typename Visitors>
   void Visit(const Visitors &visitors,
      const GroupItem<RegistryTraits> *pTopItem,
      const GroupItem<RegistryTraits> *pRegistry = {},
      typename RegistryTraits::ComputedItemContextType &computedItemContext =
         RegistryTraits::ComputedItemContextType::Instance)
   {
      static_assert(AcceptableTraits_v<RegistryTraits>);
      detail::Visitor<RegistryTraits, Visitors> visitor{ visitors };
      detail::Visit(visitor, pTopItem, pRegistry, &computedItemContext);
   }
 
   template<typename RegistryTraits>
   void VisitWithFunctions(const VisitorFunctions<RegistryTraits> &visitors,
      const GroupItem<RegistryTraits> *pTopItem,
      const GroupItem<RegistryTraits> *pRegistry = {},
      typename RegistryTraits::ComputedItemContextType &computedItemContext =
         RegistryTraits::ComputedItemContextType::Instance)
   {
      static_assert(AcceptableTraits_v<RegistryTraits>);
      Variant::Visit([&](auto &&visitor){
         Visit(visitor, pTopItem, pRegistry, computedItemContext);
      }, visitors);
   }
 
   // Typically a static object.  Constructor initializes certain preferences
   // if they are not present.  These preferences determine an extrinsic
   // visitation ordering for registered items.  This is needed in some
   // places that have migrated from a system of exhaustive listings, to a
   // registry of plug-ins, and something must be done to preserve old
   // behavior.  It can be done in the central place using string literal
   // identifiers only, not requiring static compilation or linkage dependency.
   struct REGISTRIES_API
   OrderingPreferenceInitializer : PreferenceInitializer {
      using Literal = const wxChar *;
      using Pair = std::pair< Literal, Literal >;
      using Pairs = std::vector< Pair >;
      OrderingPreferenceInitializer(
         // Specifies the topmost preference section:
         Literal root,
         // Specifies /-separated Registry paths relative to root
         // (these should be blank or start with / and not end with /),
         // each with a ,-separated sequence of identifiers, which specify a
         // desired ordering at one node of the tree:
         Pairs pairs );
 
      void operator () () override;
 
   private:
      Pairs mPairs;
      Literal mRoot;
   };
 
#ifndef _WIN32
// extern explicit instantiation to avoid link time de-duplication
extern
#endif
       template struct
#ifdef _WIN32
// Can't do that on Windows, but need this to link:
                       __declspec(dllexport)
#endif
                                             GroupItem<DefaultTraits>;
}
 
#endif