You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
459 lines
14 KiB
459 lines
14 KiB
/********************************************************************
|
|
|
|
Copyright (c) 1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
ParamConfig.cpp
|
|
|
|
Abstract:
|
|
Implements the class CParamList that contains methods for traversing the elements
|
|
of XML file that contains the parameters required by the search engine. A sample parameter list
|
|
(also known as config file) XML file if shown here -
|
|
|
|
<?xml version="1.0" encoding="UTF-8"?>
|
|
<CONFIG_DATA
|
|
|
|
SERVER_URL = "http://gsadevnet/GSASearch/search.asmx/Search"
|
|
REMOTECONFIG_SERVER_URL = "http://gsadevnet/GSASearch/search.asmx/"
|
|
UPDATE_FREQUENCY = "3">
|
|
|
|
<PARAM_ITEM NAME="ProdID" TYPE="CONFIG_DATA">
|
|
|
|
<DESCRIPTION>Choose one of the following products:</DESCRIPTION>
|
|
<PARAM_VALUE VALUE="enable">
|
|
<DISPLAYSTRING>Accessibility</DISPLAYSTRING>
|
|
</PARAM_VALUE>
|
|
|
|
<PARAM_VALUE VALUE="drx" DEFAULT="true">
|
|
<DISPLAYSTRING>DirectX (Home User)</DISPLAYSTRING>
|
|
</PARAM_VALUE>
|
|
|
|
</PARAM_ITEM>
|
|
|
|
</CONFIG_DATA>
|
|
|
|
Revision History:
|
|
a-prakac created 12/05/2000
|
|
|
|
********************************************************************/
|
|
|
|
|
|
#include "stdafx.h"
|
|
|
|
static const WCHAR g_wszMutexName[] = L"PCH_PARAMCONFIG";
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
CFG_BEGIN_FIELDS_MAP(CParamList::CParamValue)
|
|
CFG_ATTRIBUTE( L"VALUE" , BSTR, m_bstrValue ),
|
|
CFG_ELEMENT ( L"DISPLAYSTRING", BSTR, m_bstrDisplayString ),
|
|
CFG_ATTRIBUTE( L"DEFAULT" , bool, m_bDefault ),
|
|
CFG_END_FIELDS_MAP()
|
|
|
|
CFG_BEGIN_CHILD_MAP(CParamList::CParamValue)
|
|
CFG_END_CHILD_MAP()
|
|
|
|
DEFINE_CFG_OBJECT(CParamList::CParamValue, L"PARAM_VALUE")
|
|
|
|
DEFINE_CONFIG_METHODS__NOCHILD(CParamList::CParamValue)
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
CFG_BEGIN_FIELDS_MAP(CParamList::CParamItem)
|
|
CFG_ATTRIBUTE( L"NAME" , BSTR, m_bstrName ),
|
|
CFG_ATTRIBUTE( L"TYPE" , BSTR, m_bstrType ),
|
|
CFG_ELEMENT ( L"DESCRIPTION", BSTR, m_bstrDescription ),
|
|
CFG_ATTRIBUTE( L"REQUIRED" , bool, m_bRequired ),
|
|
CFG_ATTRIBUTE( L"VISIBLE" , bool, m_bVisible ),
|
|
CFG_END_FIELDS_MAP()
|
|
|
|
CFG_BEGIN_CHILD_MAP(CParamList::CParamItem)
|
|
CFG_CHILD(CParamList::CParamValue)
|
|
CFG_END_CHILD_MAP()
|
|
|
|
DEFINE_CFG_OBJECT(CParamList::CParamItem, L"PARAM_ITEM")
|
|
|
|
DEFINE_CONFIG_METHODS_CREATEINSTANCE_SECTION(CParamList::CParamItem,tag,defSubType)
|
|
if(tag == _cfg_table_tags[0])
|
|
{
|
|
defSubType = &(*(m_lstParamValue.insert( m_lstParamValue.end() )));
|
|
return S_OK;
|
|
}
|
|
DEFINE_CONFIG_METHODS_SAVENODE_SECTION(CParamList::CParamItem,xdn)
|
|
hr = MPC::Config::SaveList( m_lstParamValue, xdn );
|
|
DEFINE_CONFIG_METHODS_END(CParamList::CParamItem)
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
CFG_BEGIN_FIELDS_MAP(CParamList)
|
|
CFG_ATTRIBUTE ( L"SERVER_URL" , BSTR, m_bstrServerURL ),
|
|
CFG_ELEMENT ( L"SEARCHENGINE_NAME" , BSTR, m_bstrSearchEngineName ),
|
|
CFG_ELEMENT ( L"SEARCHENGINE_DESCRIPTION", BSTR, m_bstrSearchEngineDescription ),
|
|
CFG_ELEMENT ( L"SEARCHENGINE_OWNER" , BSTR, m_bstrSearchEngineOwner ),
|
|
CFG_ATTRIBUTE ( L"UPDATE_FREQUENCY" , long, m_lUpdateFrequency ),
|
|
CFG_ATTRIBUTE__TRISTATE( L"REMOTECONFIG_SERVER_URL" , BSTR, m_bstrRemoteConfigServerURL , m_bRemoteServerUrlPresent ),
|
|
CFG_ATTRIBUTE__TRISTATE( L"ERROR_INFO" , BSTR, m_bstrErrorInfo , m_bError ),
|
|
CFG_ATTRIBUTE__TRISTATE( L"STANDARD_SEARCH" , bool, m_bStandardSearch , m_bSearchTypePresent ),
|
|
CFG_END_FIELDS_MAP()
|
|
|
|
CFG_BEGIN_CHILD_MAP(CParamList)
|
|
CFG_CHILD(CParamList::CParamItem)
|
|
CFG_END_CHILD_MAP()
|
|
|
|
DEFINE_CFG_OBJECT(CParamList, L"CONFIG_DATA")
|
|
|
|
DEFINE_CONFIG_METHODS_CREATEINSTANCE_SECTION(CParamList,tag,defSubType)
|
|
if(tag == _cfg_table_tags[0])
|
|
{
|
|
defSubType = &(*(m_lstParamItem.insert( m_lstParamItem.end() )));
|
|
return S_OK;
|
|
}
|
|
DEFINE_CONFIG_METHODS_SAVENODE_SECTION(CParamList,xdn)
|
|
hr = MPC::Config::SaveList( m_lstParamItem, xdn );
|
|
DEFINE_CONFIG_METHODS_END(CParamList)
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
bool CParamList::CParamItem::FindDefaultValue( /*[out]*/ ParamValueIter& it )
|
|
{
|
|
for(it = m_lstParamValue.begin(); it != m_lstParamValue.end(); it++)
|
|
{
|
|
if(it->m_bDefault == true) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
// Commenting out MPC:: is a workaround for a compiler bug.
|
|
CParamList::CParamList() : /*MPC::*/NamedMutex( g_wszMutexName )
|
|
{
|
|
// Initialize the Update Frequency to -1 so that in case the server hasnt provided an update frequency
|
|
// then the default frequency can be used instead
|
|
m_lUpdateFrequency = -1;
|
|
m_bStandardSearch = true;
|
|
}
|
|
|
|
CParamList::~CParamList()
|
|
{
|
|
}
|
|
|
|
bool CParamList::IsStandardSearch()
|
|
{
|
|
return (m_bSearchTypePresent ? m_bStandardSearch : true);
|
|
}
|
|
|
|
/************
|
|
|
|
Method - CParamList::Load(BSTR bstrConfigFilePath)
|
|
|
|
Description - This method loads the XML file (whose location is given bstrConfigFilePath)
|
|
into a list and sets the iterator of the list to the first element in the list. It then loads the XML file
|
|
into a DOM tree and retrieves a collection of nodes with tag name PARAM_ITEM.
|
|
|
|
************/
|
|
|
|
HRESULT CParamList::Load( /*[in]*/ BSTR bstrLCID, /*[in]*/ BSTR bstrID, /*[in]*/ BSTR bstrXMLConfigData )
|
|
{
|
|
__HCP_FUNC_ENTRY( "CParamList::Load" );
|
|
|
|
HRESULT hr;
|
|
bool fLoaded;
|
|
bool fFound;
|
|
MPC::XmlUtil xmlConfigData;
|
|
CComPtr<IStream> pStream;
|
|
MPC::wstring strFileName;
|
|
CComPtr<IXMLDOMNode> ptrDOMNode;
|
|
CComBSTR bstrXML;
|
|
|
|
|
|
//
|
|
// First try to load the file from the user setting path - if that fails then load the ConfigData
|
|
// The file, if present, is located in user settings directory and is named bstrID_bstrLCID.xml
|
|
//
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, MPC::GetUserWritablePath( strFileName, HC_ROOT_HELPCTR ));
|
|
m_bstrConfigFilePath.Append( strFileName.c_str() );
|
|
m_bstrConfigFilePath.Append( L"\\" );
|
|
m_bstrConfigFilePath.Append( bstrID );
|
|
m_bstrConfigFilePath.Append( L"_" );
|
|
m_bstrConfigFilePath.Append( bstrLCID );
|
|
m_bstrConfigFilePath.Append( L".xml" );
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xmlConfigData.Load( m_bstrConfigFilePath, NSW_TAG_CONFIGDATA, fLoaded, &fFound ));
|
|
if(!fFound)
|
|
{
|
|
// The file could not be loaded for some reason - try loading the package_description.xml data
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xmlConfigData.LoadAsString( bstrXMLConfigData, NSW_TAG_DATA, fLoaded, &fFound ));
|
|
if(!fFound)
|
|
{
|
|
// Even if this cant be loaded then exit
|
|
__MPC_SET_ERROR_AND_EXIT(hr, S_OK);
|
|
}
|
|
|
|
// Now load the CONFIG_DATA section
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xmlConfigData.GetNode( NSW_TAG_CONFIGDATA, &ptrDOMNode ) );
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, ptrDOMNode->get_xml( &bstrXML ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xmlConfigData.LoadAsString( bstrXML, NSW_TAG_CONFIGDATA, fLoaded, &fFound ));
|
|
if(!fFound)
|
|
{
|
|
// Cant be loaded - exit
|
|
__MPC_SET_ERROR_AND_EXIT(hr, S_OK);
|
|
}
|
|
|
|
}
|
|
|
|
// At this point the XML data has been loaded
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xmlConfigData.SaveAsStream( (IUnknown**)&pStream ));
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, MPC::Config::LoadStream ( this, pStream ));
|
|
|
|
//
|
|
// For each parameter, copy the XML blob.
|
|
//
|
|
{
|
|
CComPtr<IXMLDOMNodeList> xdnl;
|
|
CComPtr<IXMLDOMNode> xdn;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xmlConfigData.GetNodes( NSW_TAG_PARAMITEM, &xdnl ));
|
|
if(xdnl)
|
|
{
|
|
for(ParamItemIter it = m_lstParamItem.begin(); it != m_lstParamItem.end() && SUCCEEDED(xdnl->nextNode( &xdn )) && xdn; it++, xdn.Release())
|
|
{
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xdn->get_xml( &it->m_bstrXML ));
|
|
}
|
|
}
|
|
}
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, MoveFirst());
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__HCP_FUNC_CLEANUP;
|
|
|
|
__HCP_FUNC_EXIT(hr);
|
|
}
|
|
|
|
/************
|
|
|
|
Method - CParamList::IsCursorValid(), MoveFirst(), MoveNext()
|
|
|
|
Description - These methods are used to traverse the list that contains the various XML elements of the
|
|
loaded file.
|
|
|
|
************/
|
|
|
|
HRESULT CParamList::ClearResults()
|
|
{
|
|
__HCP_FUNC_ENTRY( "CParamList::ClearResult" );
|
|
|
|
m_lstParamItem.clear();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
bool CParamList::IsCursorValid()
|
|
{
|
|
return (m_itCurrentParam != m_lstParamItem.end());
|
|
}
|
|
|
|
HRESULT CParamList::MoveFirst()
|
|
{
|
|
m_itCurrentParam = m_lstParamItem.begin();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CParamList::MoveNext()
|
|
{
|
|
if(IsCursorValid())
|
|
{
|
|
m_itCurrentParam++;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/************
|
|
|
|
Method - CParamList::get_Name, get_ServerUrl, get_ConfigFilePath, get_Type
|
|
|
|
Description - Properties for getting the corresponding items.
|
|
|
|
************/
|
|
|
|
HRESULT CParamList::get_Name( /*[out]*/ CComBSTR& bstrName )
|
|
{
|
|
if(IsCursorValid()) bstrName = m_itCurrentParam->m_bstrName;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CParamList::get_ServerUrl( /*[out]*/ CComBSTR& bstrServerURL )
|
|
{
|
|
bstrServerURL = m_bstrServerURL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CParamList::get_RemoteServerUrl( /*[out]*/ CComBSTR& bstrRemoteServerURL )
|
|
{
|
|
bstrRemoteServerURL = m_bstrRemoteConfigServerURL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
bool CParamList::RemoteConfig()
|
|
{
|
|
return m_bRemoteServerUrlPresent;
|
|
}
|
|
|
|
HRESULT CParamList::get_UpdateFrequency( /*[out]*/ long& lUpdateFrequency )
|
|
{
|
|
lUpdateFrequency = m_lUpdateFrequency;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CParamList::get_SearchEngineName(/*[out]*/ CComBSTR& bstrSEName )
|
|
{
|
|
bstrSEName = m_bstrSearchEngineName;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CParamList::get_SearchEngineDescription( /*[out]*/CComBSTR& bstrSEDescription )
|
|
{
|
|
bstrSEDescription = m_bstrSearchEngineDescription;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CParamList::get_SearchEngineOwner( /*[out]*/ CComBSTR& bstrSEOwner )
|
|
{
|
|
bstrSEOwner = m_bstrSearchEngineOwner;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CParamList::get_ConfigFilePath( /*[out]*/CComBSTR& bstrFilePath )
|
|
{
|
|
bstrFilePath = m_bstrConfigFilePath;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CParamList::get_Type( /*[in]*/ BSTR bstrType, /*[out]*/ ParamTypeEnum& enmParamType)
|
|
{
|
|
if (MPC::StrICmp( bstrType, L"PARAM_UI1" ) == 0) enmParamType = PARAM_UI1;
|
|
else if(MPC::StrICmp( bstrType, L"PARAM_I2" ) == 0) enmParamType = PARAM_I2;
|
|
else if(MPC::StrICmp( bstrType, L"PARAM_I4" ) == 0) enmParamType = PARAM_I4;
|
|
else if(MPC::StrICmp( bstrType, L"PARAM_R4" ) == 0) enmParamType = PARAM_R4;
|
|
else if(MPC::StrICmp( bstrType, L"PARAM_R8" ) == 0) enmParamType = PARAM_R8;
|
|
else if(MPC::StrICmp( bstrType, L"PARAM_BOOL" ) == 0) enmParamType = PARAM_BOOL;
|
|
else if(MPC::StrICmp( bstrType, L"PARAM_DATE" ) == 0) enmParamType = PARAM_DATE;
|
|
else if(MPC::StrICmp( bstrType, L"PARAM_BSTR" ) == 0) enmParamType = PARAM_BSTR;
|
|
else if(MPC::StrICmp( bstrType, L"PARAM_I1" ) == 0) enmParamType = PARAM_I1;
|
|
else if(MPC::StrICmp( bstrType, L"PARAM_UI2" ) == 0) enmParamType = PARAM_UI2;
|
|
else if(MPC::StrICmp( bstrType, L"PARAM_UI4" ) == 0) enmParamType = PARAM_UI4;
|
|
else if(MPC::StrICmp( bstrType, L"PARAM_INT" ) == 0) enmParamType = PARAM_INT;
|
|
else if(MPC::StrICmp( bstrType, L"PARAM_UINT" ) == 0) enmParamType = PARAM_UINT;
|
|
else if(MPC::StrICmp( bstrType, L"PARAM_LIST" ) == 0) enmParamType = PARAM_LIST;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/************
|
|
|
|
Method - CParamList::InitializeParamObject( SearchEngine::ParamItem_Definition2& def )
|
|
|
|
Description - This method is called to initialize a parameter item object. Initializes
|
|
with the current parameter item.
|
|
|
|
************/
|
|
HRESULT CParamList::InitializeParamObject( /*[out]*/ SearchEngine::ParamItem_Definition2& def )
|
|
{
|
|
__HCP_FUNC_ENTRY( "CParamList::InitializeParamObject" );
|
|
|
|
HRESULT hr;
|
|
|
|
if(IsCursorValid())
|
|
{
|
|
CParamItem& item = *m_itCurrentParam;
|
|
BSTR bstrData = NULL;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, get_Type( item.m_bstrType, def.m_pteParamType ));
|
|
|
|
if(def.m_pteParamType == PARAM_LIST)
|
|
{
|
|
bstrData = item.m_bstrXML;
|
|
}
|
|
else
|
|
{
|
|
ParamValueIter itValue;
|
|
|
|
if(m_itCurrentParam->FindDefaultValue( itValue ))
|
|
{
|
|
bstrData = itValue->m_bstrValue;
|
|
}
|
|
}
|
|
|
|
if(item.m_bstrName .Length()) { def.m_strName = item.m_bstrName ; def.m_szName = def.m_strName .c_str(); }
|
|
if(item.m_bstrDescription.Length()) { def.m_strDisplayString = item.m_bstrDescription; def.m_szDisplayString = def.m_strDisplayString.c_str(); }
|
|
if(STRINGISPRESENT(bstrData) ) { def.m_strData = bstrData ; def.m_szData = def.m_strData .c_str(); }
|
|
|
|
def.m_bRequired = item.m_bRequired;
|
|
def.m_bVisible = item.m_bVisible;
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__HCP_FUNC_CLEANUP;
|
|
|
|
__HCP_FUNC_EXIT(hr);
|
|
}
|
|
|
|
/************
|
|
|
|
Method - CParamList::GetDefaultValue (CComBSTR bstrParamName, MPC::wstring& wszValue)
|
|
|
|
Description - This method is called to get the default value for a parameter.
|
|
|
|
************/
|
|
HRESULT CParamList::GetDefaultValue( /*[in]*/ BSTR bstrParamName, /*[in,out]*/ MPC::wstring& strValue )
|
|
{
|
|
__HCP_FUNC_ENTRY("CParamList::GetDefaultValue");
|
|
|
|
HRESULT hr;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, MoveFirst());
|
|
while(IsCursorValid())
|
|
{
|
|
if(MPC::StrCmp( m_itCurrentParam->m_bstrName, bstrParamName ) == 0)
|
|
{
|
|
ParamValueIter itValue;
|
|
|
|
if(m_itCurrentParam->FindDefaultValue( itValue ))
|
|
{
|
|
strValue = SAFEBSTR(itValue->m_bstrValue);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, MoveNext());
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__HCP_FUNC_CLEANUP;
|
|
|
|
__HCP_FUNC_EXIT(hr);
|
|
}
|
|
|