Registry Namespace Reference

Classes
struct	BaseItem
struct	ComputedItem
struct	ConcreteGroupItem
struct	GroupItem
struct	InlineGroupItem
struct	OrderingHint
struct	OrderingPreferenceInitializer
struct	Placement
class	RegisteredItem
	Generates classes whose instances register items at construction. More...
struct	SharedItem
struct	SingleItem
struct	TransparentGroupItem
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 GroupItem *pRegistry)
void	RegisterItem (GroupItem &registry, const Placement &placement, BaseItemPtr pItem)
std::unique_ptr< SharedItem >	Shared (const BaseItemSharedPtr &ptr)

Typedef Documentation

BaseItemPtr

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

Definition at line 71 of file Registry.h.

BaseItemPtrs

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

Definition at line 73 of file Registry.h.

BaseItemSharedPtr

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

Definition at line 72 of file Registry.h.

Function Documentation

RegisterItem()

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

Parameters

pItem

Registry takes ownership

Definition at line 750 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.
   BaseItemPtrs *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< GroupItem* >( pItem.get() ); } );
 
      if ( iter2 != range.second ) {
         // A matching group in the registry, so descend
         pNode = static_cast< GroupItem* >( 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<TransparentGroupItem<>>( *pComponent );
      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 PackedArray::end(), Identifier::GET(), Registry::Placement::hint, Registry::GroupItem::items, Registry::BaseItem::name, and Registry::Placement::path.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Shared()

std::unique_ptr< SharedItem > Registry::Shared ( const BaseItemSharedPtr &  ptr )

inline

Definition at line 93 of file Registry.h.

      { return std::make_unique<SharedItem>( ptr ); }

Visit()

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

Definition at line 713 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 FileConfig::Flush(), gPrefs, Registry::BaseItem::orderingHint, and anonymous_namespace{Registry.cpp}::VisitItem().

Referenced by PrefsPanel::DefaultFactories(), Exporter::Exporter(), PopupMenuTable::ExtendMenu(), Importer::Initialize(), RealtimeEffectListWindow::PickEffect(), LibraryPrefs::PopulateOrExchange(), and MenuManager::Visit().

Here is the call graph for this function:

Here is the caller graph for this function: