Registry Namespace Reference

Namespaces
namespace	detail

Classes
struct	BaseItem
struct	DefaultTraits
struct	EmptyContext
struct	GroupItem
	Extends GroupItemBase with a variadic constructor. More...
struct	GroupItemBase
	Common abstract base class for items that group other items. More...
struct	OrderingHint
struct	OrderingPreferenceInitializer
struct	Placement
class	RegisteredItem
	Generates classes whose instances register items at construction. More...
struct	SingleItem
	Common abstract base class for items that are not groups. More...
class	Visitor

Typedefs
using	BaseItemPtr = std::unique_ptr< BaseItem >
using	BaseItemSharedPtr = std::shared_ptr< BaseItem >
using	BaseItemPtrs = std::vector< BaseItemPtr >

Functions
void	Visit (Visitor &visitor, BaseItem *pTopItem, const GroupItemBase *pRegistry)
void	RegisterItem (GroupItemBase &registry, const Placement &placement, BaseItemPtr pItem)
template<typename Item >
std::unique_ptr< detail::IndirectItem< Item > >	Indirect (const std::shared_ptr< Item > &ptr)
	A convenience function. More...

Typedef Documentation

BaseItemPtr

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

Definition at line 77 of file Registry.h.

BaseItemPtrs

using Registry::BaseItemPtrs = typedef std::vector<BaseItemPtr>

Definition at line 79 of file Registry.h.

BaseItemSharedPtr

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

Definition at line 78 of file Registry.h.

Function Documentation

Indirect()

template<typename Item >

std::unique_ptr< detail::IndirectItem< Item > > Registry::Indirect ( const std::shared_ptr< Item > &  ptr )

inline

A convenience function.

Definition at line 113 of file Registry.h.

   {
      return std::make_unique<detail::IndirectItem<Item>>( ptr );
   }

RegisterItem()

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

Parameters

pItem

Registry takes ownership

Definition at line 776 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 ) );
}

Referenced by Registry::RegisteredItem< Item, RegistryClass >::RegisteredItem(), and PopupMenuTable::RegisterItem().

Here is the caller graph for this function:

Visit()

REGISTRIES_API void Registry::Visit	(	Visitor &	visitor,
		BaseItem *	pTopItem,
		const GroupItemBase *	pRegistry
	)

Definition at line 739 of file Registry.cpp.

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

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

Referenced by compileTest(), PrefsPanel::DefaultFactories(), PopupMenuTable::ExtendMenu(), SnapFunctionsRegistry::Find(), PluginManager::GetConfigValue(), ExportPluginRegistry::Initialize(), Importer::Initialize(), ToolDock::LayoutToolBars(), anonymous_namespace{EditMenus.cpp}::OnCut(), RealtimeEffectListWindow::PickEffect(), LibraryPrefs::PopulateOrExchange(), ToolDock::PositionBar(), PluginManager::SetConfigValue(), Tester< Const, ref >::testCase(), NumericConverterRegistry::Visit(), MenuManager::Visit(), and SnapFunctionsRegistry::Visit().

Here is the call graph for this function:

Here is the caller graph for this function: