Registry::GroupItemBase Struct Reference

Common abstract base class for items that group other items. More...

#include <Registry.h>

Inheritance diagram for Registry::GroupItemBase:

Collaboration diagram for Registry::GroupItemBase:

Public Types
enum	Ordering { Anonymous , Weak , Strong }
	Choose treatment of the children of the group when merging trees. More...
Public Types inherited from Composite::Base< BaseItem, std::unique_ptr< BaseItem >, const Identifier & >
using	value_type = std::unique_ptr< BaseItem >
using	Items = std::vector< value_type >

Public Member Functions
	GroupItemBase (const GroupItemBase &)=delete
GroupItemBase &	operator= (const GroupItemBase &)=delete
	~GroupItemBase () override=0
virtual Ordering	GetOrdering () const
	Default implementation returns Strong. More...
Public Member Functions inherited from Composite::Base< BaseItem, std::unique_ptr< BaseItem >, const Identifier & >
	Base (ComponentArgs... args)
	Base (const Base &)=delete
Base &	operator= (const Base &)=delete
auto	begin () const
auto	end () const
auto	cbegin () const
auto	cend () const
auto	rbegin () const
auto	rend () const
auto	crbegin () const
auto	crend () const
void	push_back (value_type ptr)
bool	empty () const

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

Additional Inherited Members
Protected Attributes inherited from Composite::Base< BaseItem, std::unique_ptr< BaseItem >, const Identifier & >
Items	items

Detailed Description

Common abstract base class for items that group other items.

Definition at line 168 of file Registry.h.

Member Enumeration Documentation

Ordering

enum Registry::GroupItemBase::Ordering

Choose treatment of the children of the group when merging trees.

Enumerator
Anonymous	Item's name is ignored (omitted from paths) and sub-items are merged individually, sequenced by preferences or ordering hints
Weak	Item's name is significant in paths, but its sequence of children may be overridden if it merges with another group at the same path
Strong	Item's name is significant and it is intended to be the unique strongly ordered group at its path (but this could fail and cause an alpha-build-only error message during merging)

Definition at line 178 of file Registry.h.

                    {
         Anonymous,
         Weak,
         Strong,
      };

Constructor & Destructor Documentation

GroupItemBase()

Registry::GroupItemBase::GroupItemBase ( const GroupItemBase &  )

delete

~GroupItemBase()

GroupItemBase::~GroupItemBase ( )

overridepure virtual

Definition at line 726 of file Registry.cpp.

{}

Member Function Documentation

GetOrdering()

auto GroupItemBase::GetOrdering ( ) const

virtual

Default implementation returns Strong.

Reimplemented in anonymous_namespace{Registry.cpp}::PlaceHolder.

Definition at line 727 of file Registry.cpp.

{ return Strong; }

References Strong.

Referenced by anonymous_namespace{Registry.cpp}::CollectedItems::SubordinateMultipleItems().

Here is the caller graph for this function:

operator=()

GroupItemBase & Registry::GroupItemBase::operator= ( const GroupItemBase &  )

delete

Friends And Related Function Documentation

RegisterItem

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

friend

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

---

The documentation for this struct was generated from the following files:

• Registry.h
• Registry.cpp