1 files changed, 53 insertions, 118 deletions

diff --git a/lldb/source/DataFormatters/FormatCache.cpp b/lldb/source/DataFormatters/FormatCache.cpp
index 7e328cb0dac..0876673cfa8 100644
--- a/lldb/source/DataFormatters/FormatCache.cpp
+++ b/lldb/source/DataFormatters/FormatCache.cpp
@@ -17,46 +17,7 @@ using namespace lldb_private;
 
 FormatCache::Entry::Entry()
     : m_format_cached(false), m_summary_cached(false),
-      m_synthetic_cached(false), m_validator_cached(false), m_format_sp(),
-      m_summary_sp(), m_synthetic_sp(), m_validator_sp() {}
-
-FormatCache::Entry::Entry(lldb::TypeFormatImplSP format_sp)
-    : m_summary_cached(false), m_synthetic_cached(false),
-      m_validator_cached(false), m_summary_sp(), m_synthetic_sp(),
-      m_validator_sp() {
-  SetFormat(format_sp);
-}
-
-FormatCache::Entry::Entry(lldb::TypeSummaryImplSP summary_sp)
-    : m_format_cached(false), m_synthetic_cached(false),
-      m_validator_cached(false), m_format_sp(), m_synthetic_sp(),
-      m_validator_sp() {
-  SetSummary(summary_sp);
-}
-
-FormatCache::Entry::Entry(lldb::SyntheticChildrenSP synthetic_sp)
-    : m_format_cached(false), m_summary_cached(false),
-      m_validator_cached(false), m_format_sp(), m_summary_sp(),
-      m_validator_sp() {
-  SetSynthetic(synthetic_sp);
-}
-
-FormatCache::Entry::Entry(lldb::TypeValidatorImplSP validator_sp)
-    : m_format_cached(false), m_summary_cached(false),
-      m_synthetic_cached(false), m_format_sp(), m_summary_sp(),
-      m_synthetic_sp() {
-  SetValidator(validator_sp);
-}
-
-FormatCache::Entry::Entry(lldb::TypeFormatImplSP format_sp,
-                          lldb::TypeSummaryImplSP summary_sp,
-                          lldb::SyntheticChildrenSP synthetic_sp,
-                          lldb::TypeValidatorImplSP validator_sp) {
-  SetFormat(format_sp);
-  SetSummary(summary_sp);
-  SetSynthetic(synthetic_sp);
-  SetValidator(validator_sp);
-}
+      m_synthetic_cached(false), m_validator_cached(false) {}
 
 bool FormatCache::Entry::IsFormatCached() { return m_format_cached; }
 
@@ -66,36 +27,38 @@ bool FormatCache::Entry::IsSyntheticCached() { return m_synthetic_cached; }
 
 bool FormatCache::Entry::IsValidatorCached() { return m_validator_cached; }
 
-lldb::TypeFormatImplSP FormatCache::Entry::GetFormat() { return m_format_sp; }
+void FormatCache::Entry::Get(lldb::TypeFormatImplSP &retval) {
+  retval = m_format_sp;
+}
 
-lldb::TypeSummaryImplSP FormatCache::Entry::GetSummary() {
-  return m_summary_sp;
+void FormatCache::Entry::Get(lldb::TypeSummaryImplSP &retval) {
+  retval = m_summary_sp;
 }
 
-lldb::SyntheticChildrenSP FormatCache::Entry::GetSynthetic() {
-  return m_synthetic_sp;
+void FormatCache::Entry::Get(lldb::SyntheticChildrenSP &retval) {
+  retval = m_synthetic_sp;
 }
 
-lldb::TypeValidatorImplSP FormatCache::Entry::GetValidator() {
-  return m_validator_sp;
+void FormatCache::Entry::Get(lldb::TypeValidatorImplSP &retval) {
+  retval = m_validator_sp;
 }
 
-void FormatCache::Entry::SetFormat(lldb::TypeFormatImplSP format_sp) {
+void FormatCache::Entry::Set(lldb::TypeFormatImplSP format_sp) {
   m_format_cached = true;
   m_format_sp = format_sp;
 }
 
-void FormatCache::Entry::SetSummary(lldb::TypeSummaryImplSP summary_sp) {
+void FormatCache::Entry::Set(lldb::TypeSummaryImplSP summary_sp) {
   m_summary_cached = true;
   m_summary_sp = summary_sp;
 }
 
-void FormatCache::Entry::SetSynthetic(lldb::SyntheticChildrenSP synthetic_sp) {
+void FormatCache::Entry::Set(lldb::SyntheticChildrenSP synthetic_sp) {
   m_synthetic_cached = true;
   m_synthetic_sp = synthetic_sp;
 }
 
-void FormatCache::Entry::SetValidator(lldb::TypeValidatorImplSP validator_sp) {
+void FormatCache::Entry::Set(lldb::TypeValidatorImplSP validator_sp) {
   m_validator_cached = true;
   m_validator_sp = validator_sp;
 }
@@ -117,100 +80,72 @@ FormatCache::Entry &FormatCache::GetEntry(ConstString type) {
   return m_map[type];
 }
 
-bool FormatCache::GetFormat(ConstString type,
-                            lldb::TypeFormatImplSP &format_sp) {
-  std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  auto entry = GetEntry(type);
-  if (entry.IsFormatCached()) {
-#ifdef LLDB_CONFIGURATION_DEBUG
-    m_cache_hits++;
-#endif
-    format_sp = entry.GetFormat();
-    return true;
-  }
-#ifdef LLDB_CONFIGURATION_DEBUG
-  m_cache_misses++;
-#endif
-  format_sp.reset();
-  return false;
+template<> bool FormatCache::Entry::IsCached<lldb::TypeFormatImplSP>() {
+  return IsFormatCached();
 }
-
-bool FormatCache::GetSummary(ConstString type,
-                             lldb::TypeSummaryImplSP &summary_sp) {
-  std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  auto entry = GetEntry(type);
-  if (entry.IsSummaryCached()) {
-#ifdef LLDB_CONFIGURATION_DEBUG
-    m_cache_hits++;
-#endif
-    summary_sp = entry.GetSummary();
-    return true;
-  }
-#ifdef LLDB_CONFIGURATION_DEBUG
-  m_cache_misses++;
-#endif
-  summary_sp.reset();
-  return false;
+template<> bool FormatCache::Entry::IsCached<lldb::TypeSummaryImplSP> () {
+  return IsSummaryCached();
 }
-
-bool FormatCache::GetSynthetic(ConstString type,
-                               lldb::SyntheticChildrenSP &synthetic_sp) {
-  std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  auto entry = GetEntry(type);
-  if (entry.IsSyntheticCached()) {
-#ifdef LLDB_CONFIGURATION_DEBUG
-    m_cache_hits++;
-#endif
-    synthetic_sp = entry.GetSynthetic();
-    return true;
-  }
-#ifdef LLDB_CONFIGURATION_DEBUG
-  m_cache_misses++;
-#endif
-  synthetic_sp.reset();
-  return false;
+template<> bool FormatCache::Entry::IsCached<lldb::SyntheticChildrenSP>() {
+  return IsSyntheticCached();
+}
+template<> bool FormatCache::Entry::IsCached<lldb::TypeValidatorImplSP>() {
+  return IsValidatorCached();
 }
 
-bool FormatCache::GetValidator(ConstString type,
-                               lldb::TypeValidatorImplSP &validator_sp) {
+template <typename ImplSP>
+bool FormatCache::Get(ConstString type, ImplSP &format_impl_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   auto entry = GetEntry(type);
-  if (entry.IsValidatorCached()) {
+  if (entry.IsCached<ImplSP>()) {
 #ifdef LLDB_CONFIGURATION_DEBUG
     m_cache_hits++;
 #endif
-    validator_sp = entry.GetValidator();
+    entry.Get(format_impl_sp);
     return true;
   }
 #ifdef LLDB_CONFIGURATION_DEBUG
   m_cache_misses++;
 #endif
-  validator_sp.reset();
+  format_impl_sp.reset();
   return false;
 }
 
-void FormatCache::SetFormat(ConstString type,
-                            lldb::TypeFormatImplSP &format_sp) {
+/// Explicit instantiations for the four types.
+/// \{
+template bool
+FormatCache::Get<lldb::TypeValidatorImplSP>(ConstString,
+                                            lldb::TypeValidatorImplSP &);
+template bool
+FormatCache::Get<lldb::TypeFormatImplSP>(ConstString, lldb::TypeFormatImplSP &);
+template bool
+FormatCache::Get<lldb::TypeSummaryImplSP>(ConstString,
+                                          lldb::TypeSummaryImplSP &);
+template bool
+FormatCache::Get<lldb::SyntheticChildrenSP>(ConstString,
+                                            lldb::SyntheticChildrenSP &);
+/// \}
+
+void FormatCache::Set(ConstString type, lldb::TypeFormatImplSP &format_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  GetEntry(type).SetFormat(format_sp);
+  GetEntry(type).Set(format_sp);
 }
 
-void FormatCache::SetSummary(ConstString type,
-                             lldb::TypeSummaryImplSP &summary_sp) {
+void FormatCache::Set(ConstString type, lldb::TypeSummaryImplSP &summary_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  GetEntry(type).SetSummary(summary_sp);
+  GetEntry(type).Set(summary_sp);
 }
 
-void FormatCache::SetSynthetic(ConstString type,
-                               lldb::SyntheticChildrenSP &synthetic_sp) {
+void FormatCache::Set(ConstString type,
+                      lldb::SyntheticChildrenSP &synthetic_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  GetEntry(type).SetSynthetic(synthetic_sp);
+  GetEntry(type).Set(synthetic_sp);
 }
 
-void FormatCache::SetValidator(ConstString type,
-                               lldb::TypeValidatorImplSP &validator_sp) {
+void FormatCache::Set(ConstString type,
+                      lldb::TypeValidatorImplSP &validator_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  GetEntry(type).SetValidator(validator_sp);
+  GetEntry(type).Set(validator_sp);
 }
 
 void FormatCache::Clear() {