Reapply r253423 and r253424 (which cleanup the data formatters iteration model, as well as the type X list commands), along with a change by Zachary Turner to bypass a MSVC bug with SFINAE

llvm-svn: 253493

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 ();
@@ -157,9 +157,6 @@ public:
         static void
         DisableStar ();
         
-        static void
-        LoopThrough (FormatManager::CategoryCallback callback, void* callback_baton);
-        
         static void
         ForEach (TypeCategoryMap::ForEachCallback callback);
         

lldb/include/lldb/DataFormatters/FormatManager.h

@@ -43,8 +43,6 @@ class FormatManager : public IFormatChangeListener
 public:
     typedef std::map<lldb::LanguageType, LanguageCategory::UniquePointer> LanguageCategories;
     
-    typedef TypeCategoryMap::CallbackType CategoryCallback;
-    
     FormatManager();
     
     ~FormatManager() override = default;
@@ -139,9 +137,6 @@ public:
         return m_categories_map.GetAtIndex(index);
     }
     
-    void
-    LoopThroughCategories (CategoryCallback callback, void* param);
-
     void
     ForEachCategory (TypeCategoryMap::ForEachCallback callback);
     

lldb/include/lldb/DataFormatters/FormattersContainer.h

@@ -80,8 +80,6 @@ public:
     typedef typename ValueType::SharedPointer ValueSP;
     typedef std::map<KeyType, ValueSP> MapType;
     typedef typename MapType::iterator MapIterator;
-    typedef std::function<bool(void*, KeyType, const ValueSP&)> CallbackType;
-    
     typedef std::function<bool(KeyType, const ValueSP&)> ForEachCallback;
     
     FormatMap(IFormatChangeListener* lst) :
@@ -140,22 +138,6 @@ public:
         return true;
     }
     
-    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)
     {
@@ -242,7 +224,6 @@ public:
     typedef typename MapType::iterator MapIterator;
     typedef typename MapType::key_type MapKeyType;
     typedef typename MapType::mapped_type MapValueType;
-    typedef typename BackEndType::CallbackType CallbackType;
     typedef typename BackEndType::ForEachCallback ForEachCallback;
     typedef typename std::shared_ptr<FormattersContainer<KeyType, ValueType> > SharedPointer;
     
@@ -315,12 +296,6 @@ public:
         m_format_map.Clear();
     }
     
-    void
-    LoopThrough (CallbackType callback, void* param)
-    {
-        m_format_map.LoopThrough(callback,param);
-    }
-    
     void
     ForEach (ForEachCallback callback)
     {

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;
+            ForEachCallbacks () = default;
-            ~ForEach () = default;
+            ~ForEachCallbacks () = default;
             
-            ForEach&
+            template<typename U = TypeFormatImpl>
-            SetFormatExactCallback (FormatContainer::ExactMatchForEachCallback callback)
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            SetExact (FormatContainer::ExactMatchForEachCallback callback)
             {
                 m_format_exact = callback;
                 return *this;
             }
-            ForEach&
+            template<typename U = TypeFormatImpl>
-            SetFormatRegexCallback (FormatContainer::RegexMatchForEachCallback callback)
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            SetWithRegex (FormatContainer::RegexMatchForEachCallback callback)
             {
                 m_format_regex = callback;
                 return *this;
             }
 
-            ForEach&
+            template<typename U = TypeSummaryImpl>
-            SetSummaryExactCallback (SummaryContainer::ExactMatchForEachCallback callback)
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            SetExact (SummaryContainer::ExactMatchForEachCallback callback)
             {
                 m_summary_exact = callback;
                 return *this;
             }
-            ForEach&
+            template<typename U = TypeSummaryImpl>
-            SetSummaryRegexCallback (SummaryContainer::RegexMatchForEachCallback callback)
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            SetWithRegex (SummaryContainer::RegexMatchForEachCallback callback)
             {
                 m_summary_regex = callback;
                 return *this;
             }
 
-            ForEach&
+            template<typename U = TypeFilterImpl>
-            SetFilterExactCallback (FilterContainer::ExactMatchForEachCallback callback)
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            SetExact (FilterContainer::ExactMatchForEachCallback callback)
             {
                 m_filter_exact = callback;
                 return *this;
             }
-            ForEach&
+            template<typename U = TypeFilterImpl>
-            SetFilterRegexCallback (FilterContainer::RegexMatchForEachCallback callback)
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            SetWithRegex (FilterContainer::RegexMatchForEachCallback callback)
             {
                 m_filter_regex = callback;
                 return *this;
             }
 
 #ifndef LLDB_DISABLE_PYTHON
-            ForEach&
+            template<typename U = SyntheticChildren>
-            SetSynthExactCallback (SynthContainer::ExactMatchForEachCallback callback)
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            SetExact (SynthContainer::ExactMatchForEachCallback callback)
             {
                 m_synth_exact = callback;
                 return *this;
             }
-            ForEach&
+            template<typename U = SyntheticChildren>
-            SetSynthRegexCallback (SynthContainer::RegexMatchForEachCallback callback)
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            SetWithRegex (SynthContainer::RegexMatchForEachCallback callback)
             {
                 m_synth_regex = callback;
                 return *this;
             }
 #endif // LLDB_DISABLE_PYTHON
-
+            template<typename U = TypeValidatorImpl>
-            ForEach&
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
-            SetValidatorExactCallback (ValidatorContainer::ExactMatchForEachCallback callback)
+            SetExact (ValidatorContainer::ExactMatchForEachCallback callback)
             {
                 m_validator_exact = callback;
                 return *this;
             }
-            ForEach&
+            template<typename U = TypeValidatorImpl>
-            SetValidatorRegexCallback (ValidatorContainer::RegexMatchForEachCallback callback)
+            typename std::enable_if<std::is_same<U,T>::value, ForEachCallbacks&>::type
+            SetWithRegex (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());

lldb/include/lldb/DataFormatters/TypeCategoryMap.h

@@ -37,8 +37,6 @@ namespace lldb_private {
     public:
         typedef std::map<KeyType, ValueSP> MapType;
         typedef MapType::iterator MapIterator;
-        typedef bool(*CallbackType)(void*, const ValueSP&);
-        
         typedef std::function<bool(const ValueSP&)> ForEachCallback;
         
         typedef uint32_t Position;
@@ -87,9 +85,6 @@ namespace lldb_private {
         Get (uint32_t pos,
              ValueSP& entry);
         
-        void
-        LoopThrough (CallbackType callback, void* param);
-        
         void
         ForEach (ForEachCallback callback);
         

lldb/include/lldb/DataFormatters/TypeFormat.h

@@ -151,7 +151,6 @@ namespace lldb_private {
         TypeFormatImpl (const Flags& flags = Flags());
         
         typedef std::shared_ptr<TypeFormatImpl> SharedPointer;
-        typedef std::function<bool(void*, ConstString, lldb::TypeFormatImplSP)> ValueCallback;
         
         virtual ~TypeFormatImpl ();
         
@@ -259,7 +258,6 @@ namespace lldb_private {
                                const TypeFormatImpl::Flags& flags = Flags());
         
         typedef std::shared_ptr<TypeFormatImpl_Format> SharedPointer;
-        typedef std::function<bool(void*, ConstString, TypeFormatImpl_Format::SharedPointer)> ValueCallback;
         
         ~TypeFormatImpl_Format() override;
         
@@ -302,7 +300,6 @@ namespace lldb_private {
                                  const TypeFormatImpl::Flags& flags = Flags());
         
         typedef std::shared_ptr<TypeFormatImpl_EnumType> SharedPointer;
-        typedef std::function<bool(void*, ConstString, TypeFormatImpl_EnumType::SharedPointer)> ValueCallback;
         
         ~TypeFormatImpl_EnumType() override;
         

lldb/include/lldb/DataFormatters/TypeSummary.h

@@ -406,8 +406,6 @@ namespace lldb_private {
         }
         
         typedef std::shared_ptr<TypeSummaryImpl> SharedPointer;
-        typedef std::function<bool(void*, ConstString, TypeSummaryImpl::SharedPointer)> SummaryCallback;
-        typedef std::function<bool(void*, lldb::RegularExpressionSP, TypeSummaryImpl::SharedPointer)> RegexSummaryCallback;
         
     protected:
         uint32_t m_my_revision;

lldb/include/lldb/DataFormatters/TypeSynthetic.h

@@ -348,7 +348,6 @@ namespace lldb_private {
         GetFrontEnd (ValueObject &backend) = 0;
         
         typedef std::shared_ptr<SyntheticChildren> SharedPointer;
-        typedef std::function<bool(void*, ConstString, SyntheticChildren::SharedPointer)> SyntheticChildrenCallback;
         
         uint32_t&
         GetRevision ()
@@ -479,6 +478,8 @@ namespace lldb_private {
             return SyntheticChildrenFrontEnd::AutoPointer(new FrontEnd(this, backend));
         }
         
+        typedef std::shared_ptr<TypeFilterImpl> SharedPointer;
+        
     private:
         DISALLOW_COPY_AND_ASSIGN(TypeFilterImpl);
     };

lldb/include/lldb/DataFormatters/TypeValidator.h

@@ -150,7 +150,6 @@ public:
     TypeValidatorImpl (const Flags& flags = Flags());
     
     typedef std::shared_ptr<TypeValidatorImpl> SharedPointer;
-    typedef std::function<bool(void*, ConstString, TypeValidatorImpl::SharedPointer)> ValueCallback;
     
     virtual ~TypeValidatorImpl ();
     
@@ -265,7 +264,6 @@ public:
     TypeValidatorImpl_CXX (ValidatorFunction f, std::string d, const TypeValidatorImpl::Flags& flags = Flags());
     
     typedef std::shared_ptr<TypeValidatorImpl_CXX> SharedPointer;
-    typedef std::function<bool(void*, ConstString, TypeValidatorImpl_CXX::SharedPointer)> ValueCallback;
     
     ~TypeValidatorImpl_CXX() override;
     

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

lldb/source/DataFormatters/DataVisualization.cpp

@@ -225,12 +225,6 @@ DataVisualization::Categories::DisableStar ()
     GetFormatManager().DisableAllCategories();
 }
 
-void
-DataVisualization::Categories::LoopThrough (FormatManager::CategoryCallback callback, void* callback_baton)
-{
-    GetFormatManager().LoopThroughCategories(callback, callback_baton);
-}
-
 void
 DataVisualization::Categories::ForEach (TypeCategoryMap::ForEachCallback 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

lldb/source/DataFormatters/FormatManager.cpp

@@ -485,21 +485,6 @@ FormatManager::GetValidatorForType (lldb::TypeNameSpecifierImplSP type_sp)
     return validator_chosen_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)
 {

lldb/source/DataFormatters/TypeCategoryMap.cpp

@@ -372,39 +372,6 @@ TypeCategoryMap::GetValidator (FormattersMatchData& match_data)
     return lldb::TypeValidatorImplSP();
 }
 
-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)
 {