FormatNavigator has long stopped navigating anything - the generation of possible formatters matches is now done elsewhere

So, rename the class for what it truly is: a FormattersContainer
Also do a bunch of related text substitutions in the interest of overall naming clarity

llvm-svn: 197795

3 files changed, 137 insertions, 137 deletions

diff --git a/lldb/source/DataFormatters/DataVisualization.cpp b/lldb/source/DataFormatters/DataVisualization.cpp
index 48d3517750a..c2c2206f344 100644
--- a/lldb/source/DataFormatters/DataVisualization.cpp
+++ b/lldb/source/DataFormatters/DataVisualization.cpp
@@ -204,35 +204,35 @@ DataVisualization::Categories::GetCategoryAtIndex (size_t index)
 bool
 DataVisualization::NamedSummaryFormats::GetSummaryFormat (const ConstString &type, lldb::TypeSummaryImplSP &entry)
 {
-    return GetFormatManager().GetNamedSummaryNavigator().Get(type,entry);
+    return GetFormatManager().GetNamedSummaryContainer().Get(type,entry);
 }
 
 void
 DataVisualization::NamedSummaryFormats::Add (const ConstString &type, const lldb::TypeSummaryImplSP &entry)
 {
-    GetFormatManager().GetNamedSummaryNavigator().Add(FormatManager::GetValidTypeName(type),entry);
+    GetFormatManager().GetNamedSummaryContainer().Add(FormatManager::GetValidTypeName(type),entry);
 }
 
 bool
 DataVisualization::NamedSummaryFormats::Delete (const ConstString &type)
 {
-    return GetFormatManager().GetNamedSummaryNavigator().Delete(type);
+    return GetFormatManager().GetNamedSummaryContainer().Delete(type);
 }
 
 void
 DataVisualization::NamedSummaryFormats::Clear ()
 {
-    GetFormatManager().GetNamedSummaryNavigator().Clear();
+    GetFormatManager().GetNamedSummaryContainer().Clear();
 }
 
 void
 DataVisualization::NamedSummaryFormats::LoopThrough (TypeSummaryImpl::SummaryCallback callback, void* callback_baton)
 {
-    GetFormatManager().GetNamedSummaryNavigator().LoopThrough(callback, callback_baton);
+    GetFormatManager().GetNamedSummaryContainer().LoopThrough(callback, callback_baton);
 }
 
 uint32_t
 DataVisualization::NamedSummaryFormats::GetCount ()
 {
-    return GetFormatManager().GetNamedSummaryNavigator().GetCount();
+    return GetFormatManager().GetNamedSummaryContainer().GetCount();
 }
diff --git a/lldb/source/DataFormatters/FormatManager.cpp b/lldb/source/DataFormatters/FormatManager.cpp
index bec2edf5d5c..ca4603c94bb 100644
--- a/lldb/source/DataFormatters/FormatManager.cpp
+++ b/lldb/source/DataFormatters/FormatManager.cpp
@@ -744,9 +744,9 @@ AddFormat (TypeCategoryImpl::SharedPointer category_sp,
     lldb::TypeFormatImplSP format_sp(new TypeFormatImpl(format, flags));
     
     if (regex)
-        category_sp->GetRegexValueNavigator()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),format_sp);
+        category_sp->GetRegexTypeFormatsContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),format_sp);
     else
-        category_sp->GetValueNavigator()->Add(type_name, format_sp);
+        category_sp->GetTypeFormatsContainer()->Add(type_name, format_sp);
 }
 
 
@@ -761,9 +761,9 @@ AddStringSummary(TypeCategoryImpl::SharedPointer category_sp,
                                                                string));
     
     if (regex)
-        category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
+        category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
     else
-        category_sp->GetSummaryNavigator()->Add(type_name, summary_sp);
+        category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp);
 }
 
 #ifndef LLDB_DISABLE_PYTHON
@@ -782,9 +782,9 @@ AddScriptSummary(TypeCategoryImpl::SharedPointer category_sp,
                                                                funct_name,
                                                                code.c_str()));
     if (regex)
-        category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
+        category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
     else
-        category_sp->GetSummaryNavigator()->Add(type_name, summary_sp);
+        category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp);
 }
 #endif
 
@@ -799,9 +799,9 @@ AddCXXSummary (TypeCategoryImpl::SharedPointer category_sp,
 {
     lldb::TypeSummaryImplSP summary_sp(new CXXFunctionSummaryFormat(flags,funct,description));
     if (regex)
-        category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
+        category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
     else
-        category_sp->GetSummaryNavigator()->Add(type_name, summary_sp);
+        category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp);
 }
 #endif
 
@@ -815,9 +815,9 @@ static void AddCXXSynthetic  (TypeCategoryImpl::SharedPointer category_sp,
 {
     lldb::SyntheticChildrenSP synth_sp(new CXXSyntheticChildren(flags,description,generator));
     if (regex)
-        category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())), synth_sp);
+        category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())), synth_sp);
     else
-        category_sp->GetSyntheticNavigator()->Add(type_name,synth_sp);
+        category_sp->GetTypeSyntheticsContainer()->Add(type_name,synth_sp);
 }
 #endif
 
@@ -838,26 +838,26 @@ FormatManager::LoadLibStdcppFormatters()
     
     TypeCategoryImpl::SharedPointer gnu_category_sp = GetCategory(m_gnu_cpp_category_name);
     
-    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::string"),
+    gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::string"),
                                                 std_string_summary_sp);
-    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<char>"),
+    gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char>"),
                                                 std_string_summary_sp);
-    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<char,std::char_traits<char>,std::allocator<char> >"),
+    gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char,std::char_traits<char>,std::allocator<char> >"),
                                                 std_string_summary_sp);
-    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
+    gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
                                                 std_string_summary_sp);
     
     // making sure we force-pick the summary for printing wstring (_M_p is a wchar_t*)
     lldb::TypeSummaryImplSP std_wstring_summary_sp(new StringSummaryFormat(stl_summary_flags,
                                                                            "${var._M_dataplus._M_p%S}"));
     
-    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::wstring"),
+    gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::wstring"),
                                                 std_wstring_summary_sp);
-    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<wchar_t>"),
+    gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t>"),
                                                 std_wstring_summary_sp);
-    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >"),
+    gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >"),
                                                 std_wstring_summary_sp);
-    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
+    gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
                                                 std_wstring_summary_sp);
     
     
@@ -866,24 +866,24 @@ FormatManager::LoadLibStdcppFormatters()
     SyntheticChildren::Flags stl_synth_flags;
     stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false);
     
-    gnu_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")),
+    gnu_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")),
                                                        SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
                                                                                                  "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider")));
-    gnu_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")),
+    gnu_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")),
                                                        SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
                                                                                                  "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider")));
-    gnu_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::list<.+>(( )?&)?$")),
+    gnu_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::list<.+>(( )?&)?$")),
                                                        SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
                                                                                                  "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
     
     stl_summary_flags.SetDontShowChildren(false);stl_summary_flags.SetSkipPointers(true);
-    gnu_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")),
+    gnu_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")),
                                                      TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
                                                                                                "size=${svar%#}")));
-    gnu_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")),
+    gnu_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")),
                                                      TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
                                                                                                "size=${svar%#}")));
-    gnu_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::list<.+>(( )?&)?$")),
+    gnu_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::list<.+>(( )?&)?$")),
                                                      TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
                                                                                                "size=${svar%#}")));
 
@@ -891,10 +891,10 @@ FormatManager::LoadLibStdcppFormatters()
     
     AddCXXSynthetic(gnu_category_sp, lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator, "std::map iterator synthetic children", ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true);
     
-    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::vector<std::allocator<bool> >"),
+    gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::vector<std::allocator<bool> >"),
                                                    TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
     
-    gnu_category_sp->GetSyntheticNavigator()->Add(ConstString("std::vector<std::allocator<bool> >"),
+    gnu_category_sp->GetTypeSyntheticsContainer()->Add(ConstString("std::vector<std::allocator<bool> >"),
                                                      SyntheticChildrenSP(new CXXSyntheticChildren(stl_synth_flags,"libc++ std::vector<bool> synthetic children",lldb_private::formatters::LibstdcppVectorBoolSyntheticFrontEndCreator)));
 
 #endif
@@ -921,14 +921,14 @@ FormatManager::LoadLibcxxFormatters()
 
     TypeCategoryImpl::SharedPointer libcxx_category_sp = GetCategory(m_libcxx_category_name);
     
-    libcxx_category_sp->GetSummaryNavigator()->Add(ConstString("std::__1::string"),
+    libcxx_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::string"),
                                                    std_string_summary_sp);
-    libcxx_category_sp->GetSummaryNavigator()->Add(ConstString("std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >"),
+    libcxx_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >"),
                                                    std_string_summary_sp);
 
-    libcxx_category_sp->GetSummaryNavigator()->Add(ConstString("std::__1::wstring"),
+    libcxx_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::wstring"),
                                                    std_wstring_summary_sp);
-    libcxx_category_sp->GetSummaryNavigator()->Add(ConstString("std::__1::basic_string<wchar_t, std::__1::char_traits<wchar_t>, std::__1::allocator<wchar_t> >"),
+    libcxx_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::basic_string<wchar_t, std::__1::char_traits<wchar_t>, std::__1::allocator<wchar_t> >"),
                                                    std_wstring_summary_sp);
     
     SyntheticChildren::Flags stl_synth_flags;
@@ -943,7 +943,7 @@ FormatManager::LoadLibcxxFormatters()
     AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multimap synthetic children", ConstString("^std::__1::multimap<.+> >(( )?&)?$"), stl_synth_flags, true);
     AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator, "libc++ std::unordered containers synthetic children", ConstString("^(std::__1::)unordered_(multi)?(map|set)<.+> >$"), stl_synth_flags, true);
     
-    libcxx_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^(std::__1::)deque<.+>(( )?&)?$")),
+    libcxx_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^(std::__1::)deque<.+>(( )?&)?$")),
                                                           SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
                                                                                                     "lldb.formatters.cpp.libcxx.stddeque_SynthProvider")));
     
@@ -1002,9 +1002,9 @@ FormatManager::LoadSystemFormatters()
     
     TypeCategoryImpl::SharedPointer sys_category_sp = GetCategory(m_system_category_name);
     
-    sys_category_sp->GetSummaryNavigator()->Add(ConstString("char *"), string_format);
-    sys_category_sp->GetSummaryNavigator()->Add(ConstString("unsigned char *"), string_format);
-    sys_category_sp->GetRegexSummaryNavigator()->Add(any_size_char_arr, string_array_format);
+    sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("char *"), string_format);
+    sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("unsigned char *"), string_format);
+    sys_category_sp->GetRegexTypeSummariesContainer()->Add(any_size_char_arr, string_array_format);
 
     lldb::TypeSummaryImplSP ostype_summary(new StringSummaryFormat(TypeSummaryImpl::Flags().SetCascades(false)
                                                                    .SetSkipPointers(true)
@@ -1015,10 +1015,10 @@ FormatManager::LoadSystemFormatters()
                                                                    .SetHideItemNames(false),
                                                                    "${var%O}"));
     
-    sys_category_sp->GetSummaryNavigator()->Add(ConstString("OSType"), ostype_summary);
+    sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("OSType"), ostype_summary);
     
 #ifndef LLDB_DISABLE_PYTHON
-    // FIXME because of a bug in the FormatNavigator we need to add a summary for both X* and const X* (<rdar://problem/12717717>)
+    // FIXME because of a bug in the FormattersContainer we need to add a summary for both X* and const X* (<rdar://problem/12717717>)
     AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "char16_t * summary provider", ConstString("char16_t *"), string_flags);
     
     AddCXXSummary(sys_category_sp, lldb_private::formatters::Char32StringSummaryProvider, "char32_t * summary provider", ConstString("char32_t *"), string_flags);
@@ -1065,11 +1065,11 @@ FormatManager::LoadObjCFormatters()
     TypeCategoryImpl::SharedPointer objc_category_sp = GetCategory(m_objc_category_name);
     
     lldb::TypeSummaryImplSP ObjC_BOOL_summary(new CXXFunctionSummaryFormat(objc_flags, lldb_private::formatters::ObjCBOOLSummaryProvider,""));
-    objc_category_sp->GetSummaryNavigator()->Add(ConstString("BOOL"),
+    objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL"),
                                                  ObjC_BOOL_summary);
-    objc_category_sp->GetSummaryNavigator()->Add(ConstString("BOOL &"),
+    objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL &"),
                                                  ObjC_BOOL_summary);
-    objc_category_sp->GetSummaryNavigator()->Add(ConstString("BOOL *"),
+    objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL *"),
                                                  ObjC_BOOL_summary);
 
 #ifndef LLDB_DISABLE_PYTHON
diff --git a/lldb/source/DataFormatters/TypeCategory.cpp b/lldb/source/DataFormatters/TypeCategory.cpp
index a02560e7878..5c164a7b6f7 100644
--- a/lldb/source/DataFormatters/TypeCategory.cpp
+++ b/lldb/source/DataFormatters/TypeCategory.cpp
@@ -21,15 +21,15 @@ using namespace lldb_private;
 
 TypeCategoryImpl::TypeCategoryImpl(IFormatChangeListener* clist,
                                    ConstString name) :
-m_value_nav(new ValueNavigator("format",clist)),
-m_regex_value_nav(new RegexValueNavigator("regex-format",clist)),
-m_summary_nav(new SummaryNavigator("summary",clist)),
-m_regex_summary_nav(new RegexSummaryNavigator("regex-summary",clist)),
-m_filter_nav(new FilterNavigator("filter",clist)),
-m_regex_filter_nav(new RegexFilterNavigator("regex-filter",clist)),
+m_format_cont(new FormatContainer("format",clist)),
+m_regex_format_cont(new RegexFormatContainer("regex-format",clist)),
+m_summary_cont(new SummaryContainer("summary",clist)),
+m_regex_summary_cont(new RegexSummaryContainer("regex-summary",clist)),
+m_filter_cont(new FilterContainer("filter",clist)),
+m_regex_filter_cont(new RegexFilterContainer("regex-filter",clist)),
 #ifndef LLDB_DISABLE_PYTHON
-m_synth_nav(new SynthNavigator("synth",clist)),
-m_regex_synth_nav(new RegexSynthNavigator("regex-synth",clist)),
+m_synth_cont(new SynthContainer("synth",clist)),
+m_regex_synth_cont(new RegexSynthContainer("regex-synth",clist)),
 #endif
 m_enabled(false),
 m_change_listener(clist),
@@ -45,9 +45,9 @@ TypeCategoryImpl::Get (ValueObject& valobj,
 {
     if (!IsEnabled())
         return false;
-    if (GetValueNavigator()->Get(candidates, entry, reason))
+    if (GetTypeFormatsContainer()->Get(candidates, entry, reason))
         return true;
-    bool regex = GetRegexValueNavigator()->Get(candidates, entry, reason);
+    bool regex = GetRegexTypeFormatsContainer()->Get(candidates, entry, reason);
     if (regex && reason)
         *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionSummary;
     return regex;
@@ -61,9 +61,9 @@ TypeCategoryImpl::Get (ValueObject& valobj,
 {
     if (!IsEnabled())
         return false;
-    if (GetSummaryNavigator()->Get(candidates, entry, reason))
+    if (GetTypeSummariesContainer()->Get(candidates, entry, reason))
         return true;
-    bool regex = GetRegexSummaryNavigator()->Get(candidates, entry, reason);
+    bool regex = GetRegexTypeSummariesContainer()->Get(candidates, entry, reason);
     if (regex && reason)
         *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionSummary;
     return regex;
@@ -82,16 +82,16 @@ TypeCategoryImpl::Get (ValueObject& valobj,
     bool regex_filter = false;
     // first find both Filter and Synth, and then check which is most recent
     
-    if (!GetFilterNavigator()->Get(candidates, filter_sp, &reason_filter))
-        regex_filter = GetRegexFilterNavigator()->Get (candidates, filter_sp, &reason_filter);
+    if (!GetTypeFiltersContainer()->Get(candidates, filter_sp, &reason_filter))
+        regex_filter = GetRegexTypeFiltersContainer()->Get (candidates, filter_sp, &reason_filter);
     
 #ifndef LLDB_DISABLE_PYTHON
     bool regex_synth = false;
     uint32_t reason_synth = 0;
     bool pick_synth = false;
     ScriptedSyntheticChildren::SharedPointer synth;
-    if (!GetSyntheticNavigator()->Get(candidates, synth, &reason_synth))
-        regex_synth = GetRegexSyntheticNavigator()->Get (candidates, synth, &reason_synth);
+    if (!GetTypeSyntheticsContainer()->Get(candidates, synth, &reason_synth))
+        regex_synth = GetRegexTypeSyntheticsContainer()->Get (candidates, synth, &reason_synth);
     if (!filter_sp.get() && !synth.get())
         return false;
     else if (!filter_sp.get() && synth.get())
@@ -137,25 +137,25 @@ void
 TypeCategoryImpl::Clear (FormatCategoryItems items)
 {
     if ( (items & eFormatCategoryItemValue)  == eFormatCategoryItemValue )
-        m_value_nav->Clear();
+        m_format_cont->Clear();
     if ( (items & eFormatCategoryItemRegexValue) == eFormatCategoryItemRegexValue )
-        m_regex_value_nav->Clear();
+        m_regex_format_cont->Clear();
 
     if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
-        m_summary_nav->Clear();
+        m_summary_cont->Clear();
     if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
-        m_regex_summary_nav->Clear();
+        m_regex_summary_cont->Clear();
 
     if ( (items & eFormatCategoryItemFilter)  == eFormatCategoryItemFilter )
-        m_filter_nav->Clear();
+        m_filter_cont->Clear();
     if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
-        m_regex_filter_nav->Clear();
+        m_regex_filter_cont->Clear();
 
 #ifndef LLDB_DISABLE_PYTHON
     if ( (items & eFormatCategoryItemSynth)  == eFormatCategoryItemSynth )
-        m_synth_nav->Clear();
+        m_synth_cont->Clear();
     if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
-        m_regex_synth_nav->Clear();
+        m_regex_synth_cont->Clear();
 #endif
 }
 
@@ -166,25 +166,25 @@ TypeCategoryImpl::Delete (ConstString name,
     bool success = false;
     
     if ( (items & eFormatCategoryItemValue)  == eFormatCategoryItemValue )
-        success = m_value_nav->Delete(name) || success;
+        success = m_format_cont->Delete(name) || success;
     if ( (items & eFormatCategoryItemRegexValue) == eFormatCategoryItemRegexValue )
-        success = m_regex_value_nav->Delete(name) || success;
+        success = m_regex_format_cont->Delete(name) || success;
 
     if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
-        success = m_summary_nav->Delete(name) || success;
+        success = m_summary_cont->Delete(name) || success;
     if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
-        success = m_regex_summary_nav->Delete(name) || success;
+        success = m_regex_summary_cont->Delete(name) || success;
 
     if ( (items & eFormatCategoryItemFilter)  == eFormatCategoryItemFilter )
-        success = m_filter_nav->Delete(name) || success;
+        success = m_filter_cont->Delete(name) || success;
     if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
-        success = m_regex_filter_nav->Delete(name) || success;
+        success = m_regex_filter_cont->Delete(name) || success;
 
 #ifndef LLDB_DISABLE_PYTHON
     if ( (items & eFormatCategoryItemSynth)  == eFormatCategoryItemSynth )
-        success = m_synth_nav->Delete(name) || success;
+        success = m_synth_cont->Delete(name) || success;
     if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
-        success = m_regex_synth_nav->Delete(name) || success;
+        success = m_regex_synth_cont->Delete(name) || success;
 #endif
     return success;
 }
@@ -195,25 +195,25 @@ TypeCategoryImpl::GetCount (FormatCategoryItems items)
     uint32_t count = 0;
 
     if ( (items & eFormatCategoryItemValue) == eFormatCategoryItemValue )
-        count += m_value_nav->GetCount();
+        count += m_format_cont->GetCount();
     if ( (items & eFormatCategoryItemRegexValue) == eFormatCategoryItemRegexValue )
-        count += m_regex_value_nav->GetCount();
+        count += m_regex_format_cont->GetCount();
     
     if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
-        count += m_summary_nav->GetCount();
+        count += m_summary_cont->GetCount();
     if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
-        count += m_regex_summary_nav->GetCount();
+        count += m_regex_summary_cont->GetCount();
 
     if ( (items & eFormatCategoryItemFilter)  == eFormatCategoryItemFilter )
-        count += m_filter_nav->GetCount();
+        count += m_filter_cont->GetCount();
     if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
-        count += m_regex_filter_nav->GetCount();
+        count += m_regex_filter_cont->GetCount();
 
 #ifndef LLDB_DISABLE_PYTHON
     if ( (items & eFormatCategoryItemSynth)  == eFormatCategoryItemSynth )
-        count += m_synth_nav->GetCount();
+        count += m_synth_cont->GetCount();
     if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
-        count += m_regex_synth_nav->GetCount();
+        count += m_regex_synth_cont->GetCount();
 #endif
     return count;
 }
@@ -237,7 +237,7 @@ TypeCategoryImpl::AnyMatches(ConstString type_name,
     
     if ( (items & eFormatCategoryItemValue) == eFormatCategoryItemValue )
     {
-        if (m_value_nav->Get(type_name, format_sp))
+        if (m_format_cont->Get(type_name, format_sp))
         {
             if (matching_category)
                 *matching_category = m_name.GetCString();
@@ -248,7 +248,7 @@ TypeCategoryImpl::AnyMatches(ConstString type_name,
     }
     if ( (items & eFormatCategoryItemRegexValue) == eFormatCategoryItemRegexValue )
     {
-        if (m_regex_value_nav->Get(type_name, format_sp))
+        if (m_regex_format_cont->Get(type_name, format_sp))
         {
             if (matching_category)
                 *matching_category = m_name.GetCString();
@@ -260,7 +260,7 @@ TypeCategoryImpl::AnyMatches(ConstString type_name,
     
     if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
     {
-        if (m_summary_nav->Get(type_name, summary_sp))
+        if (m_summary_cont->Get(type_name, summary_sp))
         {
             if (matching_category)
                 *matching_category = m_name.GetCString();
@@ -271,7 +271,7 @@ TypeCategoryImpl::AnyMatches(ConstString type_name,
     }
     if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
     {
-        if (m_regex_summary_nav->Get(type_name, summary_sp))
+        if (m_regex_summary_cont->Get(type_name, summary_sp))
         {
             if (matching_category)
                 *matching_category = m_name.GetCString();
@@ -283,7 +283,7 @@ TypeCategoryImpl::AnyMatches(ConstString type_name,
     
     if ( (items & eFormatCategoryItemFilter)  == eFormatCategoryItemFilter )
     {
-        if (m_filter_nav->Get(type_name, filter_sp))
+        if (m_filter_cont->Get(type_name, filter_sp))
         {
             if (matching_category)
                 *matching_category = m_name.GetCString();
@@ -294,7 +294,7 @@ TypeCategoryImpl::AnyMatches(ConstString type_name,
     }
     if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
     {
-        if (m_regex_filter_nav->Get(type_name, filter_sp))
+        if (m_regex_filter_cont->Get(type_name, filter_sp))
         {
             if (matching_category)
                 *matching_category = m_name.GetCString();
@@ -307,7 +307,7 @@ TypeCategoryImpl::AnyMatches(ConstString type_name,
 #ifndef LLDB_DISABLE_PYTHON
     if ( (items & eFormatCategoryItemSynth)  == eFormatCategoryItemSynth )
     {
-        if (m_synth_nav->Get(type_name, synth_sp))
+        if (m_synth_cont->Get(type_name, synth_sp))
         {
             if (matching_category)
                 *matching_category = m_name.GetCString();
@@ -318,7 +318,7 @@ TypeCategoryImpl::AnyMatches(ConstString type_name,
     }
     if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
     {
-        if (m_regex_synth_nav->Get(type_name, synth_sp))
+        if (m_regex_synth_cont->Get(type_name, synth_sp))
         {
             if (matching_category)
                 *matching_category = m_name.GetCString();
@@ -331,66 +331,66 @@ TypeCategoryImpl::AnyMatches(ConstString type_name,
     return false;
 }
 
-TypeCategoryImpl::ValueNavigator::MapValueType
+TypeCategoryImpl::FormatContainer::MapValueType
 TypeCategoryImpl::GetFormatForType (lldb::TypeNameSpecifierImplSP type_sp)
 {
-    ValueNavigator::MapValueType retval;
+    FormatContainer::MapValueType retval;
     
     if (type_sp)
     {
         if (type_sp->IsRegex())
-            m_regex_value_nav->GetExact(ConstString(type_sp->GetName()),retval);
+            m_regex_format_cont->GetExact(ConstString(type_sp->GetName()),retval);
         else
-            m_value_nav->GetExact(ConstString(type_sp->GetName()),retval);
+            m_format_cont->GetExact(ConstString(type_sp->GetName()),retval);
     }
     
     return retval;
 }
 
-TypeCategoryImpl::SummaryNavigator::MapValueType
+TypeCategoryImpl::SummaryContainer::MapValueType
 TypeCategoryImpl::GetSummaryForType (lldb::TypeNameSpecifierImplSP type_sp)
 {
-    SummaryNavigator::MapValueType retval;
+    SummaryContainer::MapValueType retval;
     
     if (type_sp)
     {
         if (type_sp->IsRegex())
-            m_regex_summary_nav->GetExact(ConstString(type_sp->GetName()),retval);
+            m_regex_summary_cont->GetExact(ConstString(type_sp->GetName()),retval);
         else
-            m_summary_nav->GetExact(ConstString(type_sp->GetName()),retval);
+            m_summary_cont->GetExact(ConstString(type_sp->GetName()),retval);
     }
     
     return retval;
 }
 
-TypeCategoryImpl::FilterNavigator::MapValueType
+TypeCategoryImpl::FilterContainer::MapValueType
 TypeCategoryImpl::GetFilterForType (lldb::TypeNameSpecifierImplSP type_sp)
 {
-    FilterNavigator::MapValueType retval;
+    FilterContainer::MapValueType retval;
     
     if (type_sp)
     {
         if (type_sp->IsRegex())
-            m_regex_filter_nav->GetExact(ConstString(type_sp->GetName()),retval);
+            m_regex_filter_cont->GetExact(ConstString(type_sp->GetName()),retval);
         else
-            m_filter_nav->GetExact(ConstString(type_sp->GetName()),retval);
+            m_filter_cont->GetExact(ConstString(type_sp->GetName()),retval);
     }
     
     return retval;
 }
 
 #ifndef LLDB_DISABLE_PYTHON
-TypeCategoryImpl::SynthNavigator::MapValueType
+TypeCategoryImpl::SynthContainer::MapValueType
 TypeCategoryImpl::GetSyntheticForType (lldb::TypeNameSpecifierImplSP type_sp)
 {
-    SynthNavigator::MapValueType retval;
+    SynthContainer::MapValueType retval;
     
     if (type_sp)
     {
         if (type_sp->IsRegex())
-            m_regex_synth_nav->GetExact(ConstString(type_sp->GetName()),retval);
+            m_regex_synth_cont->GetExact(ConstString(type_sp->GetName()),retval);
         else
-            m_synth_nav->GetExact(ConstString(type_sp->GetName()),retval);
+            m_synth_cont->GetExact(ConstString(type_sp->GetName()),retval);
     }
     
     return retval;
@@ -400,74 +400,74 @@ TypeCategoryImpl::GetSyntheticForType (lldb::TypeNameSpecifierImplSP type_sp)
 lldb::TypeNameSpecifierImplSP
 TypeCategoryImpl::GetTypeNameSpecifierForSummaryAtIndex (size_t index)
 {
-    if (index < m_summary_nav->GetCount())
-        return m_summary_nav->GetTypeNameSpecifierAtIndex(index);
+    if (index < m_summary_cont->GetCount())
+        return m_summary_cont->GetTypeNameSpecifierAtIndex(index);
     else
-        return m_regex_summary_nav->GetTypeNameSpecifierAtIndex(index-m_summary_nav->GetCount());
+        return m_regex_summary_cont->GetTypeNameSpecifierAtIndex(index-m_summary_cont->GetCount());
 }
 
-TypeCategoryImpl::ValueNavigator::MapValueType
+TypeCategoryImpl::FormatContainer::MapValueType
 TypeCategoryImpl::GetFormatAtIndex (size_t index)
 {
-    if (index < m_value_nav->GetCount())
-        return m_value_nav->GetAtIndex(index);
+    if (index < m_format_cont->GetCount())
+        return m_format_cont->GetAtIndex(index);
     else
-        return m_regex_value_nav->GetAtIndex(index-m_value_nav->GetCount());
+        return m_regex_format_cont->GetAtIndex(index-m_format_cont->GetCount());
 }
 
-TypeCategoryImpl::SummaryNavigator::MapValueType
+TypeCategoryImpl::SummaryContainer::MapValueType
 TypeCategoryImpl::GetSummaryAtIndex (size_t index)
 {
-    if (index < m_summary_nav->GetCount())
-        return m_summary_nav->GetAtIndex(index);
+    if (index < m_summary_cont->GetCount())
+        return m_summary_cont->GetAtIndex(index);
     else
-        return m_regex_summary_nav->GetAtIndex(index-m_summary_nav->GetCount());
+        return m_regex_summary_cont->GetAtIndex(index-m_summary_cont->GetCount());
 }
 
-TypeCategoryImpl::FilterNavigator::MapValueType
+TypeCategoryImpl::FilterContainer::MapValueType
 TypeCategoryImpl::GetFilterAtIndex (size_t index)
 {
-    if (index < m_filter_nav->GetCount())
-        return m_filter_nav->GetAtIndex(index);
+    if (index < m_filter_cont->GetCount())
+        return m_filter_cont->GetAtIndex(index);
     else
-        return m_regex_filter_nav->GetAtIndex(index-m_filter_nav->GetCount());
+        return m_regex_filter_cont->GetAtIndex(index-m_filter_cont->GetCount());
 }
 
 lldb::TypeNameSpecifierImplSP
 TypeCategoryImpl::GetTypeNameSpecifierForFormatAtIndex (size_t index)
 {
-    if (index < m_value_nav->GetCount())
-        return m_value_nav->GetTypeNameSpecifierAtIndex(index);
+    if (index < m_format_cont->GetCount())
+        return m_format_cont->GetTypeNameSpecifierAtIndex(index);
     else
-        return m_regex_value_nav->GetTypeNameSpecifierAtIndex(index-m_value_nav->GetCount());
+        return m_regex_format_cont->GetTypeNameSpecifierAtIndex(index-m_format_cont->GetCount());
 }
 
 lldb::TypeNameSpecifierImplSP
 TypeCategoryImpl::GetTypeNameSpecifierForFilterAtIndex (size_t index)
 {
-    if (index < m_filter_nav->GetCount())
-        return m_filter_nav->GetTypeNameSpecifierAtIndex(index);
+    if (index < m_filter_cont->GetCount())
+        return m_filter_cont->GetTypeNameSpecifierAtIndex(index);
     else
-        return m_regex_filter_nav->GetTypeNameSpecifierAtIndex(index-m_filter_nav->GetCount());
+        return m_regex_filter_cont->GetTypeNameSpecifierAtIndex(index-m_filter_cont->GetCount());
 }
 
 #ifndef LLDB_DISABLE_PYTHON
-TypeCategoryImpl::SynthNavigator::MapValueType
+TypeCategoryImpl::SynthContainer::MapValueType
 TypeCategoryImpl::GetSyntheticAtIndex (size_t index)
 {
-    if (index < m_synth_nav->GetCount())
-        return m_synth_nav->GetAtIndex(index);
+    if (index < m_synth_cont->GetCount())
+        return m_synth_cont->GetAtIndex(index);
     else
-        return m_regex_synth_nav->GetAtIndex(index-m_synth_nav->GetCount());
+        return m_regex_synth_cont->GetAtIndex(index-m_synth_cont->GetCount());
 }
 
 lldb::TypeNameSpecifierImplSP
 TypeCategoryImpl::GetTypeNameSpecifierForSyntheticAtIndex (size_t index)
 {
-    if (index < m_synth_nav->GetCount())
-        return m_synth_nav->GetTypeNameSpecifierAtIndex(index);
+    if (index < m_synth_cont->GetCount())
+        return m_synth_cont->GetTypeNameSpecifierAtIndex(index);
     else
-        return m_regex_synth_nav->GetTypeNameSpecifierAtIndex(index - m_synth_nav->GetCount());
+        return m_regex_synth_cont->GetTypeNameSpecifierAtIndex(index - m_synth_cont->GetCount());
 }
 #endif