691 lines
22 KiB
C++
691 lines
22 KiB
C++
/******************************************************************************
|
|
|
|
Copyright (c) 1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
Configuration.cpp
|
|
|
|
Abstract:
|
|
This file contains the implementation of the ...
|
|
|
|
Revision History:
|
|
Davide Massarenti (Dmassare) 01/09/2000
|
|
created
|
|
|
|
******************************************************************************/
|
|
|
|
#include "stdafx.h"
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
const MPC::Config::DefinitionOfTag* MPC::Config::DefinitionOfTag::FindSubTag( /*[in]*/ LPCWSTR szTag ) const
|
|
{
|
|
const DefinitionOfTag** ptr = m_tblSubTags;
|
|
|
|
if(ptr)
|
|
{
|
|
while(*ptr)
|
|
{
|
|
if(!MPC::StrICmp( (*ptr)->m_szTag, szTag ))
|
|
{
|
|
return (*ptr);
|
|
}
|
|
|
|
ptr++;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
const MPC::Config::DefinitionOfAttribute* MPC::Config::DefinitionOfTag::FindAttribute( /*[in]*/ XMLTypes xt, /*[in]*/ LPCWSTR szName ) const
|
|
{
|
|
const DefinitionOfAttribute* ptr = m_tblAttributes;
|
|
|
|
if(ptr)
|
|
{
|
|
while(ptr->m_xt != XT_invalid)
|
|
{
|
|
if(ptr->m_xt == xt)
|
|
{
|
|
if(ptr->m_xt == XT_value || !MPC::StrICmp( ptr->m_szName, szName )) return ptr;
|
|
}
|
|
|
|
ptr++;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void MPC::Config::ClearValue( /*[in]*/ TypeConstructor* defType ,
|
|
/*[in]*/ const DefinitionOfAttribute* defAttrib )
|
|
{
|
|
{
|
|
void* data = defType->GetOffset( defAttrib->m_offset );
|
|
VARTYPE dest;
|
|
|
|
switch(defAttrib->m_mtType)
|
|
{
|
|
case MT_bool : *(bool *)data = false ; break;
|
|
case MT_BOOL : *(BOOL *)data = FALSE ; break;
|
|
case MT_VARIANT_BOOL: *(VARIANT_BOOL*)data = VARIANT_FALSE; break;
|
|
case MT_int : *(int *)data = 0 ; break;
|
|
case MT_long : *(long *)data = 0 ; break;
|
|
case MT_DWORD : *(DWORD *)data = 0 ; break;
|
|
case MT_float : *(float *)data = 0 ; break;
|
|
case MT_double : *(double *)data = 0 ; break;
|
|
case MT_DATE : *(DATE *)data = 0 ; break;
|
|
case MT_DATE_US : *(DATE *)data = 0 ; break;
|
|
case MT_DATE_CIM : *(DATE *)data = 0 ; break;
|
|
case MT_CHAR : *(CHAR *)data = 0 ; break;
|
|
case MT_WCHAR : *(WCHAR *)data = 0 ; break;
|
|
case MT_BSTR : *(CComBSTR *)data = (LPCWSTR)NULL; break;
|
|
case MT_string : *(MPC::string *)data = "" ; break;
|
|
case MT_wstring : *(MPC::wstring*)data = L"" ; break;
|
|
case MT_bitfield : *(DWORD *)data = 0 ; break;
|
|
}
|
|
}
|
|
|
|
if(defAttrib->m_fPresenceFlag)
|
|
{
|
|
bool* data = (bool*)defType->GetOffset( defAttrib->m_offsetPresence );
|
|
|
|
*data = false;
|
|
}
|
|
}
|
|
|
|
HRESULT MPC::Config::LoadValue( /*[in]*/ TypeConstructor* defType ,
|
|
/*[in]*/ const DefinitionOfAttribute* defAttrib ,
|
|
/*[in/out]*/ CComVariant& value ,
|
|
/*[in]*/ bool fFound )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::Config::LoadValue" );
|
|
|
|
USES_CONVERSION;
|
|
|
|
HRESULT hr;
|
|
|
|
|
|
if(fFound)
|
|
{
|
|
void* data = defType->GetOffset( defAttrib->m_offset );
|
|
VARTYPE dest;
|
|
|
|
|
|
switch(defAttrib->m_mtType)
|
|
{
|
|
case MT_bool : dest = VT_BOOL ; break;
|
|
case MT_BOOL : dest = VT_BOOL ; break;
|
|
case MT_VARIANT_BOOL: dest = VT_BOOL ; break;
|
|
case MT_int : dest = VT_I4 ; break;
|
|
case MT_long : dest = VT_I4 ; break;
|
|
case MT_DWORD : dest = VT_I4 ; break;
|
|
case MT_float : dest = VT_R4 ; break;
|
|
case MT_double : dest = VT_R8 ; break;
|
|
case MT_DATE : dest = VT_ILLEGAL; break;
|
|
case MT_DATE_US : dest = VT_ILLEGAL; break;
|
|
case MT_DATE_CIM : dest = VT_ILLEGAL; break;
|
|
case MT_CHAR : dest = VT_BSTR ; break;
|
|
case MT_WCHAR : dest = VT_BSTR ; break;
|
|
case MT_BSTR : dest = VT_BSTR ; break;
|
|
case MT_string : dest = VT_BSTR ; break;
|
|
case MT_wstring : dest = VT_BSTR ; break;
|
|
case MT_bitfield : dest = VT_BSTR ; break;
|
|
default : __MPC_SET_ERROR_AND_EXIT(hr, E_INVALIDARG);
|
|
}
|
|
|
|
if(dest == VT_ILLEGAL)
|
|
{
|
|
LPCWSTR szDate;
|
|
bool fCIM = false;
|
|
LCID lcid = 0;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, value.ChangeType( VT_BSTR ));
|
|
szDate = value.bstrVal; SANITIZEWSTR(szDate);
|
|
|
|
switch(defAttrib->m_mtType)
|
|
{
|
|
case MT_DATE : fCIM = false; lcid = 0; break;
|
|
case MT_DATE_US : fCIM = false; lcid = -1; break;
|
|
case MT_DATE_CIM: fCIM = true ; lcid = 0; break;
|
|
}
|
|
|
|
|
|
//
|
|
// We try as much as we can to parse the date. First the expected format, then the US one, finally the user default.
|
|
//
|
|
if(FAILED(MPC::ConvertStringToDate( szDate, *(DATE*)data, /*fGMT*/false, fCIM, lcid )))
|
|
{
|
|
if(FAILED(MPC::ConvertStringToDate( szDate, *(DATE*)data, /*fGMT*/false, /*fCIM*/false, -1 )))
|
|
{
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, MPC::ConvertStringToDate( szDate, *(DATE*)data, /*fGMT*/false, /*fCIM*/false, 0 ));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, value.ChangeType( dest ));
|
|
|
|
switch(defAttrib->m_mtType)
|
|
{
|
|
case MT_bool : *(bool *)data = (value.boolVal == VARIANT_TRUE) ? true : false; break;
|
|
case MT_BOOL : *(BOOL *)data = (value.boolVal == VARIANT_TRUE) ? TRUE : FALSE; break;
|
|
case MT_VARIANT_BOOL: *(VARIANT_BOOL*)data = value.boolVal ; break;
|
|
case MT_int : *(int *)data = value.lVal ; break;
|
|
case MT_long : *(long *)data = value.lVal ; break;
|
|
case MT_DWORD : *(DWORD *)data = value.lVal ; break;
|
|
case MT_float : *(float *)data = value.fltVal ; break;
|
|
case MT_double : *(double *)data = value.dblVal ; break;
|
|
case MT_CHAR : *(CHAR *)data = value.bstrVal ? ( CHAR)value.bstrVal[0] : 0 ; break;
|
|
case MT_WCHAR : *(WCHAR *)data = value.bstrVal ? (WCHAR)value.bstrVal[0] : 0 ; break;
|
|
case MT_BSTR : *(CComBSTR *)data = value.bstrVal ; break;
|
|
case MT_string : *(MPC::string *)data = OLE2A(SAFEBSTR(value.bstrVal)) ; break;
|
|
case MT_wstring : *(MPC::wstring*)data = SAFEBSTR(value.bstrVal) ; break;
|
|
|
|
case MT_bitfield:
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, MPC::ConvertStringToBitField( value.bstrVal, *(DWORD*)data, defAttrib->m_Lookup, /*fUseTilde*/false ));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(defAttrib->m_fPresenceFlag)
|
|
{
|
|
bool* data = (bool*)defType->GetOffset( defAttrib->m_offsetPresence );
|
|
|
|
*data = fFound;
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::Config::SaveValue( /*[in]*/ const TypeConstructor* defType ,
|
|
/*[in]*/ const DefinitionOfAttribute* defAttrib ,
|
|
/*[out]*/ CComVariant& value ,
|
|
/*[out]*/ bool& fFound )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::Config::SaveValue" );
|
|
|
|
HRESULT hr;
|
|
|
|
|
|
if(defAttrib->m_fPresenceFlag)
|
|
{
|
|
bool* data = (bool*)defType->GetOffset( defAttrib->m_offsetPresence );
|
|
|
|
fFound = *data;
|
|
}
|
|
else
|
|
{
|
|
fFound = true;
|
|
}
|
|
|
|
value.Clear();
|
|
|
|
if(fFound)
|
|
{
|
|
const void* data = defType->GetOffset( defAttrib->m_offset );
|
|
VARTYPE src;
|
|
WCHAR rgBuf[2];
|
|
|
|
switch(defAttrib->m_mtType)
|
|
{
|
|
case MT_bool : value.boolVal = *(bool *)data ? VARIANT_TRUE : VARIANT_FALSE; src = VT_BOOL ; break;
|
|
case MT_BOOL : value.boolVal = *(BOOL *)data ? VARIANT_TRUE : VARIANT_FALSE; src = VT_BOOL ; break;
|
|
case MT_VARIANT_BOOL: value.boolVal = *(VARIANT_BOOL*)data ; src = VT_BOOL ; break;
|
|
case MT_int : value.lVal = *(int *)data ; src = VT_I4 ; break;
|
|
case MT_long : value.lVal = *(long *)data ; src = VT_I4 ; break;
|
|
case MT_DWORD : value.lVal = *(DWORD *)data ; src = VT_I4 ; break;
|
|
case MT_float : value.fltVal = *(float *)data ; src = VT_R4 ; break;
|
|
case MT_double : value.dblVal = *(double *)data ; src = VT_R8 ; break;
|
|
case MT_DATE : ; src = VT_ILLEGAL; break;
|
|
case MT_DATE_US : ; src = VT_ILLEGAL; break;
|
|
case MT_DATE_CIM : ; src = VT_ILLEGAL; break;
|
|
case MT_CHAR : rgBuf[0] = *(CHAR *)data; rgBuf[1] = 0; value = rgBuf ; src = VT_BSTR ; break;
|
|
case MT_WCHAR : rgBuf[0] = *(WCHAR *)data; rgBuf[1] = 0; value = rgBuf ; src = VT_BSTR ; break;
|
|
case MT_BSTR : value = *(CComBSTR *)data ; src = VT_BSTR ; break;
|
|
case MT_string : value = ((MPC::string *)data)->c_str() ; src = VT_BSTR ; break;
|
|
case MT_wstring : value = ((MPC::wstring*)data)->c_str() ; src = VT_BSTR ; break;
|
|
|
|
case MT_bitfield:
|
|
{
|
|
MPC::wstring strText;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, MPC::ConvertBitFieldToString( *(DWORD*)data, strText, defAttrib->m_Lookup ));
|
|
|
|
value = strText.c_str(); src = VT_BSTR;
|
|
}
|
|
break;
|
|
|
|
default: __MPC_SET_ERROR_AND_EXIT(hr, E_INVALIDARG);
|
|
}
|
|
|
|
if(src == VT_ILLEGAL)
|
|
{
|
|
MPC::wstring strDate;
|
|
bool fCIM = false;
|
|
LCID lcid = 0;
|
|
|
|
switch(defAttrib->m_mtType)
|
|
{
|
|
case MT_DATE : fCIM = false; lcid = 0; break;
|
|
case MT_DATE_US : fCIM = false; lcid = -1; break;
|
|
case MT_DATE_CIM: fCIM = true ; lcid = 0; break;
|
|
}
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, MPC::ConvertDateToString( *(DATE*)data, strDate, /*fGMT*/false, fCIM, lcid ));
|
|
|
|
value = strDate.c_str();
|
|
}
|
|
else if(src != VT_BSTR)
|
|
{
|
|
value.vt = src;
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, value.ChangeType( VT_BSTR ));
|
|
}
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT MPC::Config::LoadNode( /*[in]*/ TypeConstructor* defType ,
|
|
/*[in]*/ const DefinitionOfTag* defTag ,
|
|
/*[in]*/ IXMLDOMNode* xdn )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::Config::LoadNode" );
|
|
|
|
HRESULT hr;
|
|
const DefinitionOfTag* defSubTag;
|
|
const DefinitionOfAttribute* defAttrib;
|
|
|
|
|
|
//
|
|
// First of all, clean all the variables.
|
|
//
|
|
defAttrib = defTag->m_tblAttributes;
|
|
if(defAttrib)
|
|
{
|
|
while(defAttrib->m_xt != XT_invalid)
|
|
{
|
|
ClearValue( defType, defAttrib );
|
|
|
|
defAttrib++;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Load all the attributes.
|
|
//
|
|
{
|
|
CComPtr<IXMLDOMNamedNodeMap> xdnnmAttribs;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xdn->get_attributes( &xdnnmAttribs ));
|
|
if(xdnnmAttribs)
|
|
{
|
|
while(1)
|
|
{
|
|
CComPtr<IXMLDOMNode> xdnNode;
|
|
CComQIPtr<IXMLDOMAttribute> xdaAttrib;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xdnnmAttribs->nextNode( &xdnNode ));
|
|
if(xdnNode == NULL) break;
|
|
|
|
if((xdaAttrib = xdnNode))
|
|
{
|
|
CComBSTR bstrName;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xdaAttrib->get_name( &bstrName ));
|
|
|
|
defAttrib = defTag->FindAttribute( XT_attribute, SAFEBSTR( bstrName ) );
|
|
if(defAttrib)
|
|
{
|
|
CComVariant value;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xdaAttrib->get_value( &value ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, LoadValue( defType, defAttrib, value, true ));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Load the node as value.
|
|
//
|
|
defAttrib = defTag->FindAttribute( XT_value, NULL );
|
|
if(defAttrib)
|
|
{
|
|
MPC::XmlUtil xml( xdn );
|
|
CComVariant value;
|
|
bool fFound;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xml.GetValue( NULL, value, fFound ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, LoadValue( defType, defAttrib, value, fFound ));
|
|
}
|
|
|
|
//
|
|
// Load all subnodes.
|
|
//
|
|
if(defTag->m_tblSubTags)
|
|
{
|
|
CComPtr<IXMLDOMNode> xdnChild;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xdn->get_firstChild( &xdnChild ));
|
|
while(xdnChild)
|
|
{
|
|
CComPtr<IXMLDOMNode> xdnSibling;
|
|
CComBSTR bstrName;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xdnChild->get_nodeName( &bstrName ));
|
|
|
|
defAttrib = defTag->FindAttribute( XT_element, SAFEBSTR( bstrName ) );
|
|
if(defAttrib)
|
|
{
|
|
MPC::XmlUtil xml( xdnChild );
|
|
CComVariant value;
|
|
bool fFound;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xml.GetValue( NULL, value, fFound ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, LoadValue( defType, defAttrib, value, fFound ));
|
|
}
|
|
|
|
defSubTag = defTag->FindSubTag( SAFEBSTR( bstrName ) );
|
|
if(defSubTag)
|
|
{
|
|
TypeConstructor* defSubType;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, defType->CreateInstance( defSubTag, defSubType ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, defSubType->LoadNode( xdnChild ));
|
|
}
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xdnChild->get_nextSibling( &xdnSibling ));
|
|
xdnChild = xdnSibling;
|
|
}
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::Config::LoadXmlUtil( /*[in]*/ TypeConstructor* defType ,
|
|
/*[in]*/ MPC::XmlUtil& xml )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::Config::LoadXmlUtil" );
|
|
|
|
HRESULT hr;
|
|
CComPtr<IXMLDOMNode> xdnRoot;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xml.GetRoot( &xdnRoot ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, defType->LoadNode( xdnRoot ));
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::Config::LoadStream( /*[in]*/ TypeConstructor* defType ,
|
|
/*[in]*/ IStream* pStream )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::Config::LoadStream" );
|
|
|
|
HRESULT hr;
|
|
MPC::XmlUtil xml;
|
|
bool fFound;
|
|
bool fLoaded;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xml.LoadAsStream( pStream, defType->GetTag(), fLoaded, &fFound ));
|
|
if(fFound)
|
|
{
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, LoadXmlUtil( defType, xml ));
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::Config::LoadFile( /*[in]*/ TypeConstructor* defType ,
|
|
/*[in]*/ LPCWSTR szFile )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::Config::LoadFile" );
|
|
|
|
HRESULT hr;
|
|
MPC::XmlUtil xml;
|
|
MPC::wstring strFileOrig( szFile ); strFileOrig += L".orig";
|
|
bool fFound;
|
|
bool fLoaded;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xml.Load( szFile, defType->GetTag(), fLoaded, &fFound ));
|
|
if(fFound == false)
|
|
{
|
|
//
|
|
// If fails, try to load "<file>.orig"
|
|
//
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xml.Load( strFileOrig.c_str(), defType->GetTag(), fLoaded, &fFound ));
|
|
}
|
|
|
|
if(fFound && fLoaded)
|
|
{
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, LoadXmlUtil( defType, xml ));
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT MPC::Config::SaveNode( /*[in]*/ const TypeConstructor* defType ,
|
|
/*[in]*/ const DefinitionOfTag* defTag ,
|
|
/*[in]*/ IXMLDOMNode* xdn )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::Config::SaveNode" );
|
|
|
|
HRESULT hr;
|
|
const DefinitionOfAttribute* defAttrib;
|
|
|
|
|
|
defAttrib = defTag->m_tblAttributes;
|
|
if(defAttrib)
|
|
{
|
|
MPC::XmlUtil xml( xdn );
|
|
|
|
while(defAttrib->m_xt != XT_invalid)
|
|
{
|
|
CComVariant value;
|
|
bool fFound;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, SaveValue( defType, defAttrib, value, fFound ));
|
|
if(fFound)
|
|
{
|
|
if(defAttrib->m_xt == XT_attribute)
|
|
{
|
|
CComPtr<IXMLDOMAttribute> xdaAttrib;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xml.PutAttribute( NULL, defAttrib->m_szName, &xdaAttrib, fFound ));
|
|
if(fFound)
|
|
{
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xdaAttrib->put_value( value ));
|
|
}
|
|
}
|
|
else if(defAttrib->m_xt == XT_value)
|
|
{
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xml.PutValue( NULL, value, fFound ));
|
|
}
|
|
else if(defAttrib->m_xt == XT_element)
|
|
{
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xml.PutValue( defAttrib->m_szName, value, fFound ));
|
|
}
|
|
}
|
|
|
|
defAttrib++;
|
|
}
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::Config::SaveSubNode( /*[in]*/ const TypeConstructor* defType ,
|
|
/*[in]*/ IXMLDOMNode* xdn )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::Config::SaveSubNode" );
|
|
|
|
HRESULT hr;
|
|
CComPtr<IXMLDOMNode> xdnChild;
|
|
MPC::XmlUtil xml( xdn );
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xml.CreateNode( defType->GetTag(), &xdnChild ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, defType->SaveNode( xdnChild ));
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::Config::SaveXmlUtil( /*[in ]*/ const TypeConstructor* defType ,
|
|
/*[out]*/ MPC::XmlUtil& xml )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::Config::SaveXmlUtil" );
|
|
|
|
HRESULT hr;
|
|
CComPtr<IXMLDOMNode> xdnRoot;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xml.New( defType->GetTag() ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xml.GetRoot( &xdnRoot ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, defType->SaveNode( xdnRoot ));
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::Config::SaveStream( /*[in]*/ const TypeConstructor* defType ,
|
|
/*[in]*/ IStream* *ppStream )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::Config::SaveStream" );
|
|
|
|
HRESULT hr;
|
|
MPC::XmlUtil xml;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, SaveXmlUtil( defType, xml ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xml.SaveAsStream( (IUnknown**)ppStream ));
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::Config::SaveFile( /*[in]*/ const TypeConstructor* defType ,
|
|
/*[in]*/ LPCWSTR szFile )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::Config::SaveFile" );
|
|
|
|
HRESULT hr;
|
|
MPC::XmlUtil xml;
|
|
MPC::wstring strFileNew ( szFile ); strFileNew += L".new";
|
|
MPC::wstring strFileOrig( szFile ); strFileOrig += L".orig";
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, SaveXmlUtil( defType, xml ));
|
|
|
|
|
|
//
|
|
// First of all, delete "<file>.new" and recreate it.
|
|
//
|
|
::SetFileAttributesW( strFileNew.c_str(), FILE_ATTRIBUTE_NORMAL );
|
|
::DeleteFileW ( strFileNew.c_str() );
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, xml.Save( strFileNew.c_str() ));
|
|
|
|
//
|
|
// Then move "<file>" to "<file>.orig"
|
|
//
|
|
::SetFileAttributesW( szFile , FILE_ATTRIBUTE_NORMAL );
|
|
::SetFileAttributesW( strFileOrig.c_str(), FILE_ATTRIBUTE_NORMAL );
|
|
::DeleteFileW ( strFileOrig.c_str() );
|
|
if(::MoveFileW( szFile, strFileOrig.c_str() ) == FALSE)
|
|
{
|
|
DWORD dwRes = ::GetLastError();
|
|
|
|
if(dwRes != ERROR_FILE_NOT_FOUND)
|
|
{
|
|
__MPC_SET_WIN32_ERROR_AND_EXIT(hr, dwRes);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Then rename "<file>.new" to "<file>"
|
|
//
|
|
__MPC_EXIT_IF_CALL_RETURNS_FALSE(hr, ::MoveFileW( strFileNew.c_str(), szFile ));
|
|
|
|
//
|
|
// Finally delete "<file>.orig"
|
|
//
|
|
(void)::DeleteFileW( strFileOrig.c_str() );
|
|
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|