//===-- 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();
}