anonymous_namespace{Registry.cpp} Namespace Reference

Classes
struct	CollectedItems
struct	ItemOrdering
struct	PlaceHolder
	Used only internally. More...

Typedefs
using	Path = std::vector< Identifier >

Functions
const OrderingHint &	ChooseHint (BaseItem *delegate, const OrderingHint &hint)
void	CollectItem (CollectedItems &collection, BaseItem *Item, const OrderingHint &hint, void *pComputedItemContext)
void	CollectItems (CollectedItems &collection, const GroupItemBase &items, const OrderingHint &hint, void *pComputedItemContext)
void	BadPath (const TranslatableString &format, const wxString &key, const Identifier &name)
void	ReportGroupGroupCollision (const wxString &key, const Identifier &name)
void	ReportItemItemCollision (const wxString &key, const Identifier &name)
void	ReportConflictingPlacements (const wxString &key, const Identifier &name)
bool	MajorComp (const CollectedItems::NewItem &a, const CollectedItems::NewItem &b)
bool	MinorComp (const CollectedItems::NewItem &a, const CollectedItems::NewItem &b)
bool	Comp (const CollectedItems::NewItem &a, const CollectedItems::NewItem &b)
void	VisitItem (VisitorBase &visitor, CollectedItems &collection, Path &path, const BaseItem *pItem, const GroupItemBase *pToMerge, const OrderingHint &hint, bool &doFlush, void *pComputedItemContext)
void	VisitItems (VisitorBase &visitor, CollectedItems &collection, Path &path, const GroupItemBase &group, const GroupItemBase *pToMerge, const OrderingHint &hint, bool &doFlush, void *pComputedItemContext)

Variables
std::unordered_set< wxString >	sBadPaths

Typedef Documentation

Path

using anonymous_namespace{Registry.cpp}::Path = typedef std::vector< Identifier >

Definition at line 172 of file Registry.cpp.

Function Documentation

BadPath()

void anonymous_namespace{Registry.cpp}::BadPath	(	const TranslatableString &	format,
		const wxString &	key,
		const Identifier &	name
	)

Definition at line 175 of file Registry.cpp.

   {
     // Warn, but not more than once in a session for each bad path
     auto badPath = key + '/' + name.GET();
     if ( sBadPaths.insert( badPath ).second ) {
        auto msg = TranslatableString{ format }.Format( badPath );
        // debug message
        wxLogDebug( msg.Translation() );
#ifdef IS_ALPHA
        // user-visible message
        BasicUI::ShowMessageBox( msg );
#endif
     }
   }

References anonymous_namespace{ExportPCM.cpp}::format, key, name, sBadPaths, and BasicUI::ShowMessageBox().

Referenced by TempDirectory::IsTempDirectoryNameOK(), ReportConflictingPlacements(), ReportGroupGroupCollision(), and ReportItemItemCollision().

Here is the call graph for this function:

Here is the caller graph for this function:

ChooseHint()

const OrderingHint & anonymous_namespace{Registry.cpp}::ChooseHint	(	BaseItem *	delegate,
		const OrderingHint &	hint
	)

Definition at line 101 of file Registry.cpp.

{
   return !delegate || delegate->orderingHint.type == OrderingHint::Unspecified
      ? hint
      : delegate->orderingHint;
}

References Registry::OrderingHint::type.

Referenced by CollectItem(), and CollectItems().

Here is the caller graph for this function:

CollectItem()

void anonymous_namespace{Registry.cpp}::CollectItem	(	CollectedItems &	collection,
		BaseItem *	Item,
		const OrderingHint &	hint,
		void *	pComputedItemContext
	)

Definition at line 124 of file Registry.cpp.

{
   if (!pItem)
      return;
 
   using namespace Registry;
   if (const auto pIndirect =
       dynamic_cast<IndirectItemBase*>(pItem)) {
      auto delegate = pIndirect->ptr.get();
      if (delegate)
         // recursion
         CollectItem(collection, delegate,
            ChooseHint(delegate, pIndirect->orderingHint), pComputedItemContext);
   }
   else
   if (const auto pComputed =
       dynamic_cast<ComputedItemBase*>(pItem)) {
      auto result = pComputed->factory(pComputedItemContext);
      if (result) {
         // Guarantee long enough lifetime of the result
         collection.computedItems.push_back( result );
         // recursion
         CollectItem(collection, result.get(),
            ChooseHint(result.get(), pComputed->orderingHint),
            pComputedItemContext);
      }
   }
   else
   if (auto pGroup = dynamic_cast<GroupItemBase*>(pItem)) {
      if (pGroup->GetOrdering() == GroupItemBase::Anonymous)
         // anonymous grouping item is transparent to path calculations
         // collect group members now
         // recursion
         CollectItems(collection, *pGroup,
            ChooseHint(pGroup, hint), pComputedItemContext);
      else
         // all other group items
         // defer collection of members until collecting at next lower level
         collection.items.push_back( {pItem, nullptr, hint} );
   }
   else {
      wxASSERT( dynamic_cast<SingleItem*>(pItem) );
      // common to all single items
      collection.items.push_back( {pItem, nullptr, hint} );
   }
}

References ChooseHint(), CollectItem(), CollectItems(), anonymous_namespace{Registry.cpp}::CollectedItems::computedItems, and anonymous_namespace{Registry.cpp}::CollectedItems::items.

Referenced by CollectItem(), and CollectItems().

Here is the call graph for this function:

Here is the caller graph for this function:

CollectItems()

void anonymous_namespace{Registry.cpp}::CollectItems	(	CollectedItems &	collection,
		const GroupItemBase &	items,
		const OrderingHint &	hint,
		void *	pComputedItemContext
	)

Definition at line 117 of file Registry.cpp.

{
   for ( auto &item : items )
      CollectItem(collection, item.get(),
         ChooseHint(item.get(), hint), pComputedItemContext);
}

References ChooseHint(), and CollectItem().

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

Here is the call graph for this function:

Here is the caller graph for this function:

Comp()

bool anonymous_namespace{Registry.cpp}::Comp ( const CollectedItems::NewItem &  a, const CollectedItems::NewItem &  b  )

inline

Definition at line 491 of file Registry.cpp.

                                                                  {
   if ( MajorComp( a, b ) )
      return true;
   if ( MajorComp( b, a ) )
      return false;
   return MinorComp( a, b );
};

References MajorComp(), and MinorComp().

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

Here is the call graph for this function:

Here is the caller graph for this function:

MajorComp()

bool anonymous_namespace{Registry.cpp}::MajorComp ( const CollectedItems::NewItem &  a, const CollectedItems::NewItem &  b  )

inline

Definition at line 480 of file Registry.cpp.

                                                                   {
   // Descending sort!
   return a.first->name > b.first->name;
};

Referenced by Comp(), anonymous_namespace{Registry.cpp}::CollectedItems::MergeItemsAscendingNamesPass(), and anonymous_namespace{Registry.cpp}::CollectedItems::MergeItemsDescendingNamesPass().

Here is the caller graph for this function:

MinorComp()

bool anonymous_namespace{Registry.cpp}::MinorComp ( const CollectedItems::NewItem &  a, const CollectedItems::NewItem &  b  )

inline

Definition at line 485 of file Registry.cpp.

                                                                  {
   // Sort by hint type.
   // This sorts items with unspecified hints last.
   return a.second < b.second;
};

Referenced by Comp().

Here is the caller graph for this function:

ReportConflictingPlacements()

void anonymous_namespace{Registry.cpp}::ReportConflictingPlacements	(	const wxString &	key,
		const Identifier &	name
	)

Definition at line 205 of file Registry.cpp.

   {
      BadPath(
XO("Plug-in items at %s specify conflicting placements"),
         key, name);
   }

References BadPath(), key, name, and XO().

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

Here is the call graph for this function:

Here is the caller graph for this function:

ReportGroupGroupCollision()

void anonymous_namespace{Registry.cpp}::ReportGroupGroupCollision	(	const wxString &	key,
		const Identifier &	name
	)

Definition at line 191 of file Registry.cpp.

   {
      BadPath(
XO("Plug-in group at %s was merged with a previously defined group"),
         key, name);
   }

References BadPath(), key, name, and XO().

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

Here is the call graph for this function:

Here is the caller graph for this function:

ReportItemItemCollision()

void anonymous_namespace{Registry.cpp}::ReportItemItemCollision	(	const wxString &	key,
		const Identifier &	name
	)

Definition at line 198 of file Registry.cpp.

   {
      BadPath(
XO("Plug-in item at %s conflicts with a previously defined item and was discarded"),
         key, name);
   }

References BadPath(), key, name, and XO().

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

Here is the call graph for this function:

Here is the caller graph for this function:

VisitItem()

void anonymous_namespace{Registry.cpp}::VisitItem	(	VisitorBase &	visitor,
		CollectedItems &	collection,
		Path &	path,
		const BaseItem *	pItem,
		const GroupItemBase *	pToMerge,
		const OrderingHint &	hint,
		bool &	doFlush,
		void *	pComputedItemContext
	)

Definition at line 678 of file Registry.cpp.

{
   if (!pItem)
      return;
 
   if (const auto pSingle =
       dynamic_cast<const SingleItem*>(pItem)) {
      wxASSERT( !pToMerge );
      visitor.Visit( *pSingle, path );
   }
   else
   if (const auto pGroup =
       dynamic_cast<const GroupItemBase*>(pItem)) {
      visitor.BeginGroup(*pGroup, path);
      // recursion
      VisitItems(
         visitor, collection, path, *pGroup, pToMerge, hint, doFlush,
         pComputedItemContext);
      visitor.EndGroup(*pGroup, path);
   }
   else
      wxASSERT( false );
}

References VisitItems().

Referenced by Registry::detail::Visit(), and VisitItems().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitItems()

void anonymous_namespace{Registry.cpp}::VisitItems	(	VisitorBase &	visitor,
		CollectedItems &	collection,
		Path &	path,
		const GroupItemBase &	group,
		const GroupItemBase *	pToMerge,
		const OrderingHint &	hint,
		bool &	doFlush,
		void *	pComputedItemContext
	)

Definition at line 629 of file Registry.cpp.

{
   // Make a NEW collection for this subtree, sharing the memo cache
   CollectedItems newCollection{ {}, collection.computedItems };
 
   // Gather items at this level
   // (The ordering hint is irrelevant when not merging items in)
   CollectItems(newCollection, group, {},
      pComputedItemContext);
 
   path.push_back(group.name.GET());
 
   // Merge with the registry
   if ( pToMerge )
   {
      ItemOrdering itemOrdering{ path };
      newCollection.MergeItems(itemOrdering, *pToMerge, hint,
         pComputedItemContext);
 
      // Remember the NEW ordering, if there was any need to use the old.
      // This makes a side effect in preferences.
      if ( itemOrdering.gotOrdering ) {
         wxString newValue;
         for ( const auto &item : newCollection.items ) {
            const auto &name = item.visitNow->name;
            if ( !name.empty() )
               newValue += newValue.empty()
                  ? name.GET()
                  : ',' + name.GET();
         }
         if (newValue != itemOrdering.strValue) {
            gPrefs->Write( itemOrdering.key, newValue );
            doFlush = true;
         }
      }
   }
 
   // Now visit them
   for ( const auto &item : newCollection.items )
      VisitItem(visitor, collection, path,
         item.visitNow, item.mergeLater, item.hint,
         doFlush, pComputedItemContext);
 
   path.pop_back();
}

References CollectItems(), anonymous_namespace{Registry.cpp}::CollectedItems::computedItems, gPrefs, name, VisitItem(), and audacity::BasicSettings::Write().

Referenced by VisitItem().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

sBadPaths

std::unordered_set< wxString > anonymous_namespace{Registry.cpp}::sBadPaths

Definition at line 174 of file Registry.cpp.

Referenced by BadPath().