1 //===-- TypeCategoryMap.cpp ----------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/lldb-python.h"
12 #include "lldb/DataFormatters/TypeCategoryMap.h"
14 #include "lldb/DataFormatters/FormatClasses.h"
15 #include "lldb/DataFormatters/FormatManager.h"
19 // Other libraries and framework includes
23 using namespace lldb_private;
25 TypeCategoryMap::TypeCategoryMap (IFormatChangeListener* lst) :
26 m_map_mutex(Mutex::eMutexTypeRecursive),
31 ConstString default_cs("default");
32 lldb::TypeCategoryImplSP default_sp = lldb::TypeCategoryImplSP(new TypeCategoryImpl(listener, default_cs));
33 Add(default_cs,default_sp);
34 Enable(default_cs,First);
38 TypeCategoryMap::Add (KeyType name, const ValueSP& entry)
40 Mutex::Locker locker(m_map_mutex);
47 TypeCategoryMap::Delete (KeyType name)
49 Mutex::Locker locker(m_map_mutex);
50 MapIterator iter = m_map.find(name);
51 if (iter == m_map.end())
61 TypeCategoryMap::Enable (KeyType category_name, Position pos)
63 Mutex::Locker locker(m_map_mutex);
65 if (!Get(category_name,category))
67 return Enable(category, pos);
71 TypeCategoryMap::Disable (KeyType category_name)
73 Mutex::Locker locker(m_map_mutex);
75 if (!Get(category_name,category))
77 return Disable(category);
81 TypeCategoryMap::Enable (ValueSP category, Position pos)
83 Mutex::Locker locker(m_map_mutex);
87 if (pos == First || m_active_categories.size() == 0)
88 m_active_categories.push_front(category);
89 else if (pos == Last || pos == m_active_categories.size())
90 m_active_categories.push_back(category);
91 else if (pos < m_active_categories.size())
93 ActiveCategoriesList::iterator iter = m_active_categories.begin();
98 m_active_categories.insert(iter,category);
102 category->Enable(true,
110 TypeCategoryMap::Disable (ValueSP category)
112 Mutex::Locker locker(m_map_mutex);
115 m_active_categories.remove_if(delete_matching_categories(category));
123 TypeCategoryMap::EnableAllCategories ()
125 Mutex::Locker locker(m_map_mutex);
126 std::vector<ValueSP> sorted_categories(m_map.size(), ValueSP());
127 MapType::iterator iter = m_map.begin(), end = m_map.end();
128 for (; iter != end; ++iter)
130 if (iter->second->IsEnabled())
132 auto pos = iter->second->GetLastEnabledPosition();
133 if (pos >= sorted_categories.size())
135 auto iter = std::find_if(sorted_categories.begin(),
136 sorted_categories.end(),
137 [] (const ValueSP& sp) -> bool {
138 return sp.get() == nullptr;
140 pos = std::distance(sorted_categories.begin(), iter);
142 sorted_categories.at(pos) = iter->second;
144 decltype(sorted_categories)::iterator viter = sorted_categories.begin(), vend = sorted_categories.end();
145 for (; viter != vend; viter++)
147 Enable(*viter, Last);
151 TypeCategoryMap::DisableAllCategories ()
153 Mutex::Locker locker(m_map_mutex);
155 for (; false == m_active_categories.empty(); p++)
157 m_active_categories.front()->SetEnabledPosition(p);
158 Disable(m_active_categories.front());
163 TypeCategoryMap::Clear ()
165 Mutex::Locker locker(m_map_mutex);
167 m_active_categories.clear();
173 TypeCategoryMap::Get (KeyType name, ValueSP& entry)
175 Mutex::Locker locker(m_map_mutex);
176 MapIterator iter = m_map.find(name);
177 if (iter == m_map.end())
179 entry = iter->second;
184 TypeCategoryMap::Get (uint32_t pos, ValueSP& entry)
186 Mutex::Locker locker(m_map_mutex);
187 MapIterator iter = m_map.begin();
188 MapIterator end = m_map.end();
196 entry = iter->second;
201 TypeCategoryMap::AnyMatches (ConstString type_name,
202 TypeCategoryImpl::FormatCategoryItems items,
204 const char** matching_category,
205 TypeCategoryImpl::FormatCategoryItems* matching_type)
207 Mutex::Locker locker(m_map_mutex);
209 MapIterator pos, end = m_map.end();
210 for (pos = m_map.begin(); pos != end; pos++)
212 if (pos->second->AnyMatches(type_name,
222 lldb::TypeFormatImplSP
223 TypeCategoryMap::GetFormat (ValueObject& valobj,
224 lldb::DynamicValueType use_dynamic)
226 Mutex::Locker locker(m_map_mutex);
229 ActiveCategoriesIterator begin, end = m_active_categories.end();
231 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
233 FormattersMatchVector matches = FormatManager::GetPossibleMatches(valobj, use_dynamic);
235 for (begin = m_active_categories.begin(); begin != end; begin++)
237 lldb::TypeCategoryImplSP category_sp = *begin;
238 lldb::TypeFormatImplSP current_format;
240 log->Printf("\n[TypeCategoryMap::GetFormat] Trying to use category %s", category_sp->GetName());
241 if (!category_sp->Get(valobj, matches, current_format, &reason_why))
243 return current_format;
246 log->Printf("[TypeCategoryMap::GetFormat] nothing found - returning empty SP");
247 return lldb::TypeFormatImplSP();
250 lldb::TypeSummaryImplSP
251 TypeCategoryMap::GetSummaryFormat (ValueObject& valobj,
252 lldb::DynamicValueType use_dynamic)
254 Mutex::Locker locker(m_map_mutex);
257 ActiveCategoriesIterator begin, end = m_active_categories.end();
259 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
261 FormattersMatchVector matches = FormatManager::GetPossibleMatches(valobj, use_dynamic);
263 for (begin = m_active_categories.begin(); begin != end; begin++)
265 lldb::TypeCategoryImplSP category_sp = *begin;
266 lldb::TypeSummaryImplSP current_format;
268 log->Printf("\n[CategoryMap::GetSummaryFormat] Trying to use category %s", category_sp->GetName());
269 if (!category_sp->Get(valobj, matches, current_format, &reason_why))
271 return current_format;
274 log->Printf("[CategoryMap::GetSummaryFormat] nothing found - returning empty SP");
275 return lldb::TypeSummaryImplSP();
278 #ifndef LLDB_DISABLE_PYTHON
279 lldb::SyntheticChildrenSP
280 TypeCategoryMap::GetSyntheticChildren (ValueObject& valobj,
281 lldb::DynamicValueType use_dynamic)
283 Mutex::Locker locker(m_map_mutex);
287 ActiveCategoriesIterator begin, end = m_active_categories.end();
289 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
291 FormattersMatchVector matches = FormatManager::GetPossibleMatches(valobj, use_dynamic);
293 for (begin = m_active_categories.begin(); begin != end; begin++)
295 lldb::TypeCategoryImplSP category_sp = *begin;
296 lldb::SyntheticChildrenSP current_format;
298 log->Printf("\n[CategoryMap::GetSyntheticChildren] Trying to use category %s", category_sp->GetName());
299 if (!category_sp->Get(valobj, matches, current_format, &reason_why))
301 return current_format;
304 log->Printf("[CategoryMap::GetSyntheticChildren] nothing found - returning empty SP");
305 return lldb::SyntheticChildrenSP();
309 lldb::TypeValidatorImplSP
310 TypeCategoryMap::GetValidator (ValueObject& valobj,
311 lldb::DynamicValueType use_dynamic)
313 Mutex::Locker locker(m_map_mutex);
316 ActiveCategoriesIterator begin, end = m_active_categories.end();
318 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
320 FormattersMatchVector matches = FormatManager::GetPossibleMatches(valobj, use_dynamic);
322 for (begin = m_active_categories.begin(); begin != end; begin++)
324 lldb::TypeCategoryImplSP category_sp = *begin;
325 lldb::TypeValidatorImplSP current_format;
327 log->Printf("\n[CategoryMap::GetValidator] Trying to use category %s", category_sp->GetName());
328 if (!category_sp->Get(valobj, matches, current_format, &reason_why))
330 return current_format;
333 log->Printf("[CategoryMap::GetValidator] nothing found - returning empty SP");
334 return lldb::TypeValidatorImplSP();
338 TypeCategoryMap::LoopThrough(CallbackType callback, void* param)
342 Mutex::Locker locker(m_map_mutex);
344 // loop through enabled categories in respective order
346 ActiveCategoriesIterator begin, end = m_active_categories.end();
347 for (begin = m_active_categories.begin(); begin != end; begin++)
349 lldb::TypeCategoryImplSP category = *begin;
350 ConstString type = ConstString(category->GetName());
351 if (!callback(param, category))
356 // loop through disabled categories in just any order
358 MapIterator pos, end = m_map.end();
359 for (pos = m_map.begin(); pos != end; pos++)
361 if (pos->second->IsEnabled())
363 KeyType type = pos->first;
364 if (!callback(param, pos->second))
372 TypeCategoryMap::GetAtIndex (uint32_t index)
374 Mutex::Locker locker(m_map_mutex);
376 if (index < m_map.size())
378 MapIterator pos, end = m_map.end();
379 for (pos = m_map.begin(); pos != end; pos++)
387 return TypeCategoryImplSP();