windows-server-2003/admin/pchealth/helpctr/service/database/cache.cpp

/******************************************************************************

Copyright (c) 1999-2000 Microsoft Corporation

Module Name:
    Cache.cpp

Abstract:
    Handles caching of database lookups.

Revision History:

******************************************************************************/

#include "stdafx.h"

////////////////////////////////////////////////////////////////////////////////

static const DWORD l_dwVersion           = 0x01314351; // QC1 01
static const DWORD l_dwSizeThresholdHIGH = 2048*1024;
static const DWORD l_dwSizeThresholdLOW  = 1024*1024;

static const DATE  l_dSaveThreshold      = (60.0/86400.0); // 60 seconds.

static const WCHAR l_szBase  [] = HC_ROOT_HELPSVC_CONFIG L"\\Cache";
static const WCHAR l_szIndex [] = L"Directory.bin";
static const WCHAR l_szQuery [] = L"Query_%08x.bin";
static const WCHAR l_szBackup[] = L".bak";

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

HRESULT Taxonomy::operator>>( /*[in]*/ MPC::Serializer& stream, /*[out]*/ Taxonomy::Cache::NodeEntry& val )
{
    __HCP_FUNC_ENTRY( "Taxonomy::operator>> Taxonomy::Cache::NodeEntry" );

    HRESULT hr;


    __MPC_EXIT_IF_METHOD_FAILS(hr, stream >> val.m_rs_data );


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::operator<<( /*[in]*/ MPC::Serializer& stream, /*[in] */ const Taxonomy::Cache::NodeEntry& val )
{
    __HCP_FUNC_ENTRY( "Taxonomy::operator<< Taxonomy::Cache::NodeEntry" );

    HRESULT hr;


    __MPC_EXIT_IF_METHOD_FAILS(hr, stream << val.m_rs_data );


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

Taxonomy::Cache::NodeEntry::NodeEntry()
{
    m_rs_data.m_ID_parent = -1;
    m_rs_data.m_ID_node   = -1;
}


bool Taxonomy::Cache::NodeEntry::operator<( /*[in]*/ NodeEntry const &en ) const
{
    long lCmp = (m_rs_data.m_ID_parent - en.m_rs_data.m_ID_parent);

    if(lCmp == 0)
    {
        lCmp = MPC::StrICmp( m_rs_data.m_strEntry, en.m_rs_data.m_strEntry );
    }

    return (lCmp < 0);
}

bool Taxonomy::Cache::NodeEntry::operator==( /*[in]*/ long ID ) const
{
    return m_rs_data.m_ID_node == ID;
}


Taxonomy::Cache::NodeEntry::MatchNode::MatchNode( /*[in]*/ long ID )
{
    m_ID = ID; // long m_ID;
}

bool Taxonomy::Cache::NodeEntry::MatchNode::operator()( /*[in]*/ Taxonomy::Cache::NodeEntry const &en ) const
{
    return en == m_ID;
}

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

HRESULT Taxonomy::operator>>( /*[in]*/ MPC::Serializer& stream, /*[out]*/ Taxonomy::Cache::QueryEntry& val )
{
    __HCP_FUNC_ENTRY( "Taxonomy::operator>> Taxonomy::Cache::QueryEntry" );

    HRESULT hr;


    __MPC_EXIT_IF_METHOD_FAILS(hr, stream >> val.m_strID     );
    __MPC_EXIT_IF_METHOD_FAILS(hr, stream >> val.m_iType     );
    __MPC_EXIT_IF_METHOD_FAILS(hr, stream >> val.m_iSequence );
    __MPC_EXIT_IF_METHOD_FAILS(hr, stream >> val.m_fNull     );

    __MPC_EXIT_IF_METHOD_FAILS(hr, stream >> val.m_dwSize    );
    __MPC_EXIT_IF_METHOD_FAILS(hr, stream >> val.m_dLastUsed );

    val.m_fRemoved = false;


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::operator<<( /*[in]*/ MPC::Serializer& stream, /*[in] */ const Taxonomy::Cache::QueryEntry& val )
{
    __HCP_FUNC_ENTRY( "Taxonomy::operator<< Taxonomy::Cache::QueryEntry" );

    HRESULT hr;


    __MPC_EXIT_IF_METHOD_FAILS(hr, stream << val.m_strID     );
    __MPC_EXIT_IF_METHOD_FAILS(hr, stream << val.m_iType     );
    __MPC_EXIT_IF_METHOD_FAILS(hr, stream << val.m_iSequence );
    __MPC_EXIT_IF_METHOD_FAILS(hr, stream << val.m_fNull     );

    __MPC_EXIT_IF_METHOD_FAILS(hr, stream << val.m_dwSize    );
    __MPC_EXIT_IF_METHOD_FAILS(hr, stream << val.m_dLastUsed );


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

Taxonomy::Cache::QueryEntry::QueryEntry()
{
                                           // MPC::wstring m_strID;
   m_iType     = OfflineCache::ET_INVALID; // int          m_iType;
   m_iSequence = 0;                        // int          m_iSequence;
   m_fNull     = true;                     // bool         m_fNull;
                                           //
   m_dwSize    = 0;                        // DWORD        m_dwSize;
   m_dLastUsed = 0;                        // DATE         m_dLastUsed;
   m_fRemoved  = true;                     // bool         m_fRemoved;
}


bool Taxonomy::Cache::QueryEntry::operator<( /*[in]*/ QueryEntry const &en ) const
{
    int iCmp = MPC::StrCmp( m_strID, en.m_strID );

    if(iCmp == 0)
    {
        iCmp = (m_iType - en.m_iType);
    }

    return (iCmp < 0);
}

////////////////////////////////////////

void Taxonomy::Cache::QueryEntry::Touch()
{
    m_dLastUsed = MPC::GetLocalTime();
    m_fRemoved  = false;
}

HRESULT Taxonomy::Cache::QueryEntry::GetFile( /*[out]*/ MPC::wstring& strFile )
{
    WCHAR rgTmp[64]; swprintf( rgTmp, l_szQuery, m_iSequence );

    strFile = rgTmp;

    return S_OK;
}

////////////////////////////////////////

HRESULT Taxonomy::Cache::QueryEntry::Store( /*[in]*/ MPC::StorageObject&              disk  ,
                                            /*[in]*/ const CPCHQueryResultCollection* pColl )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::QueryEntry::Store" );

    HRESULT             hr;
    MPC::StorageObject* child;
    MPC::wstring        strFile;


    __MPC_EXIT_IF_METHOD_FAILS(hr, GetFile( strFile ));


    m_fNull = (pColl->Size() == 0);

    __MPC_EXIT_IF_METHOD_FAILS(hr, disk.GetChild( strFile.c_str(), child, STGM_READWRITE, (m_fNull == false) ? STGTY_STREAM : 0 ));
    if(m_fNull == false)
    {
        if(child)
        {
            CComPtr<IStream> stream;

            __MPC_EXIT_IF_METHOD_FAILS(hr, child->GetStream( stream ));
            if(stream)
            {
                STATSTG statstg;

                __MPC_EXIT_IF_METHOD_FAILS(hr, pColl->SaveToCache( stream ));

                __MPC_EXIT_IF_METHOD_FAILS(hr, stream->Stat( &statstg, STATFLAG_NONAME ));
                m_dwSize = statstg.cbSize.LowPart;
            }
        }
    }
    else
    {
        if(child)
        {
            __MPC_EXIT_IF_METHOD_FAILS(hr, child->Delete());
        }
    }

    Touch();
    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::QueryEntry::Retrieve( /*[in]*/ MPC::StorageObject&        disk  ,
                                               /*[in]*/ CPCHQueryResultCollection* pColl )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::QueryEntry::Retrieve" );

    HRESULT hr;


    if(m_fNull == false)
    {
        MPC::StorageObject* child;
        MPC::wstring        strFile;


        __MPC_EXIT_IF_METHOD_FAILS(hr, GetFile( strFile ));

        __MPC_EXIT_IF_METHOD_FAILS(hr, disk.GetChild( strFile.c_str(), child, STGM_READWRITE, 0 ));
        if(child)
        {
            CComPtr<IStream> stream;

            __MPC_EXIT_IF_METHOD_FAILS(hr, child->GetStream( stream ));
            if(stream)
            {
                __MPC_EXIT_IF_METHOD_FAILS(hr, pColl->LoadFromCache( stream ));
            }
        }
    }

    Touch();
    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::QueryEntry::Release( /*[in]*/ MPC::StorageObject& disk )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::QueryEntry::Release" );

    HRESULT hr;


    if(m_fNull == false)
    {
        MPC::StorageObject* child;
        MPC::wstring        strFile;


        __MPC_EXIT_IF_METHOD_FAILS(hr, GetFile( strFile ));

        __MPC_EXIT_IF_METHOD_FAILS(hr, disk.GetChild( strFile.c_str(), child, STGM_READWRITE, 0 ));
        if(child)
        {
            __MPC_EXIT_IF_METHOD_FAILS(hr, child->Delete());
        }
    }

    m_fRemoved = true;
    hr         = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

bool Taxonomy::Cache::SortEntries::operator()( /*[in]*/ QueryEntry* const &left, /*[in]*/ QueryEntry* const &right ) const
{
    return (left->m_dLastUsed < right->m_dLastUsed);
}

////////////////////////////////////////////////////////////////////////////////

//
// ITSS.DLL is broken under IA64....
//
#ifdef _IA64_
#define CACHEDHELPSET_STORAGETOUSE false
#else
#define CACHEDHELPSET_STORAGETOUSE true
#endif

Taxonomy::Cache::CachedHelpSet::CachedHelpSet() : m_disk( STGM_READWRITE, /*fITSS*/CACHEDHELPSET_STORAGETOUSE )
{
    Init();
}


Taxonomy::Cache::CachedHelpSet::~CachedHelpSet()
{
    if(m_fDirty)
    {
        (void)EnsureInSync( true );
    }

    //
    // Copy working file as the backup.
    //
    if(m_fLoaded)
    {
        MPC::wstring strFileBack = m_strFile; strFileBack += l_szBackup;

        if(SUCCEEDED(m_disk.Compact()))
        {
            (void)MPC::MoveFile( m_strFile, strFileBack );
        }
    }
}

Taxonomy::Cache::CachedHelpSet::CachedHelpSet( /*[in]*/ const CachedHelpSet& chs ) : m_disk( STGM_READWRITE, /*fITSS*/CACHEDHELPSET_STORAGETOUSE )
{
    Init();

    m_ths     = chs.m_ths;     // Taxonomy::HelpSet  m_ths;
    m_strFile = chs.m_strFile; // MPC::wstring       m_strFile;
                               // MPC::StorageObject m_disk;
                               //
                               // bool               m_fLoaded;
                               // bool               m_fDirty;
                               // bool               m_fMarkedForLoad;
                               // DATE               m_dLastSaved;
                               // long               m_lTopNode;
                               // NodeEntrySet       m_setNodes;
                               // QueryEntrySet      m_setQueries;
                               // int                m_iLastSequence;
}

Taxonomy::Cache::CachedHelpSet& Taxonomy::Cache::CachedHelpSet::operator=( /*[in]*/ const CachedHelpSet& chs )
{
    Clean();

    m_ths     = chs.m_ths;     // Taxonomy::HelpSet  m_ths;
    m_strFile = chs.m_strFile; // MPC::wstring       m_strFile;
                               // MPC::StorageObject m_disk;
                               //
                               // bool               m_fLoaded;
                               // bool               m_fDirty;
                               // bool               m_fMarkedForLoad;
                               // DATE               m_dLastSaved;
                               // long               m_lTopNode;
                               // NodeEntrySet       m_setNodes;
                               // QueryEntrySet      m_setQueries;
                               // int                m_iLastSequence;

    return *this;
}

bool Taxonomy::Cache::CachedHelpSet::operator<( /*[in]*/ CachedHelpSet const &hs ) const
{
    return m_ths < hs.m_ths;
}

////////////////////////////////////////////////////////////////////////////////

void Taxonomy::Cache::CachedHelpSet::Init()
{
                              // Taxonomy::HelpSet  m_ths;
                              // MPC::wstring       m_strFile;
                              // MPC::StorageObject m_disk;
                              //
    m_fLoaded        = false; // bool               m_fLoaded;
    m_fDirty         = false; // bool               m_fDirty;
    m_fMarkedForLoad = false; // bool               m_fMarkedForLoad;
    m_dLastSaved     = 0;     // DATE               m_dLastSaved;
    m_lTopNode       = -1;    // long               m_lTopNode;
                              // NodeEntrySet       m_setNodes;
                              // QueryEntrySet      m_setQueries;
    m_iLastSequence  = 1;     // int                m_iLastSequence;
}

void Taxonomy::Cache::CachedHelpSet::Clean()
{
                              // Taxonomy::HelpSet  m_ths;
                              // MPC::wstring       m_strFile;
    m_disk.Release();         // MPC::StorageObject m_disk;
                              //
    m_fLoaded       = false;  // bool               m_fLoaded;
    m_fDirty        = false;  // bool               m_fDirty;
                              // DATE               m_dLastSaved;
    m_lTopNode      = -1;     // long               m_lTopNode;
    m_setNodes      .clear(); // NodeEntrySet       m_setNodes;
    m_setQueries    .clear(); // QueryEntrySet      m_setQueries;
    m_iLastSequence = 1;      // int                m_iLastSequence;
}

HRESULT Taxonomy::Cache::CachedHelpSet::Load()
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::CachedHelpSet::Load" );

    HRESULT             hr;
    MPC::StorageObject* child;


    Clean();


    DEBUG_AppendPerf( DEBUG_PERF_CACHE_L1, "Loading Taxonomy Cache" );


    //
    // Copy the backup on top of the working file.
    //
    {
        MPC::wstring strFileBack = m_strFile; strFileBack += l_szBackup;

        (void)MPC::DeleteFile(              m_strFile );
        (void)MPC::CopyFile  ( strFileBack, m_strFile );
    }


    if(FAILED(m_disk.Exists()))
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_disk.Create());
    }

    __MPC_EXIT_IF_METHOD_FAILS(hr, m_disk.GetChild( l_szIndex, child, STGM_READWRITE, 0 ));
    if(child)
    {
        CComPtr<IStream> stream;

        __MPC_EXIT_IF_METHOD_FAILS(hr, child->GetStream( stream ));
        if(stream)
        {
            MPC::Serializer_IStream   streamReal( stream     );
            MPC::Serializer_Buffering streamBuf ( streamReal );
            DWORD                     dwVer;

            __MPC_EXIT_IF_METHOD_FAILS(hr, streamBuf >> dwVer          ); if(dwVer != l_dwVersion) __MPC_SET_ERROR_AND_EXIT(hr, E_FAIL);
            __MPC_EXIT_IF_METHOD_FAILS(hr, streamBuf >> m_iLastSequence);
            __MPC_EXIT_IF_METHOD_FAILS(hr, streamBuf >> m_lTopNode     );
            DEBUG_AppendPerf( DEBUG_PERF_CACHE_L1, "Loading Taxonomy Cache : nodes" );
            __MPC_EXIT_IF_METHOD_FAILS(hr, streamBuf >> m_setNodes     );
            DEBUG_AppendPerf( DEBUG_PERF_CACHE_L1, "Loading Taxonomy Cache : queries" );
            __MPC_EXIT_IF_METHOD_FAILS(hr, streamBuf >> m_setQueries   );
        }
    }
    DEBUG_AppendPerf( DEBUG_PERF_CACHE_L1, "Loaded Taxonomy Cache" );


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    if(FAILED(hr)) Clean();

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::CachedHelpSet::Save()
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::CachedHelpSet::Save" );

    HRESULT             hr;
    MPC::StorageObject* child;


    if(FAILED(m_disk.Exists()))
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_disk.Create());
    }

    __MPC_EXIT_IF_METHOD_FAILS(hr, m_disk.GetChild( l_szIndex, child, STGM_READWRITE, STGTY_STREAM ));
    if(child)
    {
        CComPtr<IStream> stream;

        __MPC_EXIT_IF_METHOD_FAILS(hr, child->GetStream( stream ));
        if(stream)
        {
            MPC::Serializer_IStream   streamReal( stream     );
            MPC::Serializer_Buffering streamBuf ( streamReal );

            __MPC_EXIT_IF_METHOD_FAILS(hr, streamBuf << l_dwVersion    );
            __MPC_EXIT_IF_METHOD_FAILS(hr, streamBuf << m_iLastSequence);
            __MPC_EXIT_IF_METHOD_FAILS(hr, streamBuf << m_lTopNode     );
            __MPC_EXIT_IF_METHOD_FAILS(hr, streamBuf << m_setNodes     );
            __MPC_EXIT_IF_METHOD_FAILS(hr, streamBuf << m_setQueries   );

            __MPC_EXIT_IF_METHOD_FAILS(hr, streamBuf.Flush());
        }
    }

#if 0
    ////////////////////////////////////////////////////////////////////////////////
    //
    // DEBUG CODE
    //
    {
        USES_CONVERSION;

        HHK::Writer     writer;
        CHAR            rgBuf[1024];
        QueryEntryIter  it;
        SortEntries     Pr;
        SortedEntryVec  vec;
        SortedEntryIter it2;

        strFile += L".debug";

        __MPC_EXIT_IF_METHOD_FAILS(hr, writer.Init( strFile.c_str() ));

        for(it = m_setQueries.begin(); it != m_setQueries.end(); it++)
        {
            vec.push_back( &(*it) );
        }

        std::sort( vec.begin(), vec.end(), Pr );

        for(it2 = vec.begin(); it2 != vec.end(); it2++)
        {
            QueryEntry* en = *it2;

            sprintf( rgBuf, "%80s: %1d %3d %5d %1d %5.12g\n",
                     W2A( en->m_strID.c_str() ),
                          en->m_iType          ,
                          en->m_iSequence      ,
                     (int)en->m_dwSize         ,
                     (int)en->m_fRemoved       ,
                          en->m_dLastUsed      );

            __MPC_EXIT_IF_METHOD_FAILS(hr, writer.OutputLine( rgBuf ));
        }
    }
    //
    // DEBUG CODE
    //
    ////////////////////////////////////////////////////////////////////////////////
#endif

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::CachedHelpSet::EnsureInSync( /*[in]*/ bool fForceSave )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::CachedHelpSet::EnsureInSync" );

    HRESULT hr;


    if(m_fLoaded == false)
    {
        m_fDirty = false;
        m_disk   = m_strFile.c_str();

        __MPC_EXIT_IF_METHOD_FAILS(hr, Load());

        m_dLastSaved = MPC::GetSystemTime();
        m_fLoaded    = true;
    }

    if(m_fDirty)
    {
        DATE dNow = MPC::GetSystemTime();

        if(fForceSave == false)
        {
            if(dNow - m_dLastSaved > l_dSaveThreshold)
            {
                fForceSave = true;
            }
        }

        if(fForceSave)
        {
            __MPC_EXIT_IF_METHOD_FAILS(hr, Save());

            m_dLastSaved = dNow;
            m_fDirty     = false;
        }
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

////////////////////

HRESULT Taxonomy::Cache::CachedHelpSet::GenerateDefaultQueries( /*[in]*/ Taxonomy::Settings& ts      ,
                                                                /*[in]*/ Taxonomy::Updater&  updater ,
                                                                /*[in]*/ long                ID      ,
                                                                /*[in]*/ long                lLevel  )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::CachedHelpSet::GenerateDefaultQueries" );

    HRESULT                            hr;
    CComPtr<CPCHQueryResultCollection> coll;
    MPC::wstring                       strPath;


    __MPC_EXIT_IF_METHOD_FAILS(hr, MPC::CreateInstance( &coll ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, BuildNodePath( ID, strPath, /*fParent*/false ));

    //
    // Build the queries.
    //
    __MPC_EXIT_IF_METHOD_FAILS(hr, updater.LookupNode          ( strPath.c_str(),                       coll )); coll->Erase();
    __MPC_EXIT_IF_METHOD_FAILS(hr, updater.LookupSubNodes      ( strPath.c_str(), /*fVisibleOnly*/true, coll )); coll->Erase();
    __MPC_EXIT_IF_METHOD_FAILS(hr, updater.LookupNodesAndTopics( strPath.c_str(), /*fVisibleOnly*/true, coll )); coll->Erase();
    __MPC_EXIT_IF_METHOD_FAILS(hr, updater.LookupTopics        ( strPath.c_str(), /*fVisibleOnly*/true, coll )); coll->Erase();


    //
    // Recurse for sub-levels.
    //
    if(lLevel++ < 3)
    {
        MatchSet  res;
        MatchIter it;

        __MPC_EXIT_IF_METHOD_FAILS(hr, LocateSubNodes( ID, /*fRecurse*/false, /*fOnlyVisible*/true, res ));

        for(it=res.begin(); it!=res.end(); it++)
        {
            __MPC_EXIT_IF_METHOD_FAILS(hr, GenerateDefaultQueries( ts, updater, *it, lLevel ));
        }
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::CachedHelpSet::GenerateDefaultQueries( /*[in]*/ Taxonomy::Settings& ts      ,
                                                                /*[in]*/ Taxonomy::Updater&  updater )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::CachedHelpSet::GenerateDefaultQueries" );

    HRESULT        hr;
    static  WCHAR* c_rgNodes[] = { L"", L"_SYSTEM_", L"UNMAPPED" };

    for(int i=0; i<ARRAYSIZE(c_rgNodes); i++)
    {
        long                   id  = m_lTopNode;
        MPC::WStringVector     vec;
        MPC::WStringVectorIter it;
        NodeEntryIter          it2;

        __MPC_EXIT_IF_METHOD_FAILS(hr, MPC::SplitAtDelimiter( vec, c_rgNodes[i], L"/" ));

        for(it = vec.begin(); it != vec.end(); it++)
        {
            if(!LocateNode( id, it->c_str(), it2 )) break;

            id = it2->m_rs_data.m_ID_node;
        }

        if(it == vec.end())
        {
            __MPC_EXIT_IF_METHOD_FAILS(hr, GenerateDefaultQueries( ts, updater, id, 0 ));
        }
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}



HRESULT Taxonomy::Cache::CachedHelpSet::PrePopulate( /*[in]*/ Cache* parent )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::CachedHelpSet::PrePopulate" );

    HRESULT hr;


    __MPC_EXIT_IF_METHOD_FAILS(hr, EnsureInSync());

    //
    // This opens the database, walks through all the nodes in the taxonomy and makes a copy in the cache.
    //
    DEBUG_AppendPerf( DEBUG_PERF_CACHE_L1, "PrePopulating Taxonomy Cache" );
    {
        Taxonomy::Settings     ts( m_ths );
        JetBlue::SessionHandle handle;
        JetBlue::Database*     db;
        Taxonomy::Updater      updater;
        Taxonomy::RS_Taxonomy* rs;
        bool                   fFound;


        __MPC_EXIT_IF_METHOD_FAILS(hr, ts.GetDatabase( handle, db, /*fReadOnly*/true ));
        __MPC_EXIT_IF_METHOD_FAILS(hr, updater.Init  ( ts,     db, parent            ));


        __MPC_EXIT_IF_METHOD_FAILS(hr, updater.GetTaxonomy( &rs ));

        m_lTopNode = -1;
        m_setNodes.clear();
        __MPC_EXIT_IF_METHOD_FAILS(hr, rs->Move( 0, JET_MoveFirst, &fFound ));
        while(fFound)
        {
            NodeEntry en;

            en.m_rs_data = *rs;
            if(!en.m_rs_data.m_fValid__ID_parent)
            {
                en.m_rs_data.m_ID_parent = -1;

                m_lTopNode = en.m_rs_data.m_ID_node;
            }

            m_setNodes.insert( en );

            __MPC_EXIT_IF_METHOD_FAILS(hr, rs->Move( 0, JET_MoveNext, &fFound ));
        }

        m_fDirty = true;
        __MPC_EXIT_IF_METHOD_FAILS(hr, EnsureInSync( true ));

        DEBUG_AppendPerf( DEBUG_PERF_CACHE_L1, "PrePopulating Taxonomy Cache : Nodes done" );

        //
        // Walk through the first 3 level of nodes and pre-generate the queries.
        //
        // We disable offline flushing of the root index, because it gets changed too often...
        //
        __MPC_EXIT_IF_METHOD_FAILS(hr, OfflineCache::Root::s_GLOBAL->DisableSave(             ));
        __MPC_EXIT_IF_METHOD_FAILS(hr, GenerateDefaultQueries                   ( ts, updater ));
        __MPC_EXIT_IF_METHOD_FAILS(hr, EnsureInSync                             ( true        ));
        __MPC_EXIT_IF_METHOD_FAILS(hr, OfflineCache::Root::s_GLOBAL->EnableSave (             ));
    }
    DEBUG_AppendPerf( DEBUG_PERF_CACHE_L1, "PrePopulated Taxonomy Cache : Nodes done" );

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::CachedHelpSet::Erase()
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::CachedHelpSet::Erase" );

    HRESULT hr;

    Clean();

    {
        MPC::wstring strFileBack = m_strFile; strFileBack += l_szBackup;

		(void)MPC::DeleteFile( m_strFile  , /*fForce*/true, /*fDelayed*/false );
        (void)MPC::DeleteFile( strFileBack, /*fForce*/true, /*fDelayed*/false );
    }


    //
    // Propagate change to the offline cache.
    //
    {
        OfflineCache::Handle handle;

        if(SUCCEEDED(OfflineCache::Root::s_GLOBAL->Locate( m_ths, handle )))
        {
            if(SUCCEEDED(handle->RemoveQueries()))
            {
                (void)OfflineCache::Root::s_GLOBAL->Flush();
            }
        }
    }


    hr = S_OK;


    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::CachedHelpSet::PrepareToLoad()
{
    m_fMarkedForLoad = true;

    return S_OK;
}

HRESULT Taxonomy::Cache::CachedHelpSet::LoadIfMarked()
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::CachedHelpSet::LoadIfMarked" );

    HRESULT hr;


    if(m_fMarkedForLoad)
    {
        m_fMarkedForLoad = false;

        __MPC_EXIT_IF_METHOD_FAILS(hr, EnsureInSync());

        //
        // Load the JetBlue database.
        //
        {
            Taxonomy::Settings     ts( m_ths );
            JetBlue::SessionHandle handle;
            JetBlue::Database*     db;

            __MPC_EXIT_IF_METHOD_FAILS(hr, ts.GetDatabase( handle, db, /*fReadOnly*/true ));
        }
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}


HRESULT Taxonomy::Cache::CachedHelpSet::MRU()
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::CachedHelpSet::MRU" );

    HRESULT        hr;
    QueryEntryIter it;
    DWORD          dwSizeTot = 0;


    //
    // Get total cache size.
    //
    for(it = m_setQueries.begin(); it != m_setQueries.end(); it++)
    {
        if(it->m_fRemoved == false)
        {
            dwSizeTot += it->m_dwSize;
        }
    }

    //
    // If the total size of the cache is bigger than a certain value, start to purge from the least used query.
    //
    if(dwSizeTot > l_dwSizeThresholdHIGH)
    {
        SortEntries     Pr;
        SortedEntryVec  vec;
        SortedEntryIter it2;

        for(it = m_setQueries.begin(); it != m_setQueries.end(); it++)
        {
            if(it->m_fRemoved == false)
            {
                vec.push_back( &(*it) );
            }
        }

        std::sort( vec.begin(), vec.end(), Pr );

        for(it2 = vec.begin(); it2 != vec.end(); it2++)
        {
            QueryEntry* en = *it2;

            __MPC_EXIT_IF_METHOD_FAILS(hr, en->Release( m_disk ));

            m_fDirty   = true;
            dwSizeTot -= en->m_dwSize;

            if(dwSizeTot < l_dwSizeThresholdLOW) break;
        }

    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

////////////////////

bool Taxonomy::Cache::CachedHelpSet::LocateNode( /*[in] */ long           ID_parent ,
                                                 /*[in] */ LPCWSTR        szEntry   ,
                                                 /*[out]*/ NodeEntryIter& it        )
{
    NodeEntry en;

    en.m_rs_data.m_ID_parent =          ID_parent;
    en.m_rs_data.m_strEntry  = SAFEWSTR(szEntry);

    it = m_setNodes.find( en );
    return (it != m_setNodes.end());
}

HRESULT Taxonomy::Cache::CachedHelpSet::LocateNode( /*[in] */ long              ID_parent ,
                                                    /*[in] */ LPCWSTR           szEntry   ,
                                                    /*[out]*/ RS_Data_Taxonomy& rs_data   )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::CachedHelpSet::LocateNode" );

    HRESULT       hr;
    NodeEntryIter it;


    rs_data.m_ID_node = -1;


    __MPC_EXIT_IF_METHOD_FAILS(hr, EnsureInSync());


    if(LocateNode( ID_parent, szEntry, it ) == false)
    {
        __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_FILE_NOT_FOUND);
    }

    rs_data = it->m_rs_data;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::CachedHelpSet::LocateSubNodes( /*[in] */ long      ID_node      ,
                                                        /*[in] */ bool      fRecurse     ,
                                                        /*[in] */ bool      fOnlyVisible ,
                                                        /*[out]*/ MatchSet& res          )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::CachedHelpSet::LocateSubNodes" );

    HRESULT            hr;
    NodeEntry          en;
    NodeEntryIterConst it;


    __MPC_EXIT_IF_METHOD_FAILS(hr, EnsureInSync());


    en.m_rs_data.m_ID_parent = ID_node;

    it = m_setNodes.lower_bound( en );
    while(it != m_setNodes.end() && it->m_rs_data.m_ID_parent == ID_node)
    {
        if(fOnlyVisible == false || it->m_rs_data.m_fVisible)
        {
            res.insert( it->m_rs_data.m_ID_node );

            if(fRecurse)
            {
                __MPC_EXIT_IF_METHOD_FAILS(hr, LocateSubNodes( it->m_rs_data.m_ID_node, /*fRecurse*/true, fOnlyVisible, res ));
            }
        }

        it++;
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::CachedHelpSet::LocateNodesFromURL( /*[in] */ LPCWSTR   szURL ,
                                                            /*[out]*/ MatchSet& res   )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::CachedHelpSet::LocateNodesFromURL" );

    HRESULT            hr;
    NodeEntryIterConst it;


    __MPC_EXIT_IF_METHOD_FAILS(hr, EnsureInSync());

    for(it = m_setNodes.begin(); it != m_setNodes.end(); it++)
    {
        if(!MPC::StrICmp( szURL, it->m_rs_data.m_strDescriptionURI ))
        {
            res.insert( it->m_rs_data.m_ID_node );
        }
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::CachedHelpSet::BuildNodePath( /*[in] */ long          ID      ,
                                                       /*[out]*/ MPC::wstring& strPath ,
                                                       /*[in] */ bool          fParent )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::CachedHelpSet::BuildNodePath" );

    HRESULT            hr;
    NodeEntryIterConst it;
    MPC::wstring       strTmp;

    __MPC_EXIT_IF_METHOD_FAILS(hr, EnsureInSync());


    strTmp .reserve( 1024 );
    strPath.reserve( 1024 );

    strPath = L"";

    while(ID != m_lTopNode)
    {
        NodeEntry::MatchNode cmp( ID );

        it = std::find_if( m_setNodes.begin(), m_setNodes.end(), cmp );
        if(it == m_setNodes.end())
        {
            __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_FILE_NOT_FOUND);
        }

        if(fParent == false)
        {
            strTmp = it->m_rs_data.m_strEntry;
            if(strPath.size())
            {
                strTmp += L"/";
                strTmp += strPath;
            }
            strPath = strTmp;
        }
        else
        {
            fParent = true;
        }

        ID = it->m_rs_data.m_ID_parent;
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

////////////////////

HRESULT Taxonomy::Cache::CachedHelpSet::LocateQuery( /*[in] */ LPCWSTR      szID    ,
                                                     /*[in] */ int          iType   ,
                                                     /*[out]*/ QueryEntry* &pEntry  ,
                                                     /*[in] */ bool         fCreate )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::CachedHelpSet::LocateQuery" );

    HRESULT        hr;
    QueryEntry     en;
    QueryEntryIter it;


    pEntry = NULL;


    __MPC_EXIT_IF_METHOD_FAILS(hr, EnsureInSync());


    en.m_strID = SAFEWSTR(szID);
    en.m_iType = iType;

    it = m_setQueries.find( en );
    if(it == m_setQueries.end())
    {
        if(fCreate == false)
        {
            __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_FILE_NOT_FOUND);
        }

        it = m_setQueries.insert( en ).first;

        it->m_iSequence = m_iLastSequence++;
    }
    else
    {
        if(fCreate == false)
        {
            if(it->m_fRemoved)
            {
                __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_FILE_NOT_FOUND);
            }
        }
    }


    pEntry             = &(*it);
    pEntry->m_fRemoved = false;
    m_fDirty           = true;
    hr                 = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

Taxonomy::Cache::Cache()
{
    // CacheSet m_skus;

    (void)MPC::_MPC_Module.RegisterCallback( this, (void (Taxonomy::Cache::*)())Shutdown );
}

Taxonomy::Cache::~Cache()
{
    MPC::_MPC_Module.UnregisterCallback( this );

    Shutdown();
}

////////////////////

Taxonomy::Cache* Taxonomy::Cache::s_GLOBAL( NULL );

HRESULT Taxonomy::Cache::InitializeSystem()
{
    if(s_GLOBAL == NULL)
    {
        s_GLOBAL = new Taxonomy::Cache;
    }

    return s_GLOBAL ? S_OK : E_OUTOFMEMORY;
}

void Taxonomy::Cache::FinalizeSystem()
{
    if(s_GLOBAL)
    {
        delete s_GLOBAL; s_GLOBAL = NULL;
    }
}

////////////////////

void Taxonomy::Cache::Shutdown()
{
    m_skus.clear();
}

HRESULT Taxonomy::Cache::Locate( /*[in] */ const Taxonomy::HelpSet& ths ,
                                 /*[out]*/ CacheIter&               it  )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::Locate" );

    HRESULT                      hr;
    CachedHelpSet                hs;
    MPC::SmartLock<_ThreadModel> lock( this );


    hs.m_ths = ths;
    it = m_skus.find( hs );
    if(it == m_skus.end())
    {
        WCHAR rgTmp[MAX_PATH]; _snwprintf( rgTmp, MAXSTRLEN(rgTmp), L"%s\\%s_%ld.dat", l_szBase, hs.m_ths.GetSKU(), hs.m_ths.GetLanguage() );

        it = m_skus.insert( hs ).first;

        __MPC_EXIT_IF_METHOD_FAILS(hr, MPC::SubstituteEnvVariables( it->m_strFile = rgTmp ));
        __MPC_EXIT_IF_METHOD_FAILS(hr, MPC::MakeDir               ( it->m_strFile         ));

        it->m_fDirty = true;
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

////////////////////////////////////////

HRESULT Taxonomy::Cache::PrePopulate( /*[in]*/ const Taxonomy::HelpSet& ths )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::PrePopulate" );

    HRESULT                      hr;
    CacheIter                    it;
    MPC::SmartLock<_ThreadModel> lock( this );


    __MPC_EXIT_IF_METHOD_FAILS(hr, Locate( ths, it ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, it->PrePopulate( this ));

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::Erase( /*[in]*/ const Taxonomy::HelpSet& ths )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::Erase" );

    HRESULT                      hr;
    CacheIter                    it;
    MPC::SmartLock<_ThreadModel> lock( this );


    __MPC_EXIT_IF_METHOD_FAILS(hr, Locate( ths, it ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, it->Erase());

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::PrepareToLoad( /*[in]*/ const Taxonomy::HelpSet& ths )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::PrepareToLoad" );

    HRESULT                      hr;
    CacheIter                    it;
    MPC::SmartLock<_ThreadModel> lock( this );


    __MPC_EXIT_IF_METHOD_FAILS(hr, Locate( ths, it ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, it->PrepareToLoad());

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::LoadIfMarked( /*[in]*/ const Taxonomy::HelpSet& ths )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::LoadIfMarked" );

    HRESULT                      hr;
    CacheIter                    it;
    MPC::SmartLock<_ThreadModel> lock( this );


    __MPC_EXIT_IF_METHOD_FAILS(hr, Locate( ths, it ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, it->LoadIfMarked());

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

////////////////////

HRESULT Taxonomy::Cache::LocateNode( /*[in] */ const Taxonomy::HelpSet& ths       ,
                                     /*[in] */ long                     ID_parent ,
                                     /*[in] */ LPCWSTR                  szEntry   ,
                                     /*[out]*/ RS_Data_Taxonomy&        rs_data   )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::LocateNode" );

    HRESULT                      hr;
    CacheIter                    it;
    MPC::SmartLock<_ThreadModel> lock( this );


    __MPC_EXIT_IF_METHOD_FAILS(hr, Locate( ths, it ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, it->LocateNode( ID_parent, szEntry, rs_data ));


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::LocateSubNodes( /*[in] */ const Taxonomy::HelpSet& ths          ,
                                         /*[in] */ long                     ID_node      ,
                                         /*[in] */ bool                     fRecurse     ,
                                         /*[in] */ bool                     fOnlyVisible ,
                                         /*[out]*/ MatchSet&                res          )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::LocateSubNodes" );

    HRESULT                      hr;
    CacheIter                    it;
    MPC::SmartLock<_ThreadModel> lock( this );


    __MPC_EXIT_IF_METHOD_FAILS(hr, Locate( ths, it ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, it->LocateSubNodes( ID_node, fRecurse, fOnlyVisible, res ));


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::LocateNodesFromURL( /*[in] */ const Taxonomy::HelpSet& ths   ,
                                             /*[in] */ LPCWSTR                  szURL ,
                                             /*[out]*/ MatchSet&                res   )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::LocateNodesFromURL" );

    HRESULT                      hr;
    CacheIter                    it;
    MPC::SmartLock<_ThreadModel> lock( this );


    __MPC_EXIT_IF_METHOD_FAILS(hr, Locate( ths, it ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, it->LocateNodesFromURL( szURL, res ));


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::BuildNodePath( /*[in] */ const Taxonomy::HelpSet& ths     ,
                                        /*[in] */ long                     ID      ,
                                        /*[out]*/ MPC::wstring&            strPath ,
                                        /*[in] */ bool                     fParent )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::BuildNodePath" );

    HRESULT                      hr;
    CacheIter                    it;
    MPC::SmartLock<_ThreadModel> lock( this );


    __MPC_EXIT_IF_METHOD_FAILS(hr, Locate( ths, it ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, it->BuildNodePath( ID, strPath, fParent ));


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

////////////////////

HRESULT Taxonomy::Cache::StoreQuery( /*[in]*/ const Taxonomy::HelpSet&         ths   ,
                                     /*[in]*/ LPCWSTR                          szID  ,
                                     /*[in]*/ int                              iType ,
                                     /*[in]*/ const CPCHQueryResultCollection* pColl )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::StoreQuery" );

    HRESULT                      hr;
    CacheIter                    it;
    QueryEntry*                  pEntry;
    MPC::SmartLock<_ThreadModel> lock( this );

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(pColl);
    __MPC_PARAMCHECK_END();


    __MPC_EXIT_IF_METHOD_FAILS(hr, Locate( ths, it ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, it->LocateQuery( szID, iType, pEntry, true ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, pEntry->Store( it->m_disk, pColl ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, it->MRU         ());
    __MPC_EXIT_IF_METHOD_FAILS(hr, it->EnsureInSync());

    //
    // Propagate change to the offline cache.
    //
    {
        OfflineCache::Handle handle;

        if(SUCCEEDED(OfflineCache::Root::s_GLOBAL->Locate( it->m_ths, handle )))
        {
            if(handle->AreYouInterested( szID, iType ))
            {
                if(SUCCEEDED(handle->Store( szID, iType, pColl )))
                {
                    (void)OfflineCache::Root::s_GLOBAL->Flush();
                }
            }
        }
    }


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Cache::RetrieveQuery( /*[in]*/ const Taxonomy::HelpSet&   ths   ,
                                        /*[in]*/ LPCWSTR                    szID  ,
                                        /*[in]*/ int                        iType ,
                                        /*[in]*/ CPCHQueryResultCollection* pColl )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Cache::Retrieve" );

    HRESULT                      hr;
    CacheIter                    it;
    QueryEntry*                  pEntry;
    MPC::SmartLock<_ThreadModel> lock( this );

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(pColl);
    __MPC_PARAMCHECK_END();


    __MPC_EXIT_IF_METHOD_FAILS(hr, Locate( ths, it ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, it->LocateQuery( szID, iType, pEntry, false ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, pEntry->Retrieve( it->m_disk, pColl ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, it->EnsureInSync());

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}