Cleanup the type X list commands to use the new ForEach goodness

llvm-svn: 253423

11 files changed, 225 insertions, 902 deletions

diff --git a/lldb/include/lldb/DataFormatters/DataVisualization.h b/lldb/include/lldb/DataFormatters/DataVisualization.h
index 0b956b693be..856156670c9 100644
--- a/lldb/include/lldb/DataFormatters/DataVisualization.h
+++ b/lldb/include/lldb/DataFormatters/DataVisualization.h
@@ -101,7 +101,7 @@ public:
         Clear ();
         
         static void
-        LoopThrough (TypeSummaryImpl::SummaryCallback callback, void* callback_baton);
+        ForEach (std::function<bool(ConstString, const lldb::TypeSummaryImplSP&)> callback);
         
         static uint32_t
         GetCount ();
@@ -158,9 +158,6 @@ public:
         DisableStar ();
         
         static void
-        LoopThrough (FormatManager::CategoryCallback callback, void* callback_baton);
-        
-        static void
         ForEach (TypeCategoryMap::ForEachCallback callback);
         
         static uint32_t
diff --git a/lldb/include/lldb/DataFormatters/FormatManager.h b/lldb/include/lldb/DataFormatters/FormatManager.h
index ef58520010b..79a384e1782 100644
--- a/lldb/include/lldb/DataFormatters/FormatManager.h
+++ b/lldb/include/lldb/DataFormatters/FormatManager.h
@@ -140,9 +140,6 @@ public:
     }
     
     void
-    LoopThroughCategories (CategoryCallback callback, void* param);
-
-    void
     ForEachCategory (TypeCategoryMap::ForEachCallback callback);
     
     lldb::TypeCategoryImplSP
diff --git a/lldb/include/lldb/DataFormatters/FormattersContainer.h b/lldb/include/lldb/DataFormatters/FormattersContainer.h
index f3675128702..93a63bcd92b 100644
--- a/lldb/include/lldb/DataFormatters/FormattersContainer.h
+++ b/lldb/include/lldb/DataFormatters/FormattersContainer.h
@@ -141,22 +141,6 @@ public:
     }
     
     void
-    LoopThrough (CallbackType callback, void* param)
-    {
-        if (callback)
-        {
-            Mutex::Locker locker(m_map_mutex);
-            MapIterator pos, end = m_map.end();
-            for (pos = m_map.begin(); pos != end; pos++)
-            {
-                KeyType type = pos->first;
-                if (!callback(param, type, pos->second))
-                    break;
-            }
-        }
-    }
-    
-    void
     ForEach (ForEachCallback callback)
     {
         if (callback)
@@ -316,12 +300,6 @@ public:
     }
     
     void
-    LoopThrough (CallbackType callback, void* param)
-    {
-        m_format_map.LoopThrough(callback,param);
-    }
-    
-    void
     ForEach (ForEachCallback callback)
     {
         m_format_map.ForEach(callback);
diff --git a/lldb/include/lldb/DataFormatters/TypeCategory.h b/lldb/include/lldb/DataFormatters/TypeCategory.h
index 3089c4df915..23a48b72fba 100644
--- a/lldb/include/lldb/DataFormatters/TypeCategory.h
+++ b/lldb/include/lldb/DataFormatters/TypeCategory.h
@@ -67,14 +67,6 @@ namespace lldb_private {
             return m_regex_sp;
         }
         
-        void
-        LoopThrough (typename ExactMatchContainer::CallbackType exact_callback,
-                     typename RegexMatchContainer::CallbackType regex_callback)
-        {
-            GetExactMatch()->LoopThrough(exact_callback);
-            GetRegexMatch()->LoopThrough(regex_callback);
-        }
-        
         uint32_t
         GetCount ()
         {
@@ -95,7 +87,7 @@ namespace lldb_private {
         typedef FormatterContainerPair<TypeValidatorImpl> ValidatorContainer;
         
 #ifndef LLDB_DISABLE_PYTHON
-        typedef FormatterContainerPair<ScriptedSyntheticChildren> SynthContainer;
+        typedef FormatterContainerPair<SyntheticChildren> SynthContainer;
 #endif // LLDB_DISABLE_PYTHON
 
     public:
@@ -118,74 +110,84 @@ namespace lldb_private {
         typedef ValidatorContainer::ExactMatchContainerSP ValidatorContainerSP;
         typedef ValidatorContainer::RegexMatchContainerSP RegexValidatorContainerSP;
         
-        class ForEach
+        template <typename T>
+        class ForEachCallbacks
         {
         public:
-            ForEach () = default;
-            ~ForEach () = default;
+            ForEachCallbacks () = default;
+            ~ForEachCallbacks () = default;
             
-            ForEach&
-            SetFormatExactCallback (FormatContainer::ExactMatchForEachCallback callback)
+            template<typename U = TypeFormatImpl>
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            Set (FormatContainer::ExactMatchForEachCallback callback)
             {
                 m_format_exact = callback;
                 return *this;
             }
-            ForEach&
-            SetFormatRegexCallback (FormatContainer::RegexMatchForEachCallback callback)
+            template<typename U = TypeFormatImpl>
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            Set (FormatContainer::RegexMatchForEachCallback callback)
             {
                 m_format_regex = callback;
                 return *this;
             }
 
-            ForEach&
-            SetSummaryExactCallback (SummaryContainer::ExactMatchForEachCallback callback)
+            template<typename U = TypeSummaryImpl>
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            Set (SummaryContainer::ExactMatchForEachCallback callback)
             {
                 m_summary_exact = callback;
                 return *this;
             }
-            ForEach&
-            SetSummaryRegexCallback (SummaryContainer::RegexMatchForEachCallback callback)
+            template<typename U = TypeSummaryImpl>
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            Set (SummaryContainer::RegexMatchForEachCallback callback)
             {
                 m_summary_regex = callback;
                 return *this;
             }
 
-            ForEach&
-            SetFilterExactCallback (FilterContainer::ExactMatchForEachCallback callback)
+            template<typename U = TypeFilterImpl>
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            Set (FilterContainer::ExactMatchForEachCallback callback)
             {
                 m_filter_exact = callback;
                 return *this;
             }
-            ForEach&
-            SetFilterRegexCallback (FilterContainer::RegexMatchForEachCallback callback)
+            template<typename U = TypeFilterImpl>
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            Set (FilterContainer::RegexMatchForEachCallback callback)
             {
                 m_filter_regex = callback;
                 return *this;
             }
 
 #ifndef LLDB_DISABLE_PYTHON
-            ForEach&
-            SetSynthExactCallback (SynthContainer::ExactMatchForEachCallback callback)
+            template<typename U = SyntheticChildren>
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            Set (SynthContainer::ExactMatchForEachCallback callback)
             {
                 m_synth_exact = callback;
                 return *this;
             }
-            ForEach&
-            SetSynthRegexCallback (SynthContainer::RegexMatchForEachCallback callback)
+            template<typename U = SyntheticChildren>
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            Set (SynthContainer::RegexMatchForEachCallback callback)
             {
                 m_synth_regex = callback;
                 return *this;
             }
 #endif // LLDB_DISABLE_PYTHON
-
-            ForEach&
-            SetValidatorExactCallback (ValidatorContainer::ExactMatchForEachCallback callback)
+            template<typename U = TypeValidatorImpl>
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            Set (ValidatorContainer::ExactMatchForEachCallback callback)
             {
                 m_validator_exact = callback;
                 return *this;
             }
-            ForEach&
-            SetValidatorRegexCallback (ValidatorContainer::RegexMatchForEachCallback callback)
+            template<typename U = TypeValidatorImpl>
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            Set (ValidatorContainer::RegexMatchForEachCallback callback)
             {
                 m_validator_regex = callback;
                 return *this;
@@ -271,8 +273,9 @@ namespace lldb_private {
                           ConstString name,
                           std::initializer_list<lldb::LanguageType> langs = {});
         
+        template <typename T>
         void
-        ForEach (const ForEach &foreach)
+        ForEach (const ForEachCallbacks<T> &foreach)
         {
             GetTypeFormatsContainer()->ForEach(foreach.GetFormatExactCallback());
             GetRegexTypeFormatsContainer()->ForEach(foreach.GetFormatRegexCallback());
diff --git a/lldb/include/lldb/DataFormatters/TypeCategoryMap.h b/lldb/include/lldb/DataFormatters/TypeCategoryMap.h
index 62b8ce8b330..a71a0062cdf 100644
--- a/lldb/include/lldb/DataFormatters/TypeCategoryMap.h
+++ b/lldb/include/lldb/DataFormatters/TypeCategoryMap.h
@@ -88,9 +88,6 @@ namespace lldb_private {
              ValueSP& entry);
         
         void
-        LoopThrough (CallbackType callback, void* param);
-        
-        void
         ForEach (ForEachCallback callback);
         
         lldb::TypeCategoryImplSP
diff --git a/lldb/include/lldb/DataFormatters/TypeSynthetic.h b/lldb/include/lldb/DataFormatters/TypeSynthetic.h
index 61310503d1c..37c85823eac 100644
--- a/lldb/include/lldb/DataFormatters/TypeSynthetic.h
+++ b/lldb/include/lldb/DataFormatters/TypeSynthetic.h
@@ -479,6 +479,8 @@ namespace lldb_private {
             return SyntheticChildrenFrontEnd::AutoPointer(new FrontEnd(this, backend));
         }
         
+        typedef std::shared_ptr<TypeFilterImpl> SharedPointer;
+        
     private:
         DISALLOW_COPY_AND_ASSIGN(TypeFilterImpl);
     };
diff --git a/lldb/source/API/SBTypeCategory.cpp b/lldb/source/API/SBTypeCategory.cpp
index 287edfe140b..33dada8da39 100644
--- a/lldb/source/API/SBTypeCategory.cpp
+++ b/lldb/source/API/SBTypeCategory.cpp
@@ -180,7 +180,7 @@ SBTypeCategory::GetFilterForType (SBTypeNameSpecifier spec)
     if (!spec.IsValid())
         return SBTypeFilter();
     
-    lldb::SyntheticChildrenSP children_sp;
+    lldb::TypeFilterImplSP children_sp;
     
     if (spec.IsRegex())
         m_opaque_sp->GetRegexTypeFiltersContainer()->GetExact(ConstString(spec.GetName()), children_sp);
diff --git a/lldb/source/Commands/CommandObjectType.cpp b/lldb/source/Commands/CommandObjectType.cpp
index 2ee3b5628e9..c99a58ec215 100644
--- a/lldb/source/Commands/CommandObjectType.cpp
+++ b/lldb/source/Commands/CommandObjectType.cpp
@@ -1089,13 +1089,6 @@ CommandObjectTypeFormatterDelete::CommandOptions::g_option_table[] =
     { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
 };
 
-
-
-
-
-
-
-
 class CommandObjectTypeFormatterClear : public CommandObjectParsed
 {
 private:
@@ -1224,10 +1217,6 @@ CommandObjectTypeFormatterClear::CommandOptions::g_option_table[] =
     { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
 };
 
-
-
-
-
 //-------------------------------------------------------------------------
 // CommandObjectTypeFormatDelete
 //-------------------------------------------------------------------------
@@ -1264,25 +1253,8 @@ public:
     }
 };
 
-//-------------------------------------------------------------------------
-// CommandObjectTypeFormatList
-//-------------------------------------------------------------------------
-
-bool CommandObjectTypeFormatList_LoopCallback(void* pt2self, ConstString type, const lldb::TypeFormatImplSP& entry);
-bool CommandObjectTypeRXFormatList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const lldb::TypeFormatImplSP& entry);
-
-class CommandObjectTypeFormatList;
-
-struct CommandObjectTypeFormatList_LoopCallbackParam {
-    CommandObjectTypeFormatList* self;
-    CommandReturnObject* result;
-    RegularExpression* regex;
-    RegularExpression* cate_regex;
-    CommandObjectTypeFormatList_LoopCallbackParam(CommandObjectTypeFormatList* S, CommandReturnObject* R,
-                                            RegularExpression* X = NULL, RegularExpression* CX = NULL) : self(S), result(R), regex(X), cate_regex(CX) {}
-};
-
-class CommandObjectTypeFormatList : public CommandObjectParsed
+template <typename FormatterType>
+class CommandObjectTypeFormatterList : public CommandObjectParsed
 {
     class CommandOptions : public Options
     {
@@ -1323,6 +1295,12 @@ class CommandObjectTypeFormatList : public CommandObjectParsed
         const OptionDefinition*
         GetDefinitions () override
         {
+            static OptionDefinition g_option_table[] =
+            {
+                { LLDB_OPT_SET_ALL, false, "category-regex", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName,  "Only show categories matching this filter."},
+                { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
+            };
+
             return g_option_table;
         }
         
@@ -1345,10 +1323,12 @@ class CommandObjectTypeFormatList : public CommandObjectParsed
     }
 
 public:
-    CommandObjectTypeFormatList (CommandInterpreter &interpreter) :
+    CommandObjectTypeFormatterList (CommandInterpreter &interpreter,
+                                    const char* name,
+                                    const char* help) :
         CommandObjectParsed (interpreter,
-                             "type format list",
-                             "Show a list of current formatting styles.",
+                             name,
+                             help,
                              NULL),
     m_options(interpreter)
     {
@@ -1363,115 +1343,137 @@ public:
         m_arguments.push_back (type_arg);
     }
     
-    ~CommandObjectTypeFormatList () override
+    ~CommandObjectTypeFormatterList () override
     {
     }
     
 protected:
+    virtual void
+    FormatterSpecificList (CommandReturnObject &result)
+    {
+    }
+    
     bool
     DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
-        CommandObjectTypeFormatList_LoopCallbackParam *param;
-        RegularExpression* cate_regex =
-        m_options.m_category_regex.empty() ? NULL :
-        new RegularExpression(m_options.m_category_regex.c_str());
+        std::unique_ptr<RegularExpression> category_regex;
+        std::unique_ptr<RegularExpression> formatter_regex;
+        
+        if (m_options.m_category_regex.size() > 0)
+        {
+            category_regex.reset(new RegularExpression());
+            if (!category_regex->Compile(m_options.m_category_regex.c_str()))
+            {
+                result.AppendErrorWithFormat("syntax error in category regular expression '%s'", m_options.m_category_regex.c_str());
+                result.SetStatus(eReturnStatusFailed);
+                return false;
+            }
+        }
         
         if (argc == 1)
         {
-            RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0));
-            regex->Compile(command.GetArgumentAtIndex(0));
-            param = new CommandObjectTypeFormatList_LoopCallbackParam(this,&result,regex,cate_regex);
+            const char* arg = command.GetArgumentAtIndex(1);
+            formatter_regex.reset(new RegularExpression());
+            if (!formatter_regex->Compile(arg))
+            {
+                result.AppendErrorWithFormat("syntax error in regular expression '%s'", arg);
+                result.SetStatus(eReturnStatusFailed);
+                return false;
+            }
         }
-        else
-            param = new CommandObjectTypeFormatList_LoopCallbackParam(this,&result,NULL,cate_regex);
         
-        DataVisualization::Categories::LoopThrough(PerCategoryCallback,param);
-        delete param;
+        DataVisualization::Categories::ForEach( [this, &command, &result, &category_regex, &formatter_regex] (const lldb::TypeCategoryImplSP& category) -> bool {
+            if (category_regex)
+            {
+                bool escape = true;
+                if (0 == strcmp(category->GetName(), category_regex->GetText()))
+                {
+                    escape = false;
+                }
+                else if (category_regex->Execute(category->GetName()))
+                {
+                    escape = false;
+                }
+                
+                if (escape)
+                    return true;
+            }
+
+            result.GetOutputStream().Printf("-----------------------\nCategory: %s\n-----------------------\n", category->GetName());
+            
+            TypeCategoryImpl::ForEachCallbacks<FormatterType> foreach;
+            foreach.Set( [&result, &formatter_regex] (ConstString name, const typename FormatterType::SharedPointer& format_sp) -> bool {
+                if (formatter_regex)
+                {
+                    bool escape = true;
+                    if (0 == strcmp(name.AsCString(), formatter_regex->GetText()))
+                    {
+                        escape = false;
+                    }
+                    else if (formatter_regex->Execute(name.AsCString()))
+                    {
+                        escape = false;
+                    }
+                    
+                    if (escape)
+                        return true;
+                }
+
+                result.GetOutputStream().Printf ("%s: %s\n", name.AsCString(), format_sp->GetDescription().c_str());
+                
+                return true;
+            });
+
+            foreach.Set( [&result, &formatter_regex] (RegularExpressionSP regex_sp, const typename FormatterType::SharedPointer& format_sp) -> bool {
+                if (formatter_regex)
+                {
+                    bool escape = true;
+                    if (0 == strcmp(regex_sp->GetText(), formatter_regex->GetText()))
+                    {
+                        escape = false;
+                    }
+                    else if (formatter_regex->Execute(regex_sp->GetText()))
+                    {
+                        escape = false;
+                    }
+                    
+                    if (escape)
+                        return true;
+                }
+                
+                result.GetOutputStream().Printf ("%s: %s\n", regex_sp->GetText(), format_sp->GetDescription().c_str());
+                
+                return true;
+            });
 
-        if (cate_regex)
-            delete cate_regex;
+            category->ForEach(foreach);
+            
+            return true;
+        });
         
+        FormatterSpecificList(result);
+
         result.SetStatus(eReturnStatusSuccessFinishResult);
         return result.Succeeded();
     }
-    
-private:
-    
-    static bool
-    PerCategoryCallback(void* param_vp,
-                        const lldb::TypeCategoryImplSP& cate)
-    {
-        
-        CommandObjectTypeFormatList_LoopCallbackParam* param =
-        (CommandObjectTypeFormatList_LoopCallbackParam*)param_vp;
-        CommandReturnObject* result = param->result;
-        
-        const char* cate_name = cate->GetName();
-        
-        // if the category is disabled or empty and there is no regex, just skip it
-        if ((cate->IsEnabled() == false || cate->GetCount(eFormatCategoryItemValue | eFormatCategoryItemRegexValue) == 0) && param->cate_regex == NULL)
-            return true;
-        
-        // if we have a regex and this category does not match it, just skip it
-        if(param->cate_regex != NULL && strcmp(cate_name,param->cate_regex->GetText()) != 0 && param->cate_regex->Execute(cate_name) == false)
-            return true;
-        
-        result->GetOutputStream().Printf("-----------------------\nCategory: %s\n-----------------------\n", cate->GetDescription().c_str());
-        
-        cate->GetTypeFormatsContainer()->LoopThrough(CommandObjectTypeFormatList_LoopCallback, param_vp);
-        
-        if (cate->GetRegexTypeFormatsContainer()->GetCount() > 0)
-        {
-            result->GetOutputStream().Printf("Regex-based formats (slower):\n");
-            cate->GetRegexTypeFormatsContainer()->LoopThrough(CommandObjectTypeRXFormatList_LoopCallback, param_vp);
-        }
-        return true;
-    }
-    
-    
-    bool
-    LoopCallback (const char* type,
-                  const lldb::TypeFormatImplSP& entry,
-                  RegularExpression* regex,
-                  CommandReturnObject *result)
-    {
-        if (regex == NULL || strcmp(type,regex->GetText()) == 0 || regex->Execute(type))
-            result->GetOutputStream().Printf ("%s: %s\n", type, entry->GetDescription().c_str());
-        return true;
-    }
-    
-    friend bool CommandObjectTypeFormatList_LoopCallback(void* pt2self, ConstString type, const lldb::TypeFormatImplSP& entry);
-    friend bool CommandObjectTypeRXFormatList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const lldb::TypeFormatImplSP& entry);
-    
 };
 
-bool
-CommandObjectTypeFormatList_LoopCallback (
-                                    void* pt2self,
-                                    ConstString type,
-                                    const lldb::TypeFormatImplSP& entry)
-{
-    CommandObjectTypeFormatList_LoopCallbackParam* param = (CommandObjectTypeFormatList_LoopCallbackParam*)pt2self;
-    return param->self->LoopCallback(type.AsCString(), entry, param->regex, param->result);
-}
-
-bool
-CommandObjectTypeRXFormatList_LoopCallback (
-                                             void* pt2self,
-                                             lldb::RegularExpressionSP regex,
-                                             const lldb::TypeFormatImplSP& entry)
-{
-    CommandObjectTypeFormatList_LoopCallbackParam* param = (CommandObjectTypeFormatList_LoopCallbackParam*)pt2self;
-    return param->self->LoopCallback(regex->GetText(), entry, param->regex, param->result);
-}
+//-------------------------------------------------------------------------
+// CommandObjectTypeFormatList
+//-------------------------------------------------------------------------
 
-OptionDefinition
-CommandObjectTypeFormatList::CommandOptions::g_option_table[] =
+class CommandObjectTypeFormatList : public CommandObjectTypeFormatterList<TypeFormatImpl>
 {
-    { LLDB_OPT_SET_ALL, false, "category-regex", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName,  "Only show categories matching this filter."},
-    { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
+public:
+    
+    CommandObjectTypeFormatList (CommandInterpreter &interpreter) :
+        CommandObjectTypeFormatterList(interpreter,
+                                       "type format list",
+                                       "Show a list of current formats.")
+    {
+    }
 };
 
 #ifndef LLDB_DISABLE_PYTHON
@@ -2046,226 +2048,30 @@ protected:
 // CommandObjectTypeSummaryList
 //-------------------------------------------------------------------------
 
-bool CommandObjectTypeSummaryList_LoopCallback(void* pt2self, ConstString type, const StringSummaryFormat::SharedPointer& entry);
-bool CommandObjectTypeRXSummaryList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const StringSummaryFormat::SharedPointer& entry);
-
-class CommandObjectTypeSummaryList;
-
-struct CommandObjectTypeSummaryList_LoopCallbackParam {
-    CommandObjectTypeSummaryList* self;
-    CommandReturnObject* result;
-    RegularExpression* regex;
-    RegularExpression* cate_regex;
-    CommandObjectTypeSummaryList_LoopCallbackParam(CommandObjectTypeSummaryList* S, CommandReturnObject* R,
-                                                  RegularExpression* X = NULL,
-                                                  RegularExpression* CX = NULL) : self(S), result(R), regex(X), cate_regex(CX) {}
-};
-
-class CommandObjectTypeSummaryList : public CommandObjectParsed
+class CommandObjectTypeSummaryList : public CommandObjectTypeFormatterList<TypeSummaryImpl>
 {
-    
-    class CommandOptions : public Options
-    {
-    public:
-        
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options (interpreter)
-        {
-        }
-        
-        ~CommandOptions () override {}
-        
-        Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
-        {
-            Error error;
-            const int short_option = m_getopt_table[option_idx].val;
-            
-            switch (short_option)
-            {
-                case 'w':
-                    m_category_regex = std::string(option_arg);
-                    break;
-                default:
-                    error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
-                    break;
-            }
-            
-            return error;
-        }
-        
-        void
-        OptionParsingStarting () override
-        {
-            m_category_regex = "";
-        }
-        
-        const OptionDefinition*
-        GetDefinitions () override
-        {
-            return g_option_table;
-        }
-        
-        // Options table: Required for subclasses of Options.
-        
-        static OptionDefinition g_option_table[];
-        
-        // Instance variables to hold the values for command options.
-        
-        std::string m_category_regex;
-        
-    };
-    
-    CommandOptions m_options;
-    
-    Options *
-    GetOptions () override
-    {
-        return &m_options;
-    }
-    
 public:
-    CommandObjectTypeSummaryList (CommandInterpreter &interpreter) :
-        CommandObjectParsed (interpreter,
-                             "type summary list",
-                             "Show a list of current summary styles.",
-                             NULL),
-        m_options(interpreter)
-    {
-        CommandArgumentEntry type_arg;
-        CommandArgumentData type_style_arg;
-        
-        type_style_arg.arg_type = eArgTypeName;
-        type_style_arg.arg_repetition = eArgRepeatOptional;
-        
-        type_arg.push_back (type_style_arg);
-        
-        m_arguments.push_back (type_arg);
-    }
     
-    ~CommandObjectTypeSummaryList () override
+    CommandObjectTypeSummaryList (CommandInterpreter &interpreter) :
+    CommandObjectTypeFormatterList(interpreter,
+                                   "type summary list",
+                                   "Show a list of current summaries.")
     {
     }
     
 protected:
-    bool
-    DoExecute (Args& command, CommandReturnObject &result) override
+    void
+    FormatterSpecificList (CommandReturnObject &result) override
     {
-        const size_t argc = command.GetArgumentCount();
-        
-        CommandObjectTypeSummaryList_LoopCallbackParam *param;
-        RegularExpression* cate_regex = 
-        m_options.m_category_regex.empty() ? NULL :
-        new RegularExpression(m_options.m_category_regex.c_str());
-        
-        if (argc == 1)
-        {
-            RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0));
-            regex->Compile(command.GetArgumentAtIndex(0));
-            param = new CommandObjectTypeSummaryList_LoopCallbackParam(this,&result,regex,cate_regex);
-        }
-        else
-            param = new CommandObjectTypeSummaryList_LoopCallbackParam(this,&result,NULL,cate_regex);
-        
-        DataVisualization::Categories::LoopThrough(PerCategoryCallback,param);
-        delete param;
-
         if (DataVisualization::NamedSummaryFormats::GetCount() > 0)
         {
             result.GetOutputStream().Printf("Named summaries:\n");
-            if (argc == 1)
-            {
-                RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0));
-                regex->Compile(command.GetArgumentAtIndex(0));
-                param = new CommandObjectTypeSummaryList_LoopCallbackParam(this,&result,regex);
-            }
-            else
-                param = new CommandObjectTypeSummaryList_LoopCallbackParam(this,&result);
-            DataVisualization::NamedSummaryFormats::LoopThrough(CommandObjectTypeSummaryList_LoopCallback, param);
-            delete param;
-        }
-        
-        if (cate_regex)
-            delete cate_regex;
-        
-        result.SetStatus(eReturnStatusSuccessFinishResult);
-        return result.Succeeded();
-    }
-    
-private:
-    
-    static bool
-    PerCategoryCallback(void* param_vp,
-                        const lldb::TypeCategoryImplSP& cate)
-    {
-        
-        CommandObjectTypeSummaryList_LoopCallbackParam* param = 
-            (CommandObjectTypeSummaryList_LoopCallbackParam*)param_vp;
-        CommandReturnObject* result = param->result;
-        
-        const char* cate_name = cate->GetName();
-        
-        // if the category is disabled or empty and there is no regex, just skip it
-        if ((cate->IsEnabled() == false || cate->GetCount(eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary) == 0) && param->cate_regex == NULL)
-            return true;
-        
-        // if we have a regex and this category does not match it, just skip it
-        if(param->cate_regex != NULL && strcmp(cate_name,param->cate_regex->GetText()) != 0 && param->cate_regex->Execute(cate_name) == false)
-            return true;
-        
-        result->GetOutputStream().Printf("-----------------------\nCategory: %s\n-----------------------\n", cate->GetDescription().c_str());
-
-        cate->GetTypeSummariesContainer()->LoopThrough(CommandObjectTypeSummaryList_LoopCallback, param_vp);
-        
-        if (cate->GetRegexTypeSummariesContainer()->GetCount() > 0)
-        {
-            result->GetOutputStream().Printf("Regex-based summaries (slower):\n");
-            cate->GetRegexTypeSummariesContainer()->LoopThrough(CommandObjectTypeRXSummaryList_LoopCallback, param_vp);
+            DataVisualization::NamedSummaryFormats::ForEach( [&result] (ConstString name, const TypeSummaryImplSP& summary_sp) -> bool {
+                result.GetOutputStream().Printf ("%s: %s\n", name.AsCString(), summary_sp->GetDescription().c_str());
+                return true;
+            });
         }
-        return true;
-    }
-
-    
-    bool
-    LoopCallback (const char* type,
-                  const lldb::TypeSummaryImplSP& entry,
-                  RegularExpression* regex,
-                  CommandReturnObject *result)
-    {
-        if (regex == NULL || strcmp(type,regex->GetText()) == 0 || regex->Execute(type))
-                result->GetOutputStream().Printf ("%s: %s\n", type, entry->GetDescription().c_str());
-        return true;
     }
-    
-    friend bool CommandObjectTypeSummaryList_LoopCallback(void* pt2self, ConstString type, const lldb::TypeSummaryImplSP& entry);
-    friend bool CommandObjectTypeRXSummaryList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const lldb::TypeSummaryImplSP& entry);
-};
-
-bool
-CommandObjectTypeSummaryList_LoopCallback (
-                                          void* pt2self,
-                                          ConstString type,
-                                          const lldb::TypeSummaryImplSP& entry)
-{
-    CommandObjectTypeSummaryList_LoopCallbackParam* param = (CommandObjectTypeSummaryList_LoopCallbackParam*)pt2self;
-    return param->self->LoopCallback(type.AsCString(), entry, param->regex, param->result);
-}
-
-bool
-CommandObjectTypeRXSummaryList_LoopCallback (
-                                           void* pt2self,
-                                           lldb::RegularExpressionSP regex,
-                                           const lldb::TypeSummaryImplSP& entry)
-{
-    CommandObjectTypeSummaryList_LoopCallbackParam* param = (CommandObjectTypeSummaryList_LoopCallbackParam*)pt2self;
-    return param->self->LoopCallback(regex->GetText(), entry, param->regex, param->result);
-}
-
-OptionDefinition
-CommandObjectTypeSummaryList::CommandOptions::g_option_table[] =
-{
-    { LLDB_OPT_SET_ALL, false, "category-regex", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName,  "Only show categories matching this filter."},
-    { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
 };
 
 //-------------------------------------------------------------------------
@@ -2786,37 +2592,6 @@ CommandObjectTypeCategoryDisable::CommandOptions::g_option_table[] =
 
 class CommandObjectTypeCategoryList : public CommandObjectParsed
 {
-private:
-    
-    struct CommandObjectTypeCategoryList_CallbackParam
-    {
-        CommandReturnObject* result;
-        RegularExpression* regex;
-        
-        CommandObjectTypeCategoryList_CallbackParam(CommandReturnObject* res,
-                                                    RegularExpression* rex = NULL) :
-        result(res),
-        regex(rex)
-        {
-        }
-        
-    };
-    
-    static bool
-    PerCategoryCallback(void* param_vp,
-                        const lldb::TypeCategoryImplSP& cate)
-    {
-        CommandObjectTypeCategoryList_CallbackParam* param =
-            (CommandObjectTypeCategoryList_CallbackParam*)param_vp;
-        CommandReturnObject* result = param->result;
-        RegularExpression* regex = param->regex;
-        
-        const char* cate_name = cate->GetName();
-        
-        if (regex == NULL || strcmp(cate_name, regex->GetText()) == 0 || regex->Execute(cate_name))
-            result->GetOutputStream().Printf("Category: %s\n", cate->GetDescription().c_str());
-        return true;
-    }
 public:
     CommandObjectTypeCategoryList (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
@@ -2844,26 +2619,48 @@ protected:
     DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
-        RegularExpression* regex = NULL;
+
+        std::unique_ptr<RegularExpression> regex;
         
-        if (argc == 0)
-            ;
-        else if (argc == 1)
-            regex = new RegularExpression(command.GetArgumentAtIndex(0));
-        else
+        if (argc == 1)
+        {
+            regex.reset(new RegularExpression());
+            const char* arg = command.GetArgumentAtIndex(0);
+            if (!regex->Compile(arg))
+            {
+                result.AppendErrorWithFormat("syntax error in category regular expression '%s'", arg);
+                result.SetStatus(eReturnStatusFailed);
+                return false;
+            }
+        }
+        else if (argc != 0)
         {
             result.AppendErrorWithFormat ("%s takes 0 or one arg.\n", m_cmd_name.c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;
         }
         
-        CommandObjectTypeCategoryList_CallbackParam param(&result,
-                                                          regex);
-        
-        DataVisualization::Categories::LoopThrough(PerCategoryCallback, &param);
-        
-        if (regex)
-            delete regex;
+        DataVisualization::Categories::ForEach( [&regex, &result] (const lldb::TypeCategoryImplSP& category_sp) -> bool {
+            if (regex)
+            {
+                bool escape = true;
+                if (0 == strcmp(category_sp->GetName(), regex->GetText()))
+                {
+                    escape = false;
+                }
+                else if (regex->Execute(category_sp->GetName()))
+                {
+                    escape = false;
+                }
+                
+                if (escape)
+                    return true;
+            }
+            
+            result.GetOutputStream().Printf("Category: %s\n", category_sp->GetDescription().c_str());
+            
+            return true;
+        });
         
         result.SetStatus(eReturnStatusSuccessFinishResult);
         return result.Succeeded();
@@ -2875,210 +2672,16 @@ protected:
 // CommandObjectTypeFilterList
 //-------------------------------------------------------------------------
 
-bool CommandObjectTypeFilterList_LoopCallback(void* pt2self, ConstString type, const SyntheticChildren::SharedPointer& entry);
-bool CommandObjectTypeFilterRXList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const SyntheticChildren::SharedPointer& entry);
-
-class CommandObjectTypeFilterList;
-
-struct CommandObjectTypeFilterList_LoopCallbackParam {
-    CommandObjectTypeFilterList* self;
-    CommandReturnObject* result;
-    RegularExpression* regex;
-    RegularExpression* cate_regex;
-    CommandObjectTypeFilterList_LoopCallbackParam(CommandObjectTypeFilterList* S, CommandReturnObject* R,
-                                                  RegularExpression* X = NULL,
-                                                  RegularExpression* CX = NULL) : self(S), result(R), regex(X), cate_regex(CX) {}
-};
-
-class CommandObjectTypeFilterList : public CommandObjectParsed
+class CommandObjectTypeFilterList : public CommandObjectTypeFormatterList<TypeFilterImpl>
 {
-    
-    class CommandOptions : public Options
-    {
-    public:
-        
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options (interpreter)
-        {
-        }
-        
-        ~CommandOptions () override {}
-        
-        Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
-        {
-            Error error;
-            const int short_option = m_getopt_table[option_idx].val;
-            
-            switch (short_option)
-            {
-                case 'w':
-                    m_category_regex = std::string(option_arg);
-                    break;
-                default:
-                    error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
-                    break;
-            }
-            
-            return error;
-        }
-        
-        void
-        OptionParsingStarting () override
-        {
-            m_category_regex = "";
-        }
-        
-        const OptionDefinition*
-        GetDefinitions () override
-        {
-            return g_option_table;
-        }
-        
-        // Options table: Required for subclasses of Options.
-        
-        static OptionDefinition g_option_table[];
-        
-        // Instance variables to hold the values for command options.
-        
-        std::string m_category_regex;
-        
-    };
-    
-    CommandOptions m_options;
-    
-    Options *
-    GetOptions () override
-    {
-        return &m_options;
-    }
-    
 public:
-    CommandObjectTypeFilterList (CommandInterpreter &interpreter) :
-        CommandObjectParsed (interpreter,
-                             "type filter list",
-                             "Show a list of current filters.",
-                             NULL),
-        m_options(interpreter)
-    {
-        CommandArgumentEntry type_arg;
-        CommandArgumentData type_style_arg;
-        
-        type_style_arg.arg_type = eArgTypeName;
-        type_style_arg.arg_repetition = eArgRepeatOptional;
-        
-        type_arg.push_back (type_style_arg);
-        
-        m_arguments.push_back (type_arg);
-    }
-    
-    ~CommandObjectTypeFilterList () override
-    {
-    }
-    
-protected:
-    bool
-    DoExecute (Args& command, CommandReturnObject &result) override
-    {
-        const size_t argc = command.GetArgumentCount();
-        
-        CommandObjectTypeFilterList_LoopCallbackParam *param;
-        RegularExpression* cate_regex = 
-        m_options.m_category_regex.empty() ? NULL :
-        new RegularExpression(m_options.m_category_regex.c_str());
-        
-        if (argc == 1)
-        {
-            RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0));
-            regex->Compile(command.GetArgumentAtIndex(0));
-            param = new CommandObjectTypeFilterList_LoopCallbackParam(this,&result,regex,cate_regex);
-        }
-        else
-            param = new CommandObjectTypeFilterList_LoopCallbackParam(this,&result,NULL,cate_regex);
-        
-        DataVisualization::Categories::LoopThrough(PerCategoryCallback,param);
-        delete param;
-        
-        if (cate_regex)
-            delete cate_regex;
-        
-        result.SetStatus(eReturnStatusSuccessFinishResult);
-        return result.Succeeded();
-    }
     
-private:
-    
-    static bool
-    PerCategoryCallback(void* param_vp,
-                        const lldb::TypeCategoryImplSP& cate)
-    {
-        
-        const char* cate_name = cate->GetName();
-        
-        CommandObjectTypeFilterList_LoopCallbackParam* param = 
-        (CommandObjectTypeFilterList_LoopCallbackParam*)param_vp;
-        CommandReturnObject* result = param->result;
-        
-        // if the category is disabled or empty and there is no regex, just skip it
-        if ((cate->IsEnabled() == false || cate->GetCount(eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter) == 0) && param->cate_regex == NULL)
-            return true;
-        
-        // if we have a regex and this category does not match it, just skip it
-        if(param->cate_regex != NULL && strcmp(cate_name,param->cate_regex->GetText()) != 0 && param->cate_regex->Execute(cate_name) == false)
-            return true;
-        
-        result->GetOutputStream().Printf("-----------------------\nCategory: %s\n-----------------------\n", cate->GetDescription().c_str());
-        
-        cate->GetTypeFiltersContainer()->LoopThrough(CommandObjectTypeFilterList_LoopCallback, param_vp);
-        
-        if (cate->GetRegexTypeFiltersContainer()->GetCount() > 0)
-        {
-            result->GetOutputStream().Printf("Regex-based filters (slower):\n");
-            cate->GetRegexTypeFiltersContainer()->LoopThrough(CommandObjectTypeFilterRXList_LoopCallback, param_vp);
-        }
-        
-        return true;
-    }
-    
-    bool
-    LoopCallback (const char* type,
-                  const SyntheticChildren::SharedPointer& entry,
-                  RegularExpression* regex,
-                  CommandReturnObject *result)
+    CommandObjectTypeFilterList (CommandInterpreter &interpreter) :
+    CommandObjectTypeFormatterList(interpreter,
+                                   "type filter list",
+                                   "Show a list of current filters.")
     {
-        if (regex == NULL || regex->Execute(type))
-            result->GetOutputStream().Printf ("%s: %s\n", type, entry->GetDescription().c_str());
-        return true;
     }
-    
-    friend bool CommandObjectTypeFilterList_LoopCallback(void* pt2self, ConstString type, const SyntheticChildren::SharedPointer& entry);
-    friend bool CommandObjectTypeFilterRXList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const SyntheticChildren::SharedPointer& entry);
-};
-
-bool
-CommandObjectTypeFilterList_LoopCallback (void* pt2self,
-                                         ConstString type,
-                                         const SyntheticChildren::SharedPointer& entry)
-{
-    CommandObjectTypeFilterList_LoopCallbackParam* param = (CommandObjectTypeFilterList_LoopCallbackParam*)pt2self;
-    return param->self->LoopCallback(type.AsCString(), entry, param->regex, param->result);
-}
-
-bool
-CommandObjectTypeFilterRXList_LoopCallback (void* pt2self,
-                                           lldb::RegularExpressionSP regex,
-                                           const SyntheticChildren::SharedPointer& entry)
-{
-    CommandObjectTypeFilterList_LoopCallbackParam* param = (CommandObjectTypeFilterList_LoopCallbackParam*)pt2self;
-    return param->self->LoopCallback(regex->GetText(), entry, param->regex, param->result);
-}
-
-
-OptionDefinition
-CommandObjectTypeFilterList::CommandOptions::g_option_table[] =
-{
-    { LLDB_OPT_SET_ALL, false, "category-regex", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName,  "Only show categories matching this filter."},
-    { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
 };
 
 #ifndef LLDB_DISABLE_PYTHON
@@ -3087,210 +2690,16 @@ CommandObjectTypeFilterList::CommandOptions::g_option_table[] =
 // CommandObjectTypeSynthList
 //-------------------------------------------------------------------------
 
-bool CommandObjectTypeSynthList_LoopCallback(void* pt2self, ConstString type, const SyntheticChildren::SharedPointer& entry);
-bool CommandObjectTypeSynthRXList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const SyntheticChildren::SharedPointer& entry);
-
-class CommandObjectTypeSynthList;
-
-struct CommandObjectTypeSynthList_LoopCallbackParam {
-    CommandObjectTypeSynthList* self;
-    CommandReturnObject* result;
-    RegularExpression* regex;
-    RegularExpression* cate_regex;
-    CommandObjectTypeSynthList_LoopCallbackParam(CommandObjectTypeSynthList* S, CommandReturnObject* R,
-                                                 RegularExpression* X = NULL,
-                                                 RegularExpression* CX = NULL) : self(S), result(R), regex(X), cate_regex(CX) {}
-};
-
-class CommandObjectTypeSynthList : public CommandObjectParsed
+class CommandObjectTypeSynthList : public CommandObjectTypeFormatterList<SyntheticChildren>
 {
-    
-    class CommandOptions : public Options
-    {
-    public:
-        
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options (interpreter)
-        {
-        }
-        
-        ~CommandOptions () override {}
-        
-        Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
-        {
-            Error error;
-            const int short_option = m_getopt_table[option_idx].val;
-            
-            switch (short_option)
-            {
-                case 'w':
-                    m_category_regex = std::string(option_arg);
-                    break;
-                default:
-                    error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
-                    break;
-            }
-            
-            return error;
-        }
-        
-        void
-        OptionParsingStarting () override
-        {
-            m_category_regex = "";
-        }
-        
-        const OptionDefinition*
-        GetDefinitions () override
-        {
-            return g_option_table;
-        }
-        
-        // Options table: Required for subclasses of Options.
-        
-        static OptionDefinition g_option_table[];
-        
-        // Instance variables to hold the values for command options.
-        
-        std::string m_category_regex;
-        
-    };
-    
-    CommandOptions m_options;
-    
-    Options *
-    GetOptions () override
-    {
-        return &m_options;
-    }
-    
 public:
-    CommandObjectTypeSynthList (CommandInterpreter &interpreter) :
-        CommandObjectParsed (interpreter,
-                             "type synthetic list",
-                             "Show a list of current synthetic providers.",
-                             NULL),
-        m_options(interpreter)
-    {
-        CommandArgumentEntry type_arg;
-        CommandArgumentData type_style_arg;
-        
-        type_style_arg.arg_type = eArgTypeName;
-        type_style_arg.arg_repetition = eArgRepeatOptional;
-        
-        type_arg.push_back (type_style_arg);
-        
-        m_arguments.push_back (type_arg);
-    }
-    
-    ~CommandObjectTypeSynthList () override
-    {
-    }
-    
-protected:
-    bool
-    DoExecute (Args& command, CommandReturnObject &result) override
-    {
-        const size_t argc = command.GetArgumentCount();
-        
-        CommandObjectTypeSynthList_LoopCallbackParam *param;
-        RegularExpression* cate_regex = 
-        m_options.m_category_regex.empty() ? NULL :
-        new RegularExpression(m_options.m_category_regex.c_str());
-        
-        if (argc == 1)
-        {
-            RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0));
-            regex->Compile(command.GetArgumentAtIndex(0));
-            param = new CommandObjectTypeSynthList_LoopCallbackParam(this,&result,regex,cate_regex);
-        }
-        else
-            param = new CommandObjectTypeSynthList_LoopCallbackParam(this,&result,NULL,cate_regex);
-        
-        DataVisualization::Categories::LoopThrough(PerCategoryCallback,param);
-        delete param;
-
-        if (cate_regex)
-            delete cate_regex;
-        
-        result.SetStatus(eReturnStatusSuccessFinishResult);
-        return result.Succeeded();
-    }
-    
-private:
     
-    static bool
-    PerCategoryCallback(void* param_vp,
-                        const lldb::TypeCategoryImplSP& cate)
-    {
-        
-        CommandObjectTypeSynthList_LoopCallbackParam* param = 
-        (CommandObjectTypeSynthList_LoopCallbackParam*)param_vp;
-        CommandReturnObject* result = param->result;
-        
-        const char* cate_name = cate->GetName();
-        
-        // if the category is disabled or empty and there is no regex, just skip it
-        if ((cate->IsEnabled() == false || cate->GetCount(eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth) == 0) && param->cate_regex == NULL)
-            return true;
-        
-        // if we have a regex and this category does not match it, just skip it
-        if(param->cate_regex != NULL && strcmp(cate_name,param->cate_regex->GetText()) != 0 && param->cate_regex->Execute(cate_name) == false)
-            return true;
-        
-        result->GetOutputStream().Printf("-----------------------\nCategory: %s\n-----------------------\n", cate->GetDescription().c_str());
-        
-        cate->GetTypeSyntheticsContainer()->LoopThrough(CommandObjectTypeSynthList_LoopCallback, param_vp);
-        
-        if (cate->GetRegexTypeSyntheticsContainer()->GetCount() > 0)
-        {
-            result->GetOutputStream().Printf("Regex-based synthetic providers (slower):\n");
-            cate->GetRegexTypeSyntheticsContainer()->LoopThrough(CommandObjectTypeSynthRXList_LoopCallback, param_vp);
-        }
-        
-        return true;
-    }
-    
-    bool
-    LoopCallback (const char* type,
-                  const SyntheticChildren::SharedPointer& entry,
-                  RegularExpression* regex,
-                  CommandReturnObject *result)
+    CommandObjectTypeSynthList (CommandInterpreter &interpreter) :
+    CommandObjectTypeFormatterList(interpreter,
+                                   "type synthetic list",
+                                   "Show a list of current synthetic providers.")
     {
-        if (regex == NULL || regex->Execute(type))
-            result->GetOutputStream().Printf ("%s: %s\n", type, entry->GetDescription().c_str());
-        return true;
     }
-    
-    friend bool CommandObjectTypeSynthList_LoopCallback(void* pt2self, ConstString type, const SyntheticChildren::SharedPointer& entry);
-    friend bool CommandObjectTypeSynthRXList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const SyntheticChildren::SharedPointer& entry);
-};
-
-bool
-CommandObjectTypeSynthList_LoopCallback (void* pt2self,
-                                         ConstString type,
-                                         const SyntheticChildren::SharedPointer& entry)
-{
-    CommandObjectTypeSynthList_LoopCallbackParam* param = (CommandObjectTypeSynthList_LoopCallbackParam*)pt2self;
-    return param->self->LoopCallback(type.AsCString(), entry, param->regex, param->result);
-}
-
-bool
-CommandObjectTypeSynthRXList_LoopCallback (void* pt2self,
-                                         lldb::RegularExpressionSP regex,
-                                         const SyntheticChildren::SharedPointer& entry)
-{
-    CommandObjectTypeSynthList_LoopCallbackParam* param = (CommandObjectTypeSynthList_LoopCallbackParam*)pt2self;
-    return param->self->LoopCallback(regex->GetText(), entry, param->regex, param->result);
-}
-
-
-OptionDefinition
-CommandObjectTypeSynthList::CommandOptions::g_option_table[] =
-{
-    { LLDB_OPT_SET_ALL, false, "category-regex", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName,  "Only show categories matching this filter."},
-    { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
 };
 
 #endif // #ifndef LLDB_DISABLE_PYTHON
@@ -3664,7 +3073,7 @@ private:
     
     bool
     AddFilter(ConstString type_name,
-              SyntheticChildrenSP entry,
+              TypeFilterImplSP entry,
               FilterFormatType type,
               std::string category_name,
               Error* error)
@@ -3787,19 +3196,15 @@ protected:
             return false;
         }
         
-        SyntheticChildrenSP entry;
-        
-        TypeFilterImpl* impl = new TypeFilterImpl(SyntheticChildren::Flags().SetCascades(m_options.m_cascade).
-                                                    SetSkipPointers(m_options.m_skip_pointers).
-                                                    SetSkipReferences(m_options.m_skip_references));
-        
-        entry.reset(impl);
+        TypeFilterImplSP entry(new TypeFilterImpl(SyntheticChildren::Flags().SetCascades(m_options.m_cascade).
+                                       SetSkipPointers(m_options.m_skip_pointers).
+                                                  SetSkipReferences(m_options.m_skip_references)));
         
         // go through the expression paths
         CommandOptions::ExpressionPathsIterator begin, end = m_options.m_expr_paths.end();
         
         for (begin = m_options.m_expr_paths.begin(); begin != end; begin++)
-            impl->AddExpressionPath(*begin);
+            entry->AddExpressionPath(*begin);
         
         
         // now I have a valid provider, let's add it to every type
@@ -4289,5 +3694,3 @@ CommandObjectType::CommandObjectType (CommandInterpreter &interpreter) :
 CommandObjectType::~CommandObjectType ()
 {
 }
-
-
diff --git a/lldb/source/DataFormatters/DataVisualization.cpp b/lldb/source/DataFormatters/DataVisualization.cpp
index 581ef3f851a..14cf13d2f18 100644
--- a/lldb/source/DataFormatters/DataVisualization.cpp
+++ b/lldb/source/DataFormatters/DataVisualization.cpp
@@ -226,12 +226,6 @@ DataVisualization::Categories::DisableStar ()
 }
 
 void
-DataVisualization::Categories::LoopThrough (FormatManager::CategoryCallback callback, void* callback_baton)
-{
-    GetFormatManager().LoopThroughCategories(callback, callback_baton);
-}
-
-void
 DataVisualization::Categories::ForEach (TypeCategoryMap::ForEachCallback callback)
 {
     GetFormatManager().ForEachCategory(callback);
@@ -274,9 +268,9 @@ DataVisualization::NamedSummaryFormats::Clear ()
 }
 
 void
-DataVisualization::NamedSummaryFormats::LoopThrough (TypeSummaryImpl::SummaryCallback callback, void* callback_baton)
+DataVisualization::NamedSummaryFormats::ForEach (std::function<bool(ConstString, const lldb::TypeSummaryImplSP&)> callback)
 {
-    GetFormatManager().GetNamedSummaryContainer().LoopThrough(callback, callback_baton);
+    GetFormatManager().GetNamedSummaryContainer().ForEach(callback);
 }
 
 uint32_t
diff --git a/lldb/source/DataFormatters/FormatManager.cpp b/lldb/source/DataFormatters/FormatManager.cpp
index 3237f73f64e..8edc8e5ca8b 100644
--- a/lldb/source/DataFormatters/FormatManager.cpp
+++ b/lldb/source/DataFormatters/FormatManager.cpp
@@ -486,21 +486,6 @@ FormatManager::GetValidatorForType (lldb::TypeNameSpecifierImplSP type_sp)
 }
 
 void
-FormatManager::LoopThroughCategories (CategoryCallback callback, void* param)
-{
-    m_categories_map.LoopThrough(callback, param);
-    Mutex::Locker locker(m_language_categories_mutex);
-    for (const auto& entry : m_language_categories_map)
-    {
-        if (auto category_sp = entry.second->GetCategory())
-        {
-            if (!callback(param, category_sp))
-                break;
-        }
-    }
-}
-
-void
 FormatManager::ForEachCategory(TypeCategoryMap::ForEachCallback callback)
 {
     m_categories_map.ForEach(callback);
diff --git a/lldb/source/DataFormatters/TypeCategoryMap.cpp b/lldb/source/DataFormatters/TypeCategoryMap.cpp
index 19164a3c003..58e4e2117bb 100644
--- a/lldb/source/DataFormatters/TypeCategoryMap.cpp
+++ b/lldb/source/DataFormatters/TypeCategoryMap.cpp
@@ -373,39 +373,6 @@ TypeCategoryMap::GetValidator (FormattersMatchData& match_data)
 }
 
 void
-TypeCategoryMap::LoopThrough(CallbackType callback, void* param)
-{
-    if (callback)
-    {
-        Mutex::Locker locker(m_map_mutex);
-        
-        // loop through enabled categories in respective order
-        {
-            ActiveCategoriesIterator begin, end = m_active_categories.end();
-            for (begin = m_active_categories.begin(); begin != end; begin++)
-            {
-                lldb::TypeCategoryImplSP category = *begin;
-                if (!callback(param, category))
-                    break;
-            }
-        }
-        
-        // loop through disabled categories in just any order
-        {
-            MapIterator pos, end = m_map.end();
-            for (pos = m_map.begin(); pos != end; pos++)
-            {
-                if (pos->second->IsEnabled())
-                    continue;
-                KeyType type = pos->first;
-                if (!callback(param, pos->second))
-                    break;
-            }
-        }
-    }
-}
-
-void
 TypeCategoryMap::ForEach(ForEachCallback callback)
 {
     if (callback)