anonymous_namespace{Registry.cpp}::CollectedItems Struct Reference

Collaboration diagram for anonymous_namespace{Registry.cpp}::CollectedItems:

Classes
struct	Item

Public Types
using	Iterator = decltype(items)::iterator
using	NewItem = std::pair< BaseItem *, OrderingHint >
using	NewItems = std::vector< NewItem >

Public Member Functions
auto	Find (const Identifier &name) -> Iterator
auto	InsertNewItemUsingPreferences (ItemOrdering &itemOrdering, BaseItem *pItem) -> bool
auto	InsertNewItemUsingHint (BaseItem *pItem, const OrderingHint &hint, size_t endItemsCount, bool force) -> bool
auto	MergeLater (Item &found, const Identifier &name, GroupItemBase::Ordering ordering) -> GroupItemBase *
void	SubordinateSingleItem (Item &found, BaseItem *pItem)
void	SubordinateMultipleItems (Item &found, GroupItemBase &items)
bool	MergeWithExistingItem (ItemOrdering &itemOrdering, BaseItem *pItem)
bool	MergeLikeNamedItems (ItemOrdering &itemOrdering, NewItems::const_iterator left, NewItems::const_iterator right, int iPass, size_t endItemsCount, bool force)
void	MergeItemsAscendingNamesPass (ItemOrdering &itemOrdering, NewItems &newItems, int iPass, size_t endItemsCount, bool force)
void	MergeItemsDescendingNamesPass (ItemOrdering &itemOrdering, NewItems &newItems, int iPass, size_t endItemsCount, bool force)
void	MergeItems (ItemOrdering &itemOrdering, const GroupItemBase &toMerge, const OrderingHint &hint, void *pComputedItemContext)

Public Attributes
std::vector< Item >	items
std::vector< BaseItemSharedPtr > &	computedItems

Detailed Description

Definition at line 39 of file Registry.cpp.

Member Typedef Documentation

Iterator

using anonymous_namespace{Registry.cpp}::CollectedItems::Iterator = decltype( items )::iterator

Definition at line 53 of file Registry.cpp.

NewItem

using anonymous_namespace{Registry.cpp}::CollectedItems::NewItem = std::pair< BaseItem*, OrderingHint >

Definition at line 81 of file Registry.cpp.

NewItems

using anonymous_namespace{Registry.cpp}::CollectedItems::NewItems = std::vector< NewItem >

Definition at line 82 of file Registry.cpp.

Member Function Documentation

Find()

auto anonymous_namespace{Registry.cpp}::CollectedItems::Find ( const Identifier &  name ) -> Iterator

inline

Definition at line 54 of file Registry.cpp.

   {
      auto end = items.end();
      return name.empty()
         ? end
         : std::find_if( items.begin(), end,
            [&]( const Item& item ){
               return name == item.visitNow->name; } );
   }

References details::end(), and name.

Here is the call graph for this function:

InsertNewItemUsingHint()

auto anonymous_namespace{Registry.cpp}::CollectedItems::InsertNewItemUsingHint	(	BaseItem *	pItem,
		const OrderingHint &	hint,
		size_t	endItemsCount,
		bool	force
	)		-> bool

Definition at line 288 of file Registry.cpp.

{
   auto begin = items.begin(), end = items.end(),
      insertPoint = end - endItemsCount;
 
   // pItem should have a name; if not, ignore the hint, and put it at the
   // default place, but only if in the final pass.
   if ( pItem->name.empty() ) {
      if ( !force )
         return false;
   }
   else {
      switch ( hint.type ) {
         case OrderingHint::Before:
         case OrderingHint::After: {
            // Default to the end if the name is not found.
            auto found = Find( hint.name );
            if ( found == end ) {
               if ( !force )
                  return false;
               else
                  insertPoint = found;
            }
            else {
               insertPoint = found;
               if ( hint.type == OrderingHint::After )
                  ++insertPoint;
            }
            break;
         }
         case OrderingHint::Begin:
            insertPoint = begin;
            break;
         case OrderingHint::End:
            insertPoint = end;
            break;
         case OrderingHint::Unspecified:
         default:
            if ( !force )
               return false;
            break;
      }
   }
 
   // Insert the item; the hint has been used and no longer matters
   items.insert( insertPoint, {pItem, nullptr,
      // Hints no longer matter:
      {}} );
   return true;
}

References details::begin(), Journal::Begin(), details::end(), and ActiveProjects::Find().

Here is the call graph for this function:

InsertNewItemUsingPreferences()

auto anonymous_namespace{Registry.cpp}::CollectedItems::InsertNewItemUsingPreferences	(	ItemOrdering &	itemOrdering,
		BaseItem *	pItem
	)		-> bool

Definition at line 247 of file Registry.cpp.

{
   // Note that if more than one plug-in registers items under the same
   // node, then it is not specified which plug-in is handled first,
   // the first time registration happens.  It might happen that you
   // add a plug-in, run the program, then add another, then run again;
   // registration order determined by those actions might not
   // correspond to the order of re-loading of modules in later
   // sessions.  But whatever ordering is chosen the first time some
   // plug-in is seen -- that ordering gets remembered in preferences.
 
   if ( !pItem->name.empty() ) {
      // Check saved ordering first, and rebuild that as well as is possible
      auto &ordering = itemOrdering.Get();
      auto begin2 = ordering.begin(), end2 = ordering.end(),
         found2 = std::find( begin2, end2, pItem->name );
      if ( found2 != end2 ) {
         auto insertPoint = items.end();
         // Find the next name in the saved ordering that is known already
         // in the collection.
         while ( ++found2 != end2 ) {
            auto known = Find( *found2 );
            if ( known != insertPoint ) {
               insertPoint = known;
               break;
            }
         }
         items.insert( insertPoint, {pItem, nullptr,
            // Hints no longer matter:
            {}} );
         return true;
      }
   }
 
   return false;
}

References ActiveProjects::Find().

Here is the call graph for this function:

MergeItems()

void anonymous_namespace{Registry.cpp}::CollectedItems::MergeItems	(	ItemOrdering &	itemOrdering,
		const GroupItemBase &	toMerge,
		const OrderingHint &	hint,
		void *	pComputedItemContext
	)

Definition at line 546 of file Registry.cpp.

{
   NewItems newItems;
 
   {
      // First do expansion of nameless groupings, and caching of computed
      // items, just as for the previously collected items.
      CollectedItems newCollection{ {}, computedItems };
      CollectItems(newCollection, toMerge, hint, pComputedItemContext);
 
      // Try to merge each, resolving name collisions with items already in the
      // tree, and collecting those with names that don't collide.
      for (const auto &item : newCollection.items)
         if (!MergeWithExistingItem(itemOrdering, item.visitNow))
             newItems.push_back({ item.visitNow, item.hint });
   }
 
   // Choose placements for items with NEW names.
 
   // First sort so that like named items are together, and for the same name,
   // items with more specific ordering hints come earlier.
   std::sort( newItems.begin(), newItems.end(), Comp );
 
   // Outer loop over trial passes.
   int iPass = -1;
   bool force = false;
   size_t oldSize = 0;
   size_t endItemsCount = 0;
   auto prevSize = newItems.size();
   while( !newItems.empty() )
   {
      // If several items have the same hint, we try to preserve the sort by
      // name (an internal identifier, not necessarily user visible), just to
      // have some determinacy.  That requires passing one or the other way
      // over newItems.
      bool descending =
         ( iPass == OrderingHint::After || iPass == OrderingHint::Begin );
 
      if ( descending )
         MergeItemsDescendingNamesPass(itemOrdering,
            newItems, iPass, endItemsCount, force);
      else
         MergeItemsAscendingNamesPass(itemOrdering,
            newItems, iPass, endItemsCount, force);
 
      auto newSize = newItems.size();
      ++iPass;
 
      if ( iPass == 0 )
         // Just tried insertion by preferences.  Don't try it again.
         oldSize = newSize;
      else if ( iPass == OrderingHint::Unspecified ) {
         if ( !force ) {
            iPass = 0, oldSize = newSize;
            // Are we really ready for the final pass?
            bool progress = ( oldSize > newSize );
            if ( progress )
               // No.  While some progress is made, don't force final placements.
               // Retry Before and After hints.
               ;
            else
               force = true;
         }
      }
      else if (iPass == OrderingHint::End && endItemsCount == 0)
      {
         assert(newSize >= prevSize || newSize == 0);
         // Remember the size before we put the ending items in place
         endItemsCount = newSize - prevSize;
      }
 
      prevSize = newSize;
   }
}

References Journal::Begin(), anonymous_namespace{Registry.cpp}::CollectItems(), and anonymous_namespace{Registry.cpp}::Comp().

Here is the call graph for this function:

MergeItemsAscendingNamesPass()

void anonymous_namespace{Registry.cpp}::CollectedItems::MergeItemsAscendingNamesPass	(	ItemOrdering &	itemOrdering,
		NewItems &	newItems,
		int	iPass,
		size_t	endItemsCount,
		bool	force
	)

Definition at line 500 of file Registry.cpp.

{
   // Inner loop over ranges of like-named items.
   auto rright = newItems.rbegin();
   auto rend = newItems.rend();
   while ( rright != rend ) {
      // Find the range
      using namespace std::placeholders;
      auto rleft = std::find_if(
         rright + 1, rend, std::bind( MajorComp, _1, *rright ) );
 
      bool success = MergeLikeNamedItems(itemOrdering,
         rleft.base(), rright.base(), iPass, endItemsCount, force);
 
      if ( success ) {
         auto diff = rend - rleft;
         newItems.erase( rleft.base(), rright.base() );
         rend = newItems.rend();
         rleft = rend - diff;
      }
      rright = rleft;
   }
}

References anonymous_namespace{Registry.cpp}::MajorComp().

Here is the call graph for this function:

MergeItemsDescendingNamesPass()

void anonymous_namespace{Registry.cpp}::CollectedItems::MergeItemsDescendingNamesPass	(	ItemOrdering &	itemOrdering,
		NewItems &	newItems,
		int	iPass,
		size_t	endItemsCount,
		bool	force
	)

Definition at line 525 of file Registry.cpp.

{
   // Inner loop over ranges of like-named items.
   auto left = newItems.begin();
   while ( left != newItems.end() ) {
      // Find the range
      using namespace std::placeholders;
      auto right = std::find_if(
         left + 1, newItems.end(), std::bind( MajorComp, *left, _1 ) );
 
      bool success = MergeLikeNamedItems(itemOrdering, left, right, iPass,
         endItemsCount, force );
 
      if ( success )
         left = newItems.erase( left, right );
      else
         left = right;
   }
};

References anonymous_namespace{Registry.cpp}::MajorComp().

Here is the call graph for this function:

MergeLater()

auto anonymous_namespace{Registry.cpp}::CollectedItems::MergeLater	(	Item &	found,
		const Identifier &	name,
		GroupItemBase::Ordering	ordering
	)		-> GroupItemBase *

Definition at line 341 of file Registry.cpp.

{
   auto subGroup = found.mergeLater;
   if (!subGroup) {
      auto newGroup = std::make_shared<PlaceHolder>(name, ordering);
      computedItems.push_back(newGroup);
      subGroup = found.mergeLater = newGroup.get();
   }
   return subGroup;
}

References name.

MergeLikeNamedItems()

bool anonymous_namespace{Registry.cpp}::CollectedItems::MergeLikeNamedItems	(	ItemOrdering &	itemOrdering,
		NewItems::const_iterator	left,
		NewItems::const_iterator	right,
		int	iPass,
		size_t	endItemsCount,
		bool	force
	)

Definition at line 437 of file Registry.cpp.

{
   // Try to place the first item of the range.
   // If such an item is a group, then we always retain the kind of
   // grouping that was registered.  (Which doesn't always happen when
   // there is name collision in MergeWithExistingItem.)
   auto iter = left;
   auto &item = *iter;
   auto pItem = item.first;
   const auto &hint = item.second;
   bool success = false;
   if ( iPass == -1 )
      // A first pass consults preferences.
      success = InsertNewItemUsingPreferences( itemOrdering, pItem );
   else if ( iPass == hint.type ) {
      // Later passes for choosing placements.
      // Maybe it fails in this pass, because a placement refers to some
      // other name that has not yet been placed.
      success =
         InsertNewItemUsingHint( pItem, hint, endItemsCount, force );
      wxASSERT( !force || success );
   }
 
   if ( success ) {
      // Resolve collisions among remaining like-named items.
      ++iter;
      if ( iter != right && iPass != 0 &&
          iter->second.type != OrderingHint::Unspecified &&
          !( iter->second == hint ) ) {
         // A diagnostic message sometimes
         ReportConflictingPlacements( itemOrdering.key, pItem->name );
      }
      while ( iter != right )
         // Re-invoke MergeWithExistingItem for this item, which is known
         // to have a name collision, so ignore the return value.
         MergeWithExistingItem(itemOrdering, iter++ -> first);
   }
 
   return success;
}

References anonymous_namespace{Registry.cpp}::ItemOrdering::key, and anonymous_namespace{Registry.cpp}::ReportConflictingPlacements().

Here is the call graph for this function:

MergeWithExistingItem()

bool anonymous_namespace{Registry.cpp}::CollectedItems::MergeWithExistingItem	(	ItemOrdering &	itemOrdering,
		BaseItem *	pItem
	)

Definition at line 370 of file Registry.cpp.

{
   // Assume no null pointers remain after CollectItems:
   const auto &name = pItem->name;
   const auto found = Find( name );
   if (found != items.end()) {
      // Collision of names between collection and registry!
      // There are 2 * 2 = 4 cases, as each of the two are group items or
      // not.
      auto pCollectionGroup = dynamic_cast< GroupItemBase * >( found->visitNow );
      auto pRegistryGroup = dynamic_cast< GroupItemBase * >( pItem );
      if (pCollectionGroup) {
         if (pRegistryGroup) {
            // This is the expected case of collision.
            // Subordinate items from one of the groups will be merged in
            // another call to MergeItems at a lower level of path.
            // Note, however, that at most one of the two should be a
            // strongly ordered item; if not, we must lose the extra
            // information carried by one of them.
            bool pCollectionGrouping =
               (pCollectionGroup->GetOrdering() != GroupItemBase::Strong);
            auto pRegistryGrouping =
               (pRegistryGroup->GetOrdering() != GroupItemBase::Strong);
            if ( !(pCollectionGrouping || pRegistryGrouping) )
               ReportGroupGroupCollision( itemOrdering.key, name );
 
            if ( pCollectionGrouping && !pRegistryGrouping ) {
               // Swap their roles
               found->visitNow = pRegistryGroup;
               SubordinateMultipleItems(*found, *pCollectionGroup);
            }
            else
               SubordinateMultipleItems(*found, *pRegistryGroup);
         }
         else {
            // Registered non-group item collides with a previously defined
            // group.
            // Resolve this by subordinating the non-group item below
            // that group.
            SubordinateSingleItem(*found, pItem);
         }
      }
      else {
         if (pRegistryGroup) {
            // Subordinate the previously merged single item below the
            // newly merged group.
            // In case the name occurred in two different static registries,
            // the final merge is the same, no matter which is treated first.
            auto demoted = found->visitNow;
            found->visitNow = pRegistryGroup;
            SubordinateSingleItem(*found, demoted);
         }
         else
            // Collision of non-group items is the worst case!
            // The later-registered item is lost.
            // Which one you lose might be unpredictable when both originate
            // from static registries.
            ReportItemItemCollision( itemOrdering.key, name );
      }
      return true;
   }
   else
      // A name is registered that is not known in the collection.
      return false;
}

References ActiveProjects::Find(), anonymous_namespace{Registry.cpp}::ItemOrdering::key, name, anonymous_namespace{Registry.cpp}::ReportGroupGroupCollision(), and anonymous_namespace{Registry.cpp}::ReportItemItemCollision().

Here is the call graph for this function:

SubordinateMultipleItems()

void anonymous_namespace{Registry.cpp}::CollectedItems::SubordinateMultipleItems	(	Item &	found,
		GroupItemBase &	items
	)

Definition at line 361 of file Registry.cpp.

{
   auto subGroup = MergeLater(found, items.name, items.GetOrdering());
   for (const auto &pItem : items)
      subGroup->push_back(std::make_unique<IndirectItemBase>(
         // shared pointer with vacuous deleter
         std::shared_ptr<BaseItem>(pItem.get(), [](void*){})));
}

SubordinateSingleItem()

void anonymous_namespace{Registry.cpp}::CollectedItems::SubordinateSingleItem	(	Item &	found,
		BaseItem *	pItem
	)

Definition at line 353 of file Registry.cpp.

{
   MergeLater(found, pItem->name, GroupItemBase::Weak)->push_back(
      std::make_unique<IndirectItemBase>(
         // shared pointer with vacuous deleter
         std::shared_ptr<BaseItem>(pItem, [](void*){})));
}

Member Data Documentation

computedItems

std::vector< BaseItemSharedPtr >& anonymous_namespace{Registry.cpp}::CollectedItems::computedItems

Definition at line 50 of file Registry.cpp.

Referenced by anonymous_namespace{Registry.cpp}::CollectItem(), and anonymous_namespace{Registry.cpp}::VisitItems().

items

std::vector< Item > anonymous_namespace{Registry.cpp}::CollectedItems::items

Definition at line 49 of file Registry.cpp.

Referenced by anonymous_namespace{Registry.cpp}::CollectItem().

---

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

• Registry.cpp