Registry::detail Namespace Reference

Classes
struct	BaseItem
struct	Builder
struct	ComputedItem
struct	ComputedItemBase
struct	ConsUnique
struct	GroupItemBase
	Common abstract base class for items that group other items. More...
struct	IndirectItem
	An item that delegates to another held in a shared pointer. More...
struct	IndirectItemBase
struct	Visitor
	Type-erasing adapter class (with no std::function overhead) More...
class	VisitorBase

Typedefs
using	BaseItemPtr = std::unique_ptr< BaseItem >
using	BaseItemSharedPtr = std::shared_ptr< BaseItem >
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 &)>
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 > >

Functions
REGISTRIES_API void	RegisterItem (GroupItemBase &registry, const Placement &placement, BaseItemPtr pItem)
	Type-erased implementation details, don't call directly. More...
template<typename V >
auto	ForwardTuple_ (const V &visitor, std::false_type)
template<typename V >
auto	ForwardTuple_ (const V &visitor, std::true_type)
template<typename V >
auto	ForwardTuple (const V &visitor)
template<typename V >
auto	MakeTuple_ (const V &visitor, std::false_type)
template<typename V >
auto	MakeTuple_ (const V &visitor, std::true_type)
template<typename V >
auto	MakeTuple (const V &visitor)
template<typename V >
auto	CaptureTuple_ (const V &visitor, std::true_type)
template<typename V >
auto	CaptureTuple_ (const V &visitor, std::false_type)
template<bool Reference, typename V >
auto	CaptureTuple (const V &visitor)
template<typename Types , bool Reference, typename Visitor >
VisitorFunction< Types >	MakeVisitorFunction (const Visitor &visitor)
	Capture a callable for Visit() in a std::function wrapper. More...
REGISTRIES_API void	Visit (VisitorBase &visitor, const GroupItemBase *pTopItem, const GroupItemBase *pRegistry, void *pComputedItemContext)

Variables
template<typename Visitors >
static constexpr auto	TupleSize
	How large a tuple to make from Visitors. More...

Typedef Documentation

BaseItemPtr

using Registry::detail::BaseItemPtr = typedef std::unique_ptr<BaseItem>

Definition at line 91 of file Registry.h.

BaseItemSharedPtr

using Registry::detail::BaseItemSharedPtr = typedef std::shared_ptr<BaseItem>

Definition at line 93 of file Registry.h.

ConsUnique_t

template<typename Type , typename List >

using Registry::detail::ConsUnique_t = typedef typename ConsUnique<Type, List>::type

Definition at line 116 of file Registry.h.

LeafVisitorFunction

template<typename RegistryTraits >

using Registry::detail::LeafVisitorFunction = typedef VisitorFunction<VisitedLeafTypes<RegistryTraits> >

Definition at line 460 of file Registry.h.

NodeVisitorFunction

template<typename RegistryTraits >

using Registry::detail::NodeVisitorFunction = typedef VisitorFunction<VisitedNodeTypes<RegistryTraits> >

Definition at line 458 of file Registry.h.

VisitedLeafTypes

template<typename RegistryTraits >

using Registry::detail::VisitedLeafTypes = typedef ConsUnique_t<const SingleItem, Map_t<Fn<std::add_const_t>, typename RegistryTraits::LeafTypes> >

Definition at line 122 of file Registry.h.

VisitedNodeTypes

template<typename RegistryTraits >

using Registry::detail::VisitedNodeTypes = typedef ConsUnique_t<const GroupItem<RegistryTraits>, Map_t<Fn<std::add_const_t>, typename RegistryTraits::NodeTypes> >

Definition at line 119 of file Registry.h.

VisitorFunction

template<typename Types >

using Registry::detail::VisitorFunction = typedef std::function<void(Head_t<Types> &, const Path &)>

Definition at line 125 of file Registry.h.

VisitorFunctionTriple

template<typename RegistryTraits >

using Registry::detail::VisitorFunctionTriple = typedef std::tuple< NodeVisitorFunction<RegistryTraits>, LeafVisitorFunction<RegistryTraits>, NodeVisitorFunction<RegistryTraits> >

Definition at line 462 of file Registry.h.

Function Documentation

CaptureTuple()

template<bool Reference, typename V >

auto Registry::detail::CaptureTuple

(

const V &

visitor

)

Definition at line 434 of file Registry.h.

                                                                            {
      return CaptureTuple_(visitor, std::bool_constant<Reference>{});
   }

References CaptureTuple_().

Here is the call graph for this function:

CaptureTuple_() [1/2]

template<typename V >

auto Registry::detail::CaptureTuple_	(	const V &	visitor,
		std::false_type
	)

Definition at line 430 of file Registry.h.

                                                                            {
      // Capture by value
      return MakeTuple(visitor);
   }

References MakeTuple().

Here is the call graph for this function:

CaptureTuple_() [2/2]

template<typename V >

auto Registry::detail::CaptureTuple_	(	const V &	visitor,
		std::true_type
	)

Definition at line 426 of file Registry.h.

                                                                           {
      // Capture by reference
      return ForwardTuple(visitor);
   }

References ForwardTuple().

Referenced by CaptureTuple().

Here is the call graph for this function:

Here is the caller graph for this function:

ForwardTuple()

template<typename V >

auto Registry::detail::ForwardTuple

(

const V &

visitor

)

Definition at line 408 of file Registry.h.

                                                            {
      return ForwardTuple_(visitor,
         std::bool_constant<Tuple::is_tuple_like_v<V>>{});
   }

References ForwardTuple_().

Referenced by Registry::detail::Visitor< RegistryTraits, Visitors >::BeginGroup(), CaptureTuple_(), Registry::detail::Visitor< RegistryTraits, Visitors >::EndGroup(), and Registry::detail::Visitor< RegistryTraits, Visitors >::Visit().

Here is the call graph for this function:

Here is the caller graph for this function:

ForwardTuple_() [1/2]

template<typename V >

auto Registry::detail::ForwardTuple_	(	const V &	visitor,
		std::false_type
	)

Definition at line 400 of file Registry.h.

                                                                            {
      // Visitor is not a tuple
      return std::tuple<const V&>{ visitor };
   }

Referenced by ForwardTuple().

Here is the caller graph for this function:

ForwardTuple_() [2/2]

template<typename V >

auto Registry::detail::ForwardTuple_	(	const V &	visitor,
		std::true_type
	)

Definition at line 404 of file Registry.h.

                                                                           {
      // Visitor is a tuple
      return Tuple::ForwardAll(visitor);
   }

References Tuple::ForwardAll().

Here is the call graph for this function:

MakeTuple()

template<typename V >

auto Registry::detail::MakeTuple

(

const V &

visitor

)

Definition at line 421 of file Registry.h.

                                                         {
      return MakeTuple_(visitor,
         std::bool_constant<Tuple::is_tuple_like_v<V>>{});
   }

References MakeTuple_().

Referenced by CaptureTuple_().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeTuple_() [1/2]

template<typename V >

auto Registry::detail::MakeTuple_	(	const V &	visitor,
		std::false_type
	)

Definition at line 413 of file Registry.h.

                                                                         {
      // Visitor is not a tuple
      return std::tuple<V>{ visitor };
   }

Referenced by MakeTuple().

Here is the caller graph for this function:

MakeTuple_() [2/2]

template<typename V >

auto Registry::detail::MakeTuple_	(	const V &	visitor,
		std::true_type
	)

Definition at line 417 of file Registry.h.

                                                                        {
      // Visitor is a tuple
      return Tuple::All(visitor);
   }

References Tuple::All().

Here is the call graph for this function:

MakeVisitorFunction()

template<typename Types , bool Reference, typename Visitor >

VisitorFunction< Types > Registry::detail::MakeVisitorFunction

(

const Visitor &

visitor

)

Capture a callable for Visit() in a std::function wrapper.

Definition at line 440 of file Registry.h.

                                                                      {
      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);
      };
   }

RegisterItem()

void Registry::detail::RegisterItem	(	GroupItemBase &	registry,
		const Placement &	placement,
		BaseItemPtr	pItem
	)

Type-erased implementation details, don't call directly.

Definition at line 765 of file Registry.cpp.

{
   // Since registration determines only an unordered tree of menu items,
   // we can sort children of each node lexicographically for our convenience.
   std::vector<BaseItemPtr> *pItems{};
   struct Comparator {
      bool operator()
         ( const Identifier &component, const BaseItemPtr& pItem ) const {
            return component < pItem->name; }
      bool operator()
         ( const BaseItemPtr& pItem, const Identifier &component ) const {
            return pItem->name < component; }
   };
   auto find = [&pItems]( const Identifier &component ){ return std::equal_range(
      pItems->begin(), pItems->end(), component, Comparator() ); };
 
   auto pNode = &registry;
   pItems = &pNode->items;
 
   const auto pathComponents = ::wxSplit( placement.path, '/' );
   auto pComponent = pathComponents.begin(), end = pathComponents.end();
 
   // Descend the registry hierarchy, while groups matching the path components
   // can be found
   auto debugPath = wxString{'/'} + registry.name.GET();
   while ( pComponent != end ) {
      const auto &pathComponent = *pComponent;
 
      // Try to find an item already present that is a group item with the
      // same name; we don't care which if there is more than one.
      const auto range = find( pathComponent );
      const auto iter2 = std::find_if( range.first, range.second,
         [](const BaseItemPtr &pItem){
            return dynamic_cast< GroupItemBase* >( pItem.get() ); } );
 
      if ( iter2 != range.second ) {
         // A matching group in the registry, so descend
         pNode = static_cast< GroupItemBase* >( iter2->get() );
         pItems = &pNode->items;
         debugPath += '/' + pathComponent;
         ++pComponent;
      }
      else
         // Insert at this level;
         // If there are no more path components, and a name collision of
         // the added item with something already in the registry, don't resolve
         // it yet in this function, but see MergeItems().
         break;
   }
 
   // Create path group items for remaining components
   while ( pComponent != end ) {
      auto newNode =
         std::make_unique<PlaceHolder>(*pComponent, GroupItemBase::Weak);
      pNode = newNode.get();
      pItems->insert( find( pNode->name ).second, std::move( newNode ) );
      pItems = &pNode->items;
      ++pComponent;
   }
 
   // Remember the hint, to be used later in merging.
   pItem->orderingHint = placement.hint;
 
   // Now insert the item.
   pItems->insert( find( pItem->name ).second, std::move( pItem ) );
}

References details::end(), Registry::Placement::hint, Composite::Base< Component, ComponentPointer, ComponentArgs >::items, and Registry::Placement::path.

Referenced by Registry::RegisterItem().

Here is the call graph for this function:

Here is the caller graph for this function:

Visit()

void Registry::detail::Visit	(	VisitorBase &	visitor,
		const GroupItemBase *	pTopItem,
		const GroupItemBase *	pRegistry,
		void *	pComputedItemContext
	)

Definition at line 725 of file Registry.cpp.

{
   assert(pComputedItemContext);
   std::vector< BaseItemSharedPtr > computedItems;
   bool doFlush = false;
   CollectedItems collection{ {}, computedItems };
   Path emptyPath;
   VisitItem(
      visitor, collection, emptyPath, pTopItem,
      pRegistry, pRegistry->orderingHint, doFlush, pComputedItemContext);
   // Flush any writes done by MergeItems()
   if (doFlush)
      gPrefs->Flush();
}

References audacity::BasicSettings::Flush(), gPrefs, and anonymous_namespace{Registry.cpp}::VisitItem().

Here is the call graph for this function:

Variable Documentation

TupleSize

template<typename Visitors >

constexpr auto Registry::detail::TupleSize

staticconstexpr

Initial value:

=
      std::conditional_t<
         Tuple::is_tuple_like_v<Visitors>,
         std::tuple_size<Visitors>,
         std::integral_constant<size_t, 1>
      >::value

How large a tuple to make from Visitors.

Definition at line 451 of file Registry.h.