//===-- FormatCache.cpp ------------------------------------------*- C++
//-*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

// C Includes

// C++ Includes

// Other libraries and framework includes

// Project includes
#include "lldb/DataFormatters/FormatCache.h"

using namespace lldb;
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);
}

bool FormatCache::Entry::IsFormatCached() { return m_format_cached; }

bool FormatCache::Entry::IsSummaryCached() { return m_summary_cached; }

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

lldb::TypeSummaryImplSP FormatCache::Entry::GetSummary() {
  return m_summary_sp;
}

lldb::SyntheticChildrenSP FormatCache::Entry::GetSynthetic() {
  return m_synthetic_sp;
}

lldb::TypeValidatorImplSP FormatCache::Entry::GetValidator() {
  return m_validator_sp;
}

void FormatCache::Entry::SetFormat(lldb::TypeFormatImplSP format_sp) {
  m_format_cached = true;
  m_format_sp = format_sp;
}

void FormatCache::Entry::SetSummary(lldb::TypeSummaryImplSP summary_sp) {
  m_summary_cached = true;
  m_summary_sp = summary_sp;
}

void FormatCache::Entry::SetSynthetic(lldb::SyntheticChildrenSP synthetic_sp) {
  m_synthetic_cached = true;
  m_synthetic_sp = synthetic_sp;
}

void FormatCache::Entry::SetValidator(lldb::TypeValidatorImplSP validator_sp) {
  m_validator_cached = true;
  m_validator_sp = validator_sp;
}

FormatCache::FormatCache()
    : m_map(), m_mutex()
#ifdef LLDB_CONFIGURATION_DEBUG
      ,
      m_cache_hits(0), m_cache_misses(0)
#endif
{
}

FormatCache::Entry &FormatCache::GetEntry(const ConstString &type) {
  auto i = m_map.find(type), e = m_map.end();
  if (i != e)
    return i->second;
  m_map[type] = FormatCache::Entry();
  return m_map[type];
}

bool FormatCache::GetFormat(const 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;
}

bool FormatCache::GetSummary(const 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;
}

bool FormatCache::GetSynthetic(const 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;
}

bool FormatCache::GetValidator(const ConstString &type,
                               lldb::TypeValidatorImplSP &validator_sp) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  auto entry = GetEntry(type);
  if (entry.IsValidatorCached()) {
#ifdef LLDB_CONFIGURATION_DEBUG
    m_cache_hits++;
#endif
    validator_sp = entry.GetValidator();
    return true;
  }
#ifdef LLDB_CONFIGURATION_DEBUG
  m_cache_misses++;
#endif
  validator_sp.reset();
  return false;
}

void FormatCache::SetFormat(const ConstString &type,
                            lldb::TypeFormatImplSP &format_sp) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  GetEntry(type).SetFormat(format_sp);
}

void FormatCache::SetSummary(const ConstString &type,
                             lldb::TypeSummaryImplSP &summary_sp) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  GetEntry(type).SetSummary(summary_sp);
}

void FormatCache::SetSynthetic(const ConstString &type,
                               lldb::SyntheticChildrenSP &synthetic_sp) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  GetEntry(type).SetSynthetic(synthetic_sp);
}

void FormatCache::SetValidator(const ConstString &type,
                               lldb::TypeValidatorImplSP &validator_sp) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  GetEntry(type).SetValidator(validator_sp);
}

void FormatCache::Clear() {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  m_map.clear();
}