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

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);
}