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

Copyright (c) 1999 Microsoft Corporation

Module Name:
    Updater.cpp

Abstract:
    Handles access to the database.

Revision History:

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

#include "stdafx.h"

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

static const WCHAR s_DB_LOCATION_ENV[] = L"%HELP_LOCATION%";

#define STAT_CREATED( table )  m_stat.m_ent##table.Created()
#define STAT_MODIFIED( table ) m_stat.m_ent##table.Modified()
#define STAT_DELETED( table )  m_stat.m_ent##table.Deleted()
#define STAT_NOOP( table )     m_stat.m_ent##table.NoOp()

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

Taxonomy::Updater::WordSetStatus::WordSetStatus()
{
    m_updater   = NULL;       // Updater*          m_updater;
    m_def       = NULL;       // const WordSetDef* m_def;
                              //
                              // WordSet           m_set;
    m_fLoaded   = false;      // bool              m_fLoaded;
    m_fModified = false;      // bool              m_fModified;
}

HRESULT Taxonomy::Updater::WordSetStatus::Close()
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::WordSetStatus::Close" );

    HRESULT hr;


    m_updater = NULL;
    m_def     = NULL;

    m_set.clear();
    m_fLoaded   = false;
    m_fModified = false;


    hr = S_OK;


    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::WordSetStatus::Init( /*[in]*/ Updater* updater, /*[in]*/ const WordSetDef* def )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::WordSetStatus::Init" );

    HRESULT hr;

    __MPC_EXIT_IF_METHOD_FAILS(hr, Close());

    m_updater = updater;
    m_def     = def;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);

}

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

HRESULT Taxonomy::Updater::WordSetStatus::Load()
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::WordSetStatus::Load" );

    HRESULT hr;

    if(m_fLoaded == false)
    {
        MPC::wstring strTokenList;
        bool         fFound;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_updater->ReadDBParameter( m_def->szName, strTokenList, &fFound ));

        if(m_def->szDefault && strTokenList.size() == 0) strTokenList  = m_def->szDefault;
        if(m_def->szAlwaysPresent                      ) strTokenList += m_def->szAlwaysPresent;

        if(m_def->fSplitAtDelimiter)
        {
            std::vector<MPC::wstring> vec;
            int                       iLen;
            int                       i;

            __MPC_EXIT_IF_METHOD_FAILS(hr, MPC::SplitAtDelimiter( vec, strTokenList.c_str(), L" ,\t\n", false, true ));

            iLen = vec.size();
            for(i=0; i<iLen; i++)
            {
                m_set.insert( vec[i] );
            }
        }
        else
        {
            int iLen;
            int i;

            iLen = strTokenList.size();
            for(i=0; i<iLen; i++)
            {
                m_set.insert( MPC::wstring( 1, strTokenList[i] ) );
            }
        }

        m_fLoaded = true;
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::WordSetStatus::Save()
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::WordSetStatus::Save" );

    HRESULT hr;


    if(m_fModified)
    {
        MPC::wstring              strTokenList;
        std::vector<MPC::wstring> vec;
        WordIter                  it;
        int                       i;

        vec.resize( m_set.size() );

        for(i=0, it = m_set.begin(); it != m_set.end(); it++, i++)
        {
            vec[i] = *it;
        }

        __MPC_EXIT_IF_METHOD_FAILS(hr, MPC::JoinWithDelimiter( vec, strTokenList, m_def->fSplitAtDelimiter ? L"," : L"" ));

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_updater->WriteDBParameter( m_def->szName, strTokenList.c_str() ));

        m_fModified = false;
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::WordSetStatus::Add( /*[in]*/ LPCWSTR szValue )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::WordSetStatus::Add" );

    HRESULT hr;


    __MPC_EXIT_IF_METHOD_FAILS(hr, Load());

    m_set.insert( szValue ); m_fModified = true;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::WordSetStatus::Remove( /*[in]*/ LPCWSTR szValue )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::WordSetStatus::Remove" );

    HRESULT  hr;
    WordIter it;


    __MPC_EXIT_IF_METHOD_FAILS(hr, Load());

    it = m_set.find( szValue );
    if(it != m_set.end())
    {
        m_set.erase( it ); m_fModified = true;
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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

static const Taxonomy::Updater::WordSetDef s_SetDef[] =
{
    { L"SET_STOPSIGNS"            , false, L",?" , NULL    }, // UPDATER_SET_STOPSIGNS
    { L"SET_STOPSIGNS_ATENDOFWORD", false, NULL  , NULL    }, // UPDATER_SET_STOPSIGNS_ATENDOFWORD
    { L"SET_STOPWORDS"            , true , NULL  , NULL    }, // UPDATER_SET_STOPWORDS
    { L"SET_OPERATOR_NOT"         , true , L"NOT", L",!"   }, // UPDATER_SET_OPERATOR_NOT
    { L"SET_OPERATOR_AND"         , true , L"AND", L",&,+" }, // UPDATER_SET_OPERATOR_AND
    { L"SET_OPERATOR_OR"          , true , L"OR" , L",||"  }  // UPDATER_SET_OPERATOR_OR
};


Taxonomy::Updater::Updater()
{
                                // Settings           m_ts;
    m_db               = NULL;  // JetBlue::Database* m_db;
    m_cache            = NULL;  // Cache*             m_cache;
    m_fUseCache        = false; // bool               m_fUseCache;
                                //
    m_rsDBParameters   = NULL;  // RS_DBParameters*   m_rsDBParameters;
    m_rsContentOwners  = NULL;  // RS_ContentOwners*  m_rsContentOwners;
    m_rsSynSets        = NULL;  // RS_SynSets*        m_rsSynSets;
    m_rsHelpImage      = NULL;  // RS_HelpImage*      m_rsHelpImage;
    m_rsIndexFiles     = NULL;  // RS_IndexFiles*     m_rsIndexFiles;
    m_rsFullTextSearch = NULL;  // RS_FullTextSearch* m_rsFullTextSearch;
    m_rsScope          = NULL;  // RS_Scope*          m_rsScope;
    m_rsTaxonomy       = NULL;  // RS_Taxonomy*       m_rsTaxonomy;
    m_rsTopics         = NULL;  // RS_Topics*         m_rsTopics;
    m_rsSynonyms       = NULL;  // RS_Synonyms*       m_rsSynonyms;
    m_rsKeywords       = NULL;  // RS_Keywords*       m_rsKeywords;
    m_rsMatches        = NULL;  // RS_Matches*        m_rsMatches;
                                //
    m_ID_owner         = -1;    // long               m_ID_owner;
    m_fOEM             = false; // bool               m_fOEM;
                                //
                                // WordSetStatus      m_sets[UPDATER_SET_OPERATOR_MAX];
                                // JetBlue::Id2Node   m_nodes;
                                // JetBlue::Node2Id   m_nodes_reverse;
                                // 
                                // Updater_Stat       m_stat;
}

Taxonomy::Updater::~Updater()
{
    (void)Close();
}

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

HRESULT Taxonomy::Updater::FlushWordSets()
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::FlushWordSets" );

    HRESULT hr;
    int     i;

    for(i=UPDATER_SET_STOPSIGNS; i<UPDATER_SET_OPERATOR_MAX; i++)
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_sets[i].Save());
    }

    hr = S_OK;

    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}


HRESULT Taxonomy::Updater::Close()
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::Close" );

    HRESULT hr;
    int     i;


    for(i=UPDATER_SET_STOPSIGNS; i<UPDATER_SET_OPERATOR_MAX; i++)
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_sets[i].Close());
    }

	NodeCache_Clear();

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    if(m_rsDBParameters  ) { delete m_rsDBParameters  ; m_rsDBParameters   = NULL; }
    if(m_rsContentOwners ) { delete m_rsContentOwners ; m_rsContentOwners  = NULL; }
    if(m_rsSynSets       ) { delete m_rsSynSets       ; m_rsSynSets        = NULL; }
    if(m_rsHelpImage     ) { delete m_rsHelpImage     ; m_rsHelpImage      = NULL; }
    if(m_rsIndexFiles    ) { delete m_rsIndexFiles    ; m_rsIndexFiles     = NULL; }
    if(m_rsFullTextSearch) { delete m_rsFullTextSearch; m_rsFullTextSearch = NULL; }
    if(m_rsScope         ) { delete m_rsScope         ; m_rsScope          = NULL; }
    if(m_rsTaxonomy      ) { delete m_rsTaxonomy      ; m_rsTaxonomy       = NULL; }
    if(m_rsTopics        ) { delete m_rsTopics        ; m_rsTopics         = NULL; }
    if(m_rsSynonyms      ) { delete m_rsSynonyms      ; m_rsSynonyms       = NULL; }
    if(m_rsKeywords      ) { delete m_rsKeywords      ; m_rsKeywords       = NULL; }
    if(m_rsMatches       ) { delete m_rsMatches       ; m_rsMatches        = NULL; }

    m_db        = NULL;
    m_cache     = NULL;
    m_fUseCache = false;

    m_ID_owner = -1;
    m_fOEM     = false;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::Init( /*[in]*/ const Settings& ts, /*[in]*/ JetBlue::Database* db, /*[in]*/ Cache* cache )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::Init" );

    HRESULT hr;
    int     i;


    __MPC_EXIT_IF_METHOD_FAILS(hr, Close());

    m_ts        = ts;
    m_db        = db;
    m_cache     = cache;
    m_fUseCache = (cache != NULL);
    m_strDBLocation = L"";

    for(i=UPDATER_SET_STOPSIGNS; i<UPDATER_SET_OPERATOR_MAX; i++)
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_sets[i].Init( this, &s_SetDef[i] ));
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GetWordSet( /*[in] */ Updater_Set  id   ,
                                       /*[out]*/ WordSet*    *pVal )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GetWordSet" );

    HRESULT hr;

    if(pVal) *pVal = NULL;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_db);
    __MPC_PARAMCHECK_END();


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_sets[id].Load());

    if(pVal) *pVal = &m_sets[id].m_set;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GetDBParameters( /*[out]*/ RS_DBParameters* *pVal )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GetDBParameters" );

    HRESULT hr;

    if(pVal) *pVal = NULL;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_db);
    __MPC_PARAMCHECK_END();


    if(m_rsDBParameters == NULL)
    {
        JetBlue::Table* tbl;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_db->GetTable( "DBParameters", tbl ));

        __MPC_EXIT_IF_ALLOC_FAILS(hr, m_rsDBParameters, new RS_DBParameters( tbl ));
    }

    if(pVal) *pVal = m_rsDBParameters;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GetContentOwners( /*[out]*/ RS_ContentOwners* *pVal )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GetContentOwners" );

    HRESULT hr;

    if(pVal) *pVal = NULL;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_db);
    __MPC_PARAMCHECK_END();


    if(m_rsContentOwners == NULL)
    {
        JetBlue::Table* tbl;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_db->GetTable( "ContentOwners", tbl ));

        __MPC_EXIT_IF_ALLOC_FAILS(hr, m_rsContentOwners, new RS_ContentOwners( tbl ));
    }

    if(pVal) *pVal = m_rsContentOwners;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GetSynSets( /*[out]*/ RS_SynSets* *pVal )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GetSynSets" );

    HRESULT hr;

    if(pVal) *pVal = NULL;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_db);
    __MPC_PARAMCHECK_END();


    if(m_rsSynSets == NULL)
    {
        JetBlue::Table* tbl;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_db->GetTable( "SynSets", tbl ));

        __MPC_EXIT_IF_ALLOC_FAILS(hr, m_rsSynSets, new RS_SynSets( tbl ));
    }

    if(pVal) *pVal = m_rsSynSets;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GetHelpImage( /*[out]*/ RS_HelpImage* *pVal )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GetHelpImage" );

    HRESULT hr;

    if(pVal) *pVal = NULL;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_db);
    __MPC_PARAMCHECK_END();


    if(m_rsHelpImage == NULL)
    {
        JetBlue::Table* tbl;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_db->GetTable( "HelpImage", tbl ));

        __MPC_EXIT_IF_ALLOC_FAILS(hr, m_rsHelpImage, new RS_HelpImage( tbl ));
    }

    if(pVal) *pVal = m_rsHelpImage;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GetIndexFiles( /*[out]*/ RS_IndexFiles* *pVal )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GetIndexFiles" );

    HRESULT hr;

    if(pVal) *pVal = NULL;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_db);
    __MPC_PARAMCHECK_END();


    if(m_rsIndexFiles == NULL)
    {
        JetBlue::Table* tbl;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_db->GetTable( "IndexFiles", tbl ));

        __MPC_EXIT_IF_ALLOC_FAILS(hr, m_rsIndexFiles, new RS_IndexFiles( tbl ));
    }

    if(pVal) *pVal = m_rsIndexFiles;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GetFullTextSearch( /*[out]*/ RS_FullTextSearch* *pVal )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GetFullTextSearch" );

    HRESULT hr;

    if(pVal) *pVal = NULL;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_db);
    __MPC_PARAMCHECK_END();


    if(m_rsFullTextSearch == NULL)
    {
        JetBlue::Table* tbl;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_db->GetTable( "FullTextSearch", tbl ));

        __MPC_EXIT_IF_ALLOC_FAILS(hr, m_rsFullTextSearch, new RS_FullTextSearch( tbl ));
    }

    if(pVal) *pVal = m_rsFullTextSearch;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GetScope( /*[out]*/ RS_Scope* *pVal )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GetScope" );

    HRESULT hr;

    if(pVal) *pVal = NULL;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_db);
    __MPC_PARAMCHECK_END();


    if(m_rsScope == NULL)
    {
        JetBlue::Table* tbl;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_db->GetTable( "Scope", tbl ));

        __MPC_EXIT_IF_ALLOC_FAILS(hr, m_rsScope, new RS_Scope( tbl ));
    }

    if(pVal) *pVal = m_rsScope;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GetTaxonomy( /*[out]*/ RS_Taxonomy* *pVal )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GetTaxonomy" );

    HRESULT hr;

    if(pVal) *pVal = NULL;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_db);
    __MPC_PARAMCHECK_END();


    if(m_rsTaxonomy == NULL)
    {
        JetBlue::Table* tbl;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_db->GetTable( "Taxonomy", tbl ));

        __MPC_EXIT_IF_ALLOC_FAILS(hr, m_rsTaxonomy, new RS_Taxonomy( tbl ));
    }

    if(pVal) *pVal = m_rsTaxonomy;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GetTopics( /*[out]*/ RS_Topics* *pVal )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GetTopics" );

    HRESULT hr;

    if(pVal) *pVal = NULL;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_db);
    __MPC_PARAMCHECK_END();


    if(m_rsTopics == NULL)
    {
        JetBlue::Table* tbl;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_db->GetTable( "Topics", tbl ));

        __MPC_EXIT_IF_ALLOC_FAILS(hr, m_rsTopics, new RS_Topics( tbl ));
    }

    if(pVal) *pVal = m_rsTopics;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GetSynonyms( /*[out]*/ RS_Synonyms* *pVal )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GetSynonyms" );

    HRESULT hr;

    if(pVal) *pVal = NULL;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_db);
    __MPC_PARAMCHECK_END();


    if(m_rsSynonyms == NULL)
    {
        JetBlue::Table* tbl;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_db->GetTable( "Synonyms", tbl ));

        __MPC_EXIT_IF_ALLOC_FAILS(hr, m_rsSynonyms, new RS_Synonyms( tbl ));
    }

    if(pVal) *pVal = m_rsSynonyms;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GetKeywords( /*[out]*/ RS_Keywords* *pVal )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GetKeywords" );

    HRESULT hr;

    if(pVal) *pVal = NULL;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_db);
    __MPC_PARAMCHECK_END();


    if(m_rsKeywords == NULL)
    {
        JetBlue::Table* tbl;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_db->GetTable( "Keywords", tbl ));

        __MPC_EXIT_IF_ALLOC_FAILS(hr, m_rsKeywords, new RS_Keywords( tbl ));
    }

    if(pVal) *pVal = m_rsKeywords;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GetMatches( /*[out]*/ RS_Matches* *pVal )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GetMatches" );

    HRESULT hr;

    if(pVal) *pVal = NULL;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_db);
    __MPC_PARAMCHECK_END();


    if(m_rsMatches == NULL)
    {
        JetBlue::Table* tbl;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_db->GetTable( "Matches", tbl ));

        __MPC_EXIT_IF_ALLOC_FAILS(hr, m_rsMatches, new RS_Matches( tbl ));
    }

    if(pVal) *pVal = m_rsMatches;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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

HRESULT Taxonomy::Updater::DeleteAllTopicsUnderANode( /*[in]*/ RS_Topics* rs       ,
                                                      /*[in]*/ long       ID_node  ,
                                                      /*[in]*/ bool       fCheck   )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::DeleteAllTopicsUnderANode" );

    HRESULT hr;
    bool    fFound;


    __MPC_EXIT_IF_METHOD_FAILS(hr, rs->Seek_TopicsUnderNode( ID_node, &fFound ));
    while(fFound && rs->m_ID_node == ID_node)
    {
        if(rs->m_ID_owner != m_ID_owner)
        {
            __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_ACCESS_DENIED);
        }

        if(fCheck == false)
        {
            __MPC_EXIT_IF_METHOD_FAILS(hr, GetMatches());

            __MPC_EXIT_IF_METHOD_FAILS(hr, DeleteAllMatchesPointingToTopic( m_rsMatches, rs->m_ID_topic ));

            __MPC_EXIT_IF_METHOD_FAILS(hr, rs->Delete()); STAT_DELETED( Topics );
        }

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


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}


HRESULT Taxonomy::Updater::DeleteAllSubNodes( /*[in]*/ RS_Taxonomy* rs       ,
                                              /*[in]*/ long         ID_node  ,
                                              /*[in]*/ bool         fCheck   )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::DeleteAllSubNodes" );

    HRESULT hr;
    bool    fFound;

	
	__MPC_EXIT_IF_METHOD_FAILS(hr, DeleteAllTopicsUnderANode( m_rsTopics, ID_node, fCheck ));


    __MPC_EXIT_IF_METHOD_FAILS(hr, rs->Seek_Children( ID_node, &fFound ));
    while(fFound)
    {
        if(rs->m_ID_owner != m_ID_owner)
        {
            __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_ACCESS_DENIED);
        }

        {
            RS_Taxonomy subrs( *rs );

            __MPC_EXIT_IF_METHOD_FAILS(hr, DeleteAllSubNodes( &subrs, rs->m_ID_node, fCheck ));
        }

        if(fCheck == false)
        {
			//
			// Keep the node cache in sync.
			//
			NodeCache_Remove( rs->m_ID_node );

            __MPC_EXIT_IF_METHOD_FAILS(hr, rs->Delete()); STAT_DELETED( Taxonomy );
        }

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


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::DeleteAllMatchesPointingToTopic( /*[in]*/ RS_Matches* rs       ,
                                                            /*[in]*/ long        ID_topic )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::DeleteAllMatchesPointingToTopic" );

    HRESULT hr;
    bool    fFound;


    __MPC_EXIT_IF_METHOD_FAILS(hr, rs->Seek_ByTopic( ID_topic, &fFound ));
    while(fFound)
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, rs->Delete()); STAT_DELETED( Matches );

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

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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

HRESULT Taxonomy::Updater::ReadDBParameter( /*[in] */ LPCWSTR        szName   ,
                                            /*[out]*/ MPC::wstring&  strValue ,
                                            /*[out]*/ bool          *pfFound  )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::ReadDBParameter" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetDBParameters());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsDBParameters->Seek_ByName( szName, &fFound ));
    if(fFound)
    {
        strValue = m_rsDBParameters->m_strValue;
    }

    if(pfFound)
    {
        *pfFound = fFound;
    }
    else if(fFound == false)
    {
        __MPC_SET_ERROR_AND_EXIT(hr, JetBlue::JetERRToHRESULT(JET_errRecordNotFound));
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::ReadDBParameter( /*[in] */ LPCWSTR  szName  ,
                                            /*[out]*/ long&    lValue  ,
                                            /*[out]*/ bool    *pfFound )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::ReadDBParameter" );

    HRESULT      hr;
    MPC::wstring strValue;


    __MPC_EXIT_IF_METHOD_FAILS(hr, ReadDBParameter( szName, strValue, pfFound ));

    lValue = _wtol( strValue.c_str() );

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}


HRESULT Taxonomy::Updater::WriteDBParameter( /*[in]*/ LPCWSTR szName  ,
                                             /*[in]*/ LPCWSTR szValue )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::WriteDBParameter" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetDBParameters());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsDBParameters->Seek_ByName( szName, &fFound ));

    JET_SET_FIELD_TRISTATE(m_rsDBParameters,m_strValue,m_fValid__Value,szValue,STRINGISPRESENT(szValue));

    if(fFound)
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsDBParameters->Update());
    }
    else
    {
        m_rsDBParameters->m_strName = szName;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsDBParameters->Insert());
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::WriteDBParameter( /*[in]*/ LPCWSTR szName ,
                                             /*[in]*/ long    lValue )
{
    WCHAR rgValue[64]; swprintf( rgValue, L"%ld", lValue );

    return WriteDBParameter( szName, rgValue );
}

HRESULT Taxonomy::Updater::AddWordToSet( /*[in]*/ Updater_Set id      ,
                                         /*[in]*/ LPCWSTR     szValue )
{
    return m_sets[id].Add( szValue );
}

HRESULT Taxonomy::Updater::RemoveWordFromSet( /*[in]*/ Updater_Set id, /*[in]*/ LPCWSTR szValue )
{
    return m_sets[id].Remove( szValue );
}

const MPC::wstring& Taxonomy::Updater::GetHelpLocation()
{
    if(m_strDBLocation.size() == 0)
    {
        if(Taxonomy::InstalledInstanceStore::s_GLOBAL)
		{
			Taxonomy::LockingHandle         handle;
			Taxonomy::InstalledInstanceIter it;
			bool                     	    fFound;

			if(SUCCEEDED(Taxonomy::InstalledInstanceStore::s_GLOBAL->GrabControl( handle           )) && 
			   SUCCEEDED(Taxonomy::InstalledInstanceStore::s_GLOBAL->SKU_Find   ( m_ts, fFound, it )) && fFound)
			{
				m_strDBLocation = it->m_inst.m_strHelpFiles;
			}
		}

		if(m_strDBLocation.size() == 0)
		{
            m_strDBLocation = HC_HELPSVC_HELPFILES_DEFAULT;
        }
    }

    return m_strDBLocation;
}

HRESULT Taxonomy::Updater::ExpandURL( /*[in/out]*/ MPC::wstring& strURL )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::ExpandURL" );

    HRESULT hr;
    LPCWSTR szEnd;


    GetHelpLocation();


    szEnd = strURL.c_str();
    while((szEnd = wcschr( szEnd, '%' )))
    {
        if(!_wcsnicmp( szEnd, s_DB_LOCATION_ENV, MAXSTRLEN( s_DB_LOCATION_ENV ) ))
        {
            MPC::wstring::size_type pos = szEnd - strURL.c_str();

            strURL.replace( pos, MAXSTRLEN( s_DB_LOCATION_ENV ), m_strDBLocation );
            break;
        }

        szEnd++;
    }

    hr = MPC::SubstituteEnvVariables( strURL );


    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::CollapseURL( /*[in/out]*/ MPC::wstring& strURL )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::CollapseURL" );

    HRESULT      hr;
    MPC::wstring strBASE;
    CComBSTR     bstrBASE;
    CComBSTR     bstrURL;
    LPCWSTR      szEnd;


    GetHelpLocation(); (void)MPC::SubstituteEnvVariables( strBASE = m_strDBLocation );

    bstrBASE = strBASE.c_str(); ::CharUpperW( bstrBASE );
    bstrURL  = strURL .c_str(); ::CharUpperW( bstrURL  );

    if(szEnd = wcsstr( bstrURL, bstrBASE ))
    {
        MPC::wstring::size_type pos = szEnd - bstrURL;

        strURL.replace( pos, bstrBASE.Length(), s_DB_LOCATION_ENV );
    }

    hr = S_OK;


    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::ListAllTheHelpFiles( /*[out]*/ MPC::WStringList& lstFiles )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::ListAllTheHelpFiles" );

    HRESULT  hr;
    WordSet  setFiles;
    WordIter it;
    bool     fFound;


    //
    // Get all the files from the HelpImage list.
    //
    if(SUCCEEDED(GetHelpImage()))
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsHelpImage->Move( 0, JET_MoveFirst, &fFound ));
        while(fFound)
        {
            if(m_rsHelpImage->m_strFile.empty() == false) setFiles.insert( m_rsHelpImage->m_strFile );

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

    //
    // Get all the CHM and CHQ from the FullTextSearch list.
    //
    if(SUCCEEDED(GetFullTextSearch()))
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsFullTextSearch->Move( 0, JET_MoveFirst, &fFound ));
        while(fFound)
        {
            if(m_rsFullTextSearch->m_strCHM.empty() == false) setFiles.insert( m_rsFullTextSearch->m_strCHM );
            if(m_rsFullTextSearch->m_strCHQ.empty() == false) setFiles.insert( m_rsFullTextSearch->m_strCHQ );

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

    //
    // Get all the CHM from the IndexFiles list.
    //
    if(SUCCEEDED(GetIndexFiles()))
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsIndexFiles->Move( 0, JET_MoveFirst, &fFound ));
        while(fFound)
        {
            if(m_rsIndexFiles->m_strStorage.empty() == false) setFiles.insert( m_rsIndexFiles->m_strStorage );

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

    //
    // From a set to a list to a VARIANT.
    //
    for(it = setFiles.begin(); it != setFiles.end(); it++)
    {
        lstFiles.push_back( *it );
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GetIndexInfo( /*[out]*/ MPC::wstring& strLocation, /*[out]*/ MPC::wstring& strDisplayName, /*[in]*/ LPCWSTR szScope )
{
	__HCP_FUNC_ENTRY( "Taxonomy::Updater::GetIndexInfo" );

    HRESULT hr;
	long    ID_Scope = -1;
	long    lOwner;


	if(szScope)
	{
		__MPC_EXIT_IF_METHOD_FAILS(hr, LocateScope( ID_Scope, lOwner, szScope ));
	}

	__MPC_EXIT_IF_METHOD_FAILS(hr, m_ts.IndexFile( strLocation, ID_Scope ));

	strDisplayName = m_rsScope->m_strName;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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

HRESULT Taxonomy::Updater::DeleteOwner()
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::DeleteOwner" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetContentOwners());

    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsContentOwners->Move( 0, JET_MoveFirst, &fFound ));
    while(fFound)
    {
        if(m_rsContentOwners->m_ID_owner == m_ID_owner)
        {
            __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsContentOwners->Delete()); STAT_DELETED( ContentOwners );
            m_ID_owner = -1;
            break;
        }

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

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::LocateOwner( /*[in] */ LPCWSTR szDN )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::LocateOwner" );

    HRESULT hr;
    bool    fFound;

    m_ID_owner = -1;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetContentOwners());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsContentOwners->Seek_ByVendorID( szDN, &fFound ));
    if(fFound)
    {
        m_ID_owner = m_rsContentOwners->m_ID_owner;
        m_fOEM     = m_rsContentOwners->m_fIsOEM;
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::CreateOwner( /*[out]*/ long&   ID_owner,
                                        /*[in] */ LPCWSTR szDN   ,
                                        /*[in] */ bool    fIsOEM )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::CreateOwner" );

    HRESULT hr;
    bool    fFound;

    ID_owner = -1;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetContentOwners());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsContentOwners->Seek_ByVendorID( szDN, &fFound ));

    m_rsContentOwners->m_fIsOEM = fIsOEM;

    if(fFound == true)
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsContentOwners->Update()); STAT_MODIFIED( ContentOwners );
    }
    else
    {
        m_rsContentOwners->m_strDN = szDN;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsContentOwners->Insert()); STAT_CREATED( ContentOwners );
    }

    ID_owner = m_rsContentOwners->m_ID_owner;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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

HRESULT Taxonomy::Updater::DeleteSynSet( /*[in]*/ LPCWSTR szName )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::DeleteSynSet" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetSynSets());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsSynSets->Seek_ByPair( szName, m_ID_owner, &fFound ));
    if(fFound)
    {
		__MPC_EXIT_IF_METHOD_FAILS(hr, m_rsSynSets->Delete()); STAT_DELETED( SynSets );
    }
	else
	{
		STAT_NOOP( SynSets );
	}

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::LocateSynSet( /*[out]*/ long&   ID_synset ,
										 /*[in] */ LPCWSTR szName    )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::LocateSynSet" );

    HRESULT hr;
    bool    fFound;

    ID_synset = -1;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetSynSets());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsSynSets->Seek_ByPair( szName, m_ID_owner, &fFound ));
    if(fFound)
    {
        ID_synset = m_rsSynSets->m_ID_synset;
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::CreateSynSet( /*[out]*/ long&   ID_synset ,
										 /*[in ]*/ LPCWSTR szName    )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::CreateSynSet" );

    HRESULT hr;
    bool    fFound;

    ID_synset = -1;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetSynSets());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsSynSets->Seek_ByPair( szName, m_ID_owner, &fFound ));
    if(!fFound)
    {
        m_rsSynSets->m_strName  = szName;
        m_rsSynSets->m_ID_owner = m_ID_owner;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsSynSets->Insert()); STAT_CREATED( SynSets );
    }
	else
	{
		STAT_NOOP( SynSets );
	}

    ID_synset = m_rsSynSets->m_ID_synset;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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


HRESULT Taxonomy::Updater::DeleteSynonym( /*[in]*/ long    ID_synset ,
										  /*[in]*/ LPCWSTR szName    )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::DeleteSynonym" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetSynonyms());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsSynonyms->Seek_ByPair( szName, ID_synset, &fFound ));
    if(fFound)
    {
		__MPC_EXIT_IF_METHOD_FAILS(hr, m_rsSynonyms->Delete()); STAT_DELETED( Synonyms );
    }
	else
	{
		STAT_NOOP( Synonyms );
	}

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::CreateSynonym( /*[in]*/ long    ID_synset ,
										  /*[in]*/ LPCWSTR szName    )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::CreateSynonym" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetSynonyms());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsSynonyms->Seek_ByPair( szName, ID_synset, &fFound ));
    if(!fFound)
    {
        m_rsSynonyms->m_strKeyword = szName;
        m_rsSynonyms->m_ID_synset  = ID_synset;
        m_rsSynonyms->m_ID_owner   = m_ID_owner;

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsSynonyms->Insert()); STAT_CREATED( Synonyms );
    }
	else
	{
		STAT_NOOP( Synonyms );
	}

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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

HRESULT Taxonomy::Updater::LocateSynonyms( /*[in ]*/ LPCWSTR           szName      ,
										   /*[out]*/ MPC::WStringList& lst         ,
										   /*[in ]*/ bool              fMatchOwner )
{
	__HCP_FUNC_ENTRY( "Taxonomy::Updater::LocateSynonyms" );

	HRESULT hr;
	bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetSynonyms());

    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsSynonyms->Seek_ByName( szName, &fFound ));
    while(fFound)
    {
		if(fMatchOwner == false || m_rsSynonyms->m_ID_owner == m_ID_owner)
		{
			WCHAR rgBuf[64]; swprintf( rgBuf, L"SYNSET_%ld", m_rsSynonyms->m_ID_synset );

			lst.push_back( rgBuf );
		}

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

	hr = S_OK;


	__HCP_FUNC_CLEANUP;

	__HCP_FUNC_EXIT(hr);
}

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

HRESULT Taxonomy::Updater::AddFile( /*[in]*/ LPCWSTR szFile )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::AddFile" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetHelpImage());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsHelpImage->Seek_ByFile( szFile, &fFound ));
    if(fFound)
    {
        if(m_rsHelpImage->m_ID_owner != m_ID_owner)
        {
            __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_ACCESS_DENIED);
        }

		STAT_NOOP( HelpImage );
    }
    else
    {
        JET_SET_FIELD(m_rsHelpImage,m_ID_owner,m_ID_owner);
        JET_SET_FIELD(m_rsHelpImage,m_strFile ,  szFile  );

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsHelpImage->Insert()); STAT_CREATED( HelpImage );
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::RemoveFile( /*[in]*/ LPCWSTR szFile )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::RemoveFile" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetHelpImage());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsHelpImage->Seek_ByFile( szFile, &fFound ));
    if(fFound)
    {
        if(m_rsHelpImage->m_ID_owner != m_ID_owner)
        {
            __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_ACCESS_DENIED);
        }

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsHelpImage->Delete()); STAT_DELETED( HelpImage );
    }
	else
	{
		STAT_NOOP( HelpImage );
	}

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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

HRESULT Taxonomy::Updater::AddIndexFile( /*[in]*/ long ID_scope, /*[in]*/ LPCWSTR szStorage, /*[in]*/ LPCWSTR szFile )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::AddIndexFile" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetIndexFiles());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsIndexFiles->Seek_ByScope( ID_scope, &fFound ));
    while(fFound)
    {
        if(!MPC::StrICmp( m_rsIndexFiles->m_strStorage, szStorage ) &&
           !MPC::StrICmp( m_rsIndexFiles->m_strFile   , szFile    )  )
        {
            if(m_rsIndexFiles->m_ID_owner != m_ID_owner)
            {
                __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_ACCESS_DENIED);
            }

			break;
        }

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


    JET_SET_FIELD_TRISTATE(m_rsIndexFiles,m_strStorage,m_fValid__Storage,szStorage,STRINGISPRESENT(szStorage));
    JET_SET_FIELD_TRISTATE(m_rsIndexFiles,m_strFile   ,m_fValid__File   ,szFile   ,STRINGISPRESENT(szFile   ));


    if(fFound)
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsIndexFiles->Update()); STAT_MODIFIED( IndexFiles );
    }
    else
    {
        JET_SET_FIELD(m_rsIndexFiles,m_ID_owner,m_ID_owner);
        JET_SET_FIELD(m_rsIndexFiles,m_ID_scope,  ID_scope);

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsIndexFiles->Insert()); STAT_CREATED( IndexFiles );
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::RemoveIndexFile( /*[in]*/ long ID_scope, /*[in]*/ LPCWSTR szStorage, /*[in]*/ LPCWSTR szFile )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::RemoveIndexFile" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetIndexFiles());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsIndexFiles->Seek_ByScope( ID_scope, &fFound ));
    while(fFound)
    {
        if(!MPC::StrICmp( m_rsIndexFiles->m_strStorage, szStorage ) &&
           !MPC::StrICmp( m_rsIndexFiles->m_strFile   , szFile    )  )
        {
            if(m_rsIndexFiles->m_ID_owner != m_ID_owner)
            {
                __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_ACCESS_DENIED);
            }

			break;
        }

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

    if(fFound)
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsIndexFiles->Delete()); STAT_DELETED( IndexFiles );
    }
	else
	{
		STAT_NOOP( IndexFiles );
	}

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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

HRESULT Taxonomy::Updater::AddFullTextSearchQuery( /*[in]*/ long ID_scope, /*[in]*/ LPCWSTR szCHM, /*[in]*/ LPCWSTR szCHQ )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::AddFullTextSearchQuery" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetFullTextSearch());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsFullTextSearch->Seek_ByScope( ID_scope, &fFound ));
    while(fFound)
    {
        if(!MPC::StrICmp( m_rsFullTextSearch->m_strCHM, szCHM ))
        {
            if(m_rsFullTextSearch->m_ID_owner != m_ID_owner)
            {
                __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_ACCESS_DENIED);
            }

            break;
        }

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


    JET_SET_FIELD_TRISTATE(m_rsFullTextSearch,m_strCHM,m_fValid__CHM, szCHM,STRINGISPRESENT(szCHM));
    JET_SET_FIELD_TRISTATE(m_rsFullTextSearch,m_strCHQ,m_fValid__CHQ, szCHQ,STRINGISPRESENT(szCHQ));


    if(fFound)
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsFullTextSearch->Update()); STAT_MODIFIED( FullTextSearch );
    }
    else
    {
        JET_SET_FIELD(m_rsFullTextSearch,m_ID_owner,m_ID_owner);
        JET_SET_FIELD(m_rsFullTextSearch,m_ID_scope,  ID_scope);

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsFullTextSearch->Insert()); STAT_CREATED( FullTextSearch );
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::RemoveFullTextSearchQuery( /*[in]*/ long ID_scope, /*[in]*/ LPCWSTR szCHM )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::RemoveFullTextSearchQuery" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetFullTextSearch());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsFullTextSearch->Seek_ByScope( ID_scope, &fFound ));
    while(fFound)
    {
        if(!MPC::StrICmp( m_rsFullTextSearch->m_strCHM, szCHM ))
        {
            if(m_rsFullTextSearch->m_ID_owner != m_ID_owner)
            {
                __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_ACCESS_DENIED);
            }

            break;
        }

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

    if(fFound)
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsFullTextSearch->Delete()); STAT_DELETED( FullTextSearch );
    }
	else
	{
		STAT_NOOP( FullTextSearch );
	}

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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


HRESULT Taxonomy::Updater::RemoveScope( /*[in]*/ long ID_scope )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::RemoveScope" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetScope());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsScope->Seek_ByScope( ID_scope, &fFound ));
    if(fFound)
    {
        if(m_rsScope->m_ID_owner != m_ID_owner)
        {
            __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_ACCESS_DENIED);
        }

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsScope->Delete()); STAT_DELETED( Scope );
    }
	else
	{
		STAT_NOOP( Scope );
	}

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::LocateScope( /*[out]*/ long& ID_scope, /*[out]*/ long& ID_owner, /*[in]*/ LPCWSTR szID )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::LocateScope" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetScope());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsScope->Seek_ByID( szID, &fFound ));
    if(fFound)
    {
        ID_scope = m_rsScope->m_ID_scope;
        ID_owner = m_rsScope->m_ID_owner;
    }
    else
    {
        ID_scope = -1;
        ID_owner = -1;
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::CreateScope( /*[out]*/ long& ID_scope, /*[in]*/ LPCWSTR szID, /*[in]*/ LPCWSTR szName, /*[in]*/ LPCWSTR szCategory )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::CreateScope" );

    HRESULT hr;
    bool    fFound;

    ID_scope = -1;


    __MPC_EXIT_IF_METHOD_FAILS(hr, GetScope());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsScope->Seek_ByID( szID, &fFound ));
    if(fFound)
    {
        if(m_rsScope->m_ID_owner != m_ID_owner)
        {
            __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_ACCESS_DENIED);
        }
    }


    JET_SET_FIELD         (m_rsScope,m_strID      ,                   szID                                  );
    JET_SET_FIELD         (m_rsScope,m_strName    ,                   szName                                );
    JET_SET_FIELD_TRISTATE(m_rsScope,m_strCategory,m_fValid__Category,szCategory,STRINGISPRESENT(szCategory));


    if(fFound)
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsScope->Update()); STAT_MODIFIED( Scope );
    }
    else
    {
        JET_SET_FIELD(m_rsScope,m_ID_owner, m_ID_owner);

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsScope->Insert()); STAT_CREATED( Scope );
    }

    ID_scope = m_rsScope->m_ID_scope;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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

bool Taxonomy::Updater::NodeCache_FindNode( /*[in ]*/ MPC::wstringUC& strPathUC, /*[out]*/ JetBlue::Id2NodeIter& itNode )
{
	itNode = m_nodes.find( strPathUC );

	return (itNode != m_nodes.end());
}

bool Taxonomy::Updater::NodeCache_FindId( /*[in ]*/ long ID_node, /*[out]*/ JetBlue::Node2IdIter& itId )
{
	itId = m_nodes_reverse.find( ID_node );

	return (itId != m_nodes_reverse.end());
}


void Taxonomy::Updater::NodeCache_Add( /*[in]*/ MPC::wstringUC& strPathUC, /*[in]*/ long ID_node )
{
	m_nodes        [ strPathUC ] = ID_node;
	m_nodes_reverse[ ID_node   ] = strPathUC;
}

void Taxonomy::Updater::NodeCache_Remove( /*[in]*/ long ID_node )
{
	JetBlue::Node2IdIter itId;
	JetBlue::Id2NodeIter itNode;

	itId = m_nodes_reverse.find( ID_node );
	if(itId != m_nodes_reverse.end())
	{
		m_nodes        .erase( itId->second );
		m_nodes_reverse.erase( itId         );
	}
}

void Taxonomy::Updater::NodeCache_Clear()
{
	m_nodes        .clear();
	m_nodes_reverse.clear();
}

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

HRESULT Taxonomy::Updater::DeleteTaxonomyNode( /*[in ]*/ long ID_node )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::DeleteTaxonomyNode" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetTaxonomy());
    __MPC_EXIT_IF_METHOD_FAILS(hr, GetTopics  ());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsTaxonomy->Seek_Node( ID_node, &fFound ));
    if(fFound)
    {
        if(m_rsTaxonomy->m_ID_owner != m_ID_owner)
        {
            __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_ACCESS_DENIED);
        }

        //
        // Before deleting the node, check everything below it can be deleted, then delete it.
        //
        {
            RS_Taxonomy subrs( *m_rsTaxonomy );

            __MPC_EXIT_IF_METHOD_FAILS(hr, DeleteAllSubNodes( &subrs, ID_node, true  ));
            __MPC_EXIT_IF_METHOD_FAILS(hr, DeleteAllSubNodes( &subrs, ID_node, false ));
        }

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsTaxonomy->Delete()); STAT_DELETED( Taxonomy );

		//
		// Keep the node cache in sync.
		//
		NodeCache_Remove( ID_node );
    }
	else
	{
		STAT_NOOP( Taxonomy );
	}

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::LocateTaxonomyNode( /*[out]*/ long&   ID_node        ,
                                               /*[in ]*/ LPCWSTR szTaxonomyPath ,
                                               /*[in ]*/ bool    fLookForFather )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::LocateTaxonomyNode" );

    HRESULT            	   hr;
    MPC::WStringVector 	   vec;
    MPC::WStringVectorIter it;
	MPC::wstring           strPath;
	MPC::wstringUC         strPathUC;
	JetBlue::Id2NodeIter   itNode;
    long               	   idCurrent = -1;
    int                	   iLast;
    int                	   i;

    ID_node = -1;


    __MPC_EXIT_IF_METHOD_FAILS(hr, GetTaxonomy());

    __MPC_EXIT_IF_METHOD_FAILS(hr, Taxonomy::Settings::SplitNodePath( szTaxonomyPath, vec ));

	it    = vec.begin();
    iLast = vec.size (); if(fLookForFather) iLast--;

    for(i=0; i<iLast; i++, it++)
    {
		//
		// Build partial node path.
		//
		if(strPath.size()) strPath.append( L"/" );
		strPath.append( *it );

		//
		// If we are already seen the node, it's in the cache.
		//
		if(NodeCache_FindNode( strPathUC = strPath, itNode ))
		{
			idCurrent = itNode->second;
		}
		else
		{
			LPCWSTR szEntry = it->c_str();

			if(m_cache == NULL || FAILED(m_cache->LocateNode( m_ts, idCurrent, szEntry, *m_rsTaxonomy )))
			{
				__MPC_EXIT_IF_METHOD_FAILS(hr, m_rsTaxonomy->Seek_SubNode( idCurrent, szEntry ));
			}

			idCurrent = m_rsTaxonomy->m_ID_node;

			//
			// Update cache.
			//
			NodeCache_Add( strPathUC, idCurrent );
		}
    }

    ID_node = idCurrent;
    hr      = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::CreateTaxonomyNode( /*[out]*/ long&   ID_node        ,
                                               /*[in ]*/ LPCWSTR szTaxonomyPath ,
                                               /*[in ]*/ LPCWSTR szTitle        ,
                                               /*[in ]*/ LPCWSTR szDescription  ,
                                               /*[in ]*/ LPCWSTR szURI          ,
                                               /*[in ]*/ LPCWSTR szIconURI      ,
                                               /*[in ]*/ bool    fVisible       ,
                                               /*[in ]*/ bool    fSubsite       ,
                                               /*[in ]*/ long    lNavModel      ,
                                               /*[in ]*/ long    lPos           )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::CreateTaxonomyNode" );

    HRESULT hr;
    LPCWSTR szEntry;
    long    ID_parent;
	bool    fFound;

    ID_node = -1;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(szTaxonomyPath);
    __MPC_PARAMCHECK_END();

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetTaxonomy());


    __MPC_EXIT_IF_METHOD_FAILS(hr, LocateTaxonomyNode( ID_parent, szTaxonomyPath, true ));

    //
    // Extract the last component of the Category.
    //
    if((szEntry = wcsrchr( szTaxonomyPath, '/' )))
    {
        szEntry++;
    }
    else
    {
        szEntry = szTaxonomyPath;
    }


	__MPC_EXIT_IF_METHOD_FAILS(hr, m_rsTaxonomy->Seek_SubNode( ID_parent, szEntry, &fFound ));
	if(fFound && m_rsTaxonomy->m_ID_owner != m_ID_owner)
	{
		__MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_ACCESS_DENIED);
	}

	JET_SET_FIELD_TRISTATE(m_rsTaxonomy,m_ID_parent        ,m_fValid__ID_parent     ,  ID_parent    ,(ID_parent != -1             ));
	JET_SET_FIELD         (m_rsTaxonomy,m_ID_owner                                  ,m_ID_owner                                    );
	JET_SET_FIELD         (m_rsTaxonomy,m_strEntry                                  ,  szEntry                                     );
	JET_SET_FIELD_TRISTATE(m_rsTaxonomy,m_strTitle         ,m_fValid__Title         ,  szTitle      ,STRINGISPRESENT(szTitle      ));
	JET_SET_FIELD_TRISTATE(m_rsTaxonomy,m_strDescription   ,m_fValid__Description   ,  szDescription,STRINGISPRESENT(szDescription));
	JET_SET_FIELD_TRISTATE(m_rsTaxonomy,m_strDescriptionURI,m_fValid__DescriptionURI,  szURI        ,STRINGISPRESENT(szURI        ));
	JET_SET_FIELD_TRISTATE(m_rsTaxonomy,m_strIconURI       ,m_fValid__IconURI       ,  szIconURI    ,STRINGISPRESENT(szIconURI    ));
	JET_SET_FIELD         (m_rsTaxonomy,m_fVisible                                  ,  fVisible                                    );
	JET_SET_FIELD         (m_rsTaxonomy,m_fSubsite                                  ,  fSubsite                                    );
	JET_SET_FIELD         (m_rsTaxonomy,m_lNavModel                                 ,  lNavModel                                   );

	if(fFound)
	{
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsTaxonomy->Update()); STAT_MODIFIED( Taxonomy );
	}
	else
	{
	    //
	    // Respect the positioning attributes only if the Node doesn't already exist.
	    //
	    JET_SET_FIELD(m_rsTaxonomy, m_lPos, lPos);
		__MPC_EXIT_IF_METHOD_FAILS(hr, m_rsTaxonomy->Insert()); STAT_CREATED( Taxonomy );
	}

	ID_node = m_rsTaxonomy->m_ID_node;

	{
		JetBlue::Node2IdIter itId;

		if(NodeCache_FindId( ID_parent, itId ))
		{
			MPC::wstring strPath = itId->second;

			strPath.append( L"/"    );
			strPath.append( szEntry );

			//
			// Update cache.
			//
			NodeCache_Add( MPC::wstringUC( strPath ), ID_node );
		}
	}

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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

HRESULT Taxonomy::Updater::DeleteTopicEntry( /*[in]*/ long ID_topic )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::DeleteTopicEntry" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetTopics ());
    __MPC_EXIT_IF_METHOD_FAILS(hr, GetMatches());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsTopics->Seek_SingleTopic( ID_topic, &fFound ));
    if(fFound)
    {
        if(m_rsTopics->m_ID_owner != m_ID_owner)
        {
            __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_ACCESS_DENIED);
        }

        __MPC_EXIT_IF_METHOD_FAILS(hr, DeleteAllMatchesPointingToTopic( m_rsMatches, ID_topic ));

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsTopics->Delete()); STAT_DELETED( Topics );
    }
	else
	{
		STAT_NOOP( Topics );
	}


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::LocateTopicEntry( /*[out]*/ long&   ID_topic    ,
                                             /*[in ]*/ long    ID_node     ,
                                             /*[in ]*/ LPCWSTR szURI       ,
                                             /*[in ]*/ bool    fCheckOwner )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::LocateTopicEntry" );

    HRESULT hr;
    bool    fFound;

    ID_topic = -1;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetTopics());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsTopics->Seek_TopicsUnderNode( ID_node, &fFound ));
    while(fFound)
    {
        if(!MPC::StrICmp( m_rsTopics->m_strURI, szURI ))
        {
            if(fCheckOwner && m_rsTopics->m_ID_owner != m_ID_owner)
            {
                __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_ACCESS_DENIED);
            }

            ID_topic = m_rsTopics->m_ID_topic;
            break;
        }

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




    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::CreateTopicEntry( /*[out]*/ long&   ID_topic      ,
                                             /*[in]*/  long    ID_node       ,
                                             /*[in]*/  LPCWSTR szTitle       ,
                                             /*[in]*/  LPCWSTR szURI         ,
                                             /*[in]*/  LPCWSTR szDescription ,
                                             /*[in]*/  LPCWSTR szIconURI     ,
                                             /*[in]*/  long    lType         ,
                                             /*[in]*/  bool    fVisible      ,
                                             /*[in]*/  long    lPos          )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::CreateTopicEntry" );

    HRESULT hr;
    bool    fFound;

    ID_topic = -1;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(szTitle);
        __MPC_PARAMCHECK_NOTNULL(szURI);
    __MPC_PARAMCHECK_END();

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetTopics());


    __MPC_EXIT_IF_METHOD_FAILS(hr, LocateTopicEntry( ID_topic, ID_node, szURI, /*fCheckOwner*/true ));

    JET_SET_FIELD         (m_rsTopics,m_ID_node                             ,  ID_node                                     );
    JET_SET_FIELD         (m_rsTopics,m_ID_owner                            ,m_ID_owner                                    );
    JET_SET_FIELD_TRISTATE(m_rsTopics,m_strTitle      ,m_fValid__Title      ,  szTitle      ,STRINGISPRESENT(szTitle      ));
    JET_SET_FIELD_TRISTATE(m_rsTopics,m_strURI        ,m_fValid__URI        ,  szURI        ,STRINGISPRESENT(szURI        ));
    JET_SET_FIELD_TRISTATE(m_rsTopics,m_strDescription,m_fValid__Description,  szDescription,STRINGISPRESENT(szDescription));
    JET_SET_FIELD_TRISTATE(m_rsTopics,m_strIconURI    ,m_fValid__IconURI    ,  szIconURI    ,STRINGISPRESENT(szIconURI    ));
    JET_SET_FIELD         (m_rsTopics,m_lType                               ,  lType                                       );
    JET_SET_FIELD         (m_rsTopics,m_lPos                                ,  lPos                                        );
    JET_SET_FIELD         (m_rsTopics,m_fVisible                            ,  fVisible                                    );


    if(ID_topic == -1)
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsTopics->Insert()); STAT_CREATED( Topics );

        ID_topic = m_rsTopics->m_ID_topic;
    }
    else
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsTopics->Update()); STAT_MODIFIED( Topics );
    }


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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

HRESULT Taxonomy::Updater::CreateMatch( /*[in]*/ LPCWSTR szKeyword ,
                                        /*[in]*/ long    ID_topic  ,
										/*[in]*/ long    lPriority ,
                                        /*[in]*/ bool    fHHK      )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::CreateMatch" );

    HRESULT hr;
    bool    fFound;

    __MPC_EXIT_IF_METHOD_FAILS(hr, GetKeywords());
    __MPC_EXIT_IF_METHOD_FAILS(hr, GetMatches ());


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsKeywords->Seek_ByName( szKeyword, &fFound ));
    if(fFound == false)
    {
        JET_SET_FIELD(m_rsKeywords,m_strKeyword,szKeyword);

        __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsKeywords->Insert()); STAT_CREATED( Keywords );
    }


    JET_SET_FIELD(m_rsMatches,m_ID_topic  ,ID_topic                  );
    JET_SET_FIELD(m_rsMatches,m_ID_keyword,m_rsKeywords->m_ID_keyword);
    JET_SET_FIELD(m_rsMatches,m_lPriority ,lPriority                 );
    JET_SET_FIELD(m_rsMatches,m_fHHK      ,fHHK                      );


	__MPC_EXIT_IF_METHOD_FAILS(hr, m_rsMatches->Seek_Pair( m_rsKeywords->m_ID_keyword, ID_topic, &fFound ));
	if(fFound)
	{
		if(m_rsMatches->m_lPriority != lPriority ||
		   m_rsMatches->m_fHHK      != fHHK       )
		{
			JET_SET_FIELD(m_rsMatches,m_lPriority,lPriority);
			JET_SET_FIELD(m_rsMatches,m_fHHK     ,fHHK     );

			__MPC_EXIT_IF_METHOD_FAILS(hr, m_rsMatches->Update()); STAT_MODIFIED( Matches );
		}
		else
		{
			STAT_NOOP( Matches );
		}
	}
	else
	{
		__MPC_EXIT_IF_METHOD_FAILS(hr, m_rsMatches->Insert()); STAT_CREATED( Matches );
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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

HRESULT Taxonomy::Updater::MakeRoomForInsert( /*[in ]*/ LPCWSTR szNodeStr ,
                                              /*[in ]*/ LPCWSTR szMode    ,
                                              /*[in ]*/ LPCWSTR szID      ,
                                              /*[out]*/ long&   lPos      )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::MakeRoomForInsert" );

    HRESULT      hr;
    QueryResults qr( *this );
    long         ID_node;


    lPos = -1;


	__MPC_EXIT_IF_METHOD_FAILS(hr, LocateTaxonomyNode( ID_node, szNodeStr, false ));

	__MPC_EXIT_IF_METHOD_FAILS(hr, qr.MakeRoomForInsert( szMode, szID, ID_node, lPos ));

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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

    HRESULT hr;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_cache);
    __MPC_PARAMCHECK_END();


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


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

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

    HRESULT hr;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_NOTNULL(m_cache);
    __MPC_PARAMCHECK_END();


    __MPC_EXIT_IF_METHOD_FAILS(hr, m_cache->LocateNodesFromURL( m_ts, szURL, res ));


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::LookupNode( /*[in]*/ LPCWSTR                    szNodeStr ,
                                       /*[in]*/ CPCHQueryResultCollection* pColl     )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::LookupNode" );

    HRESULT                  hr;
    OfflineCache::Entry_Type et = OfflineCache::ET_NODE;
    QueryResults             qr( *this );
    long                     ID_node;
    MPC::wstring             strParent;

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


    if(m_fUseCache && m_cache && SUCCEEDED(m_cache->RetrieveQuery( m_ts, szNodeStr, et, pColl )))
    {
        __MPC_SET_ERROR_AND_EXIT(hr, S_OK);
    }

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

    //
    // Find the father of the node.
    //
    if(szNodeStr)
    {
        LPCWSTR szEnd = wcsrchr( szNodeStr, '/' );

        if(szEnd)
        {
            strParent.assign( szNodeStr, szEnd );
        }
        else
        {
            ; // Root
        }
    }


    __MPC_EXIT_IF_METHOD_FAILS(hr, LocateTaxonomyNode( ID_node, szNodeStr, false ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, qr.Append( m_rsTaxonomy, strParent.c_str() ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, qr.PopulateCollection( pColl ));


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

    if(m_fUseCache && m_cache && FAILED(m_cache->StoreQuery( m_ts, szNodeStr, et, pColl )))
    {
        ; // Cache failures are not fatal, don't abort.
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::LookupSubNodes( /*[in]*/ LPCWSTR                    szNodeStr    ,
                                           /*[in]*/ bool                       fVisibleOnly ,
                                           /*[in]*/ CPCHQueryResultCollection* pColl        )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::LookupSubNodes" );

    HRESULT                  hr;
    OfflineCache::Entry_Type et = fVisibleOnly ? OfflineCache::ET_SUBNODES_VISIBLE : OfflineCache::ET_SUBNODES;
    QueryResults             qr( *this );
    long                     ID_node;

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


    if(m_fUseCache && m_cache && SUCCEEDED(m_cache->RetrieveQuery( m_ts, szNodeStr, et, pColl )))
    {
        __MPC_SET_ERROR_AND_EXIT(hr, S_OK);
    }

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

    __MPC_EXIT_IF_METHOD_FAILS(hr, LocateTaxonomyNode( ID_node, szNodeStr, false ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, qr.LookupNodes( szNodeStr, ID_node, fVisibleOnly ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, qr.PopulateCollection( pColl ));

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

    if(m_fUseCache && m_cache && FAILED(m_cache->StoreQuery( m_ts, szNodeStr, et, pColl )))
    {
        ; // Cache failures are not fatal, don't abort.
    }


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::LookupNodesAndTopics( /*[in]*/ LPCWSTR                    szNodeStr    ,
                                                 /*[in]*/ bool                       fVisibleOnly ,
                                                 /*[in]*/ CPCHQueryResultCollection* pColl        )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::LookupNodesAndTopics" );

    HRESULT                  hr;
    OfflineCache::Entry_Type et = fVisibleOnly ? OfflineCache::ET_NODESANDTOPICS_VISIBLE : OfflineCache::ET_NODESANDTOPICS;
    QueryResults             qr( *this );
    long                     ID_node;

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


    if(m_fUseCache && m_cache && SUCCEEDED(m_cache->RetrieveQuery( m_ts, szNodeStr, et, pColl )))
    {
        __MPC_SET_ERROR_AND_EXIT(hr, S_OK);
    }

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

    __MPC_EXIT_IF_METHOD_FAILS(hr, LocateTaxonomyNode( ID_node, szNodeStr, false ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, qr.LookupNodes ( szNodeStr, ID_node, fVisibleOnly ));
    __MPC_EXIT_IF_METHOD_FAILS(hr, qr.LookupTopics( szNodeStr, ID_node, fVisibleOnly ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, qr.PopulateCollection( pColl ));

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

    if(m_fUseCache && m_cache && FAILED(m_cache->StoreQuery( m_ts, szNodeStr, et, pColl )))
    {
        ; // Cache failures are not fatal, don't abort.
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::LookupTopics( /*[in]*/ LPCWSTR                    szNodeStr    ,
                                         /*[in]*/ bool                       fVisibleOnly ,
                                         /*[in]*/ CPCHQueryResultCollection* pColl        )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::LookupTopics" );

    HRESULT                  hr;
    OfflineCache::Entry_Type et = fVisibleOnly ? OfflineCache::ET_TOPICS_VISIBLE : OfflineCache::ET_TOPICS;
    QueryResults             qr( *this );
    long                     ID_node;

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


    if(m_fUseCache && m_cache && SUCCEEDED(m_cache->RetrieveQuery( m_ts, szNodeStr, et, pColl )))
    {
        __MPC_SET_ERROR_AND_EXIT(hr, S_OK);
    }

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

    __MPC_EXIT_IF_METHOD_FAILS(hr, LocateTaxonomyNode( ID_node, szNodeStr, false ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, qr.LookupTopics( szNodeStr, ID_node, fVisibleOnly ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, qr.PopulateCollection( pColl ));

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

    if(m_fUseCache && m_cache && FAILED(m_cache->StoreQuery( m_ts, szNodeStr, et, pColl )))
    {
        ; // Cache failures are not fatal, don't abort.
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::LocateContext( /*[in]*/ LPCWSTR                    szURL     ,
                                          /*[in]*/ LPCWSTR                    szSubSite ,
                                          /*[in]*/ CPCHQueryResultCollection* pColl     )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::LocateContext" );

    HRESULT             hr;
    QueryResults        qr( *this );
    Taxonomy::MatchSet  setNodes;
    Taxonomy::MatchSet  setNodes2;
	Taxonomy::MatchIter it2;
    MPC::wstring        strURL;
    MPC::wstring        strPath;
	long                ID_node;
    bool                fFound;

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


	SANITIZEWSTR(szSubSite);


    __MPC_EXIT_IF_METHOD_FAILS(hr, GetTopics());


    __MPC_EXIT_IF_METHOD_FAILS(hr, CollapseURL( strURL = szURL ));

    //
    // Locate the subsite.
    //
	__MPC_EXIT_IF_METHOD_FAILS(hr, LocateTaxonomyNode( ID_node, szSubSite, false ));

	//
	// Create the set of nodes in the subsite.
	//
	setNodes.insert( ID_node ); // Add the node itself.
	__MPC_EXIT_IF_METHOD_FAILS(hr, LocateSubNodes( ID_node, /*fRecurse*/true, /*fOnlyVisible*/true, setNodes ));

	//
	// Also create the set of nodes matching the URL.
	//
	__MPC_EXIT_IF_METHOD_FAILS(hr, LocateNodesFromURL( strURL.c_str(), setNodes2 ));


    //
    // For all the topics matching the URL, create an entry.
    //
    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsTopics->Seek_ByURI( strURL.c_str(), &fFound ));
    while(fFound)
    {
        long ID_node = m_rsTopics->m_ID_node;

        if(setNodes.find( ID_node ) != setNodes.end())
        {
            if(m_fUseCache && m_cache)
            {
                __MPC_EXIT_IF_METHOD_FAILS(hr, m_cache->BuildNodePath( m_ts, ID_node, strPath, /*fParent*/false ));
            }

            __MPC_EXIT_IF_METHOD_FAILS(hr, qr.Append( m_rsTopics, strPath.c_str() ));
        }

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

    }

    //
    // For all the nodes matching the URL, create an entry.
    //
	for(it2 = setNodes2.begin(); it2 != setNodes2.end(); it2++)
	{
        long ID_node = *it2;

        if(setNodes.find( ID_node ) != setNodes.end())
        {
            if(m_fUseCache && m_cache)
            {
                __MPC_EXIT_IF_METHOD_FAILS(hr, m_cache->BuildNodePath( m_ts, ID_node, strPath, /*fParent*/false ));
            }

            __MPC_EXIT_IF_METHOD_FAILS(hr, qr.Append( m_rsTopics, strPath.c_str() ));
        }
	}


    __MPC_EXIT_IF_METHOD_FAILS(hr, qr.PopulateCollection( pColl ));

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::KeywordSearch( /*[in]*/ LPCWSTR                    szQueryStr ,
                                          /*[in]*/ LPCWSTR                    szSubSite  ,
                                          /*[in]*/ CPCHQueryResultCollection* pColl      ,
										  /*[in]*/ MPC::WStringList*          lst        )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::KeywordSearch" );

    HRESULT                 hr;
    Taxonomy::KeywordSearch ks( *this );

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


    __MPC_EXIT_IF_METHOD_FAILS(hr, ks.Execute( szQueryStr, szSubSite, pColl, lst ));

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}


HRESULT Taxonomy::Updater::GatherNodes( /*[in]*/ LPCWSTR                    szNodeStr    ,
                                        /*[in]*/ bool                       fVisibleOnly ,
                                        /*[in]*/ CPCHQueryResultCollection* pColl        )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GatherNodes" );

    HRESULT      hr;
    QueryResults qr( *this );
    MatchSet     setNodes;
    long         ID_node;
    bool         fFound;

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


    __MPC_EXIT_IF_METHOD_FAILS(hr, LocateTaxonomyNode( ID_node, szNodeStr, /*fLookForFather*/false                         ));
    __MPC_EXIT_IF_METHOD_FAILS(hr, LocateSubNodes    ( ID_node,            /*fRecurse      */true , fVisibleOnly, setNodes ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsTaxonomy->Move( 0, JET_MoveFirst, &fFound ));
    while(fFound)
    {
        if(fVisibleOnly == false || m_rsTaxonomy->m_fVisible)
        {
            if(setNodes.find( m_rsTaxonomy->m_ID_node ) != setNodes.end())
            {
                MPC::wstring strPath;

                if(m_fUseCache && m_cache)
                {
                    __MPC_EXIT_IF_METHOD_FAILS(hr, m_cache->BuildNodePath( m_ts, m_rsTaxonomy->m_ID_node, strPath, /*fParent*/true ));
                }

                __MPC_EXIT_IF_METHOD_FAILS(hr, qr.Append( m_rsTaxonomy, strPath.c_str() ));
            }
        }

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

    __MPC_EXIT_IF_METHOD_FAILS(hr, qr.PopulateCollection( pColl ));

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT Taxonomy::Updater::GatherTopics( /*[in]*/ LPCWSTR                    szNodeStr    ,
                                         /*[in]*/ bool                       fVisibleOnly ,
                                         /*[in]*/ CPCHQueryResultCollection* pColl        )
{
    __HCP_FUNC_ENTRY( "Taxonomy::Updater::GatherTopics" );

    HRESULT            hr;
    Taxonomy::MatchSet setNodes;
    QueryResults       qr( *this );
    long               ID_node;
    bool               fFound;

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


    __MPC_EXIT_IF_METHOD_FAILS(hr, GetTopics());

    __MPC_EXIT_IF_METHOD_FAILS(hr, LocateTaxonomyNode( ID_node, szNodeStr, /*fLookForFather*/false                         ));
    __MPC_EXIT_IF_METHOD_FAILS(hr, LocateSubNodes    ( ID_node,            /*fRecurse      */true , fVisibleOnly, setNodes ));
    setNodes.insert( ID_node ); // Add the node itself.

    //
    // Create an entry for each topic.
    //
    __MPC_EXIT_IF_METHOD_FAILS(hr, m_rsTopics->Move( 0, JET_MoveFirst, &fFound ));
    while(fFound)
    {
        if(fVisibleOnly == false || m_rsTopics->m_fVisible)
        {
            if(setNodes.find( m_rsTopics->m_ID_node ) != setNodes.end())
            {
                MPC::wstring strPath;

                if(m_fUseCache && m_cache)
                {
                    __MPC_EXIT_IF_METHOD_FAILS(hr, m_cache->BuildNodePath( m_ts, m_rsTaxonomy->m_ID_node, strPath, /*fParent*/false ));
                }

                __MPC_EXIT_IF_METHOD_FAILS(hr, qr.Append( m_rsTopics, strPath.c_str() ));
            }
        }

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

    __MPC_EXIT_IF_METHOD_FAILS(hr, qr.PopulateCollection( pColl ));

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}