/////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 1998-2000 Microsoft Corporation
//
//  Module Name:
//      ClusterObject.cpp
//
//  Description:
//      Implementation of ClusterObject
//
//  Author:
//      Galen Barbee    (GalenB)    14-Dec-1998
//
//  Revision History:
//
//  Notes:
//
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ClusterObject.h"
#include "property.h"


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


/////////////////////////////////////////////////////////////////////////////
// CClusterObject class
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusterObject::HrSaveProperties
//
//  Description:
//      Save the properties to the cluster database.
//
//  Arguments:
//      cpvProps        [IN OUT]    - The properties to save.
//      bPrivate        [IN]        - Are these private properties?
//      pvarStatusCode  [OUT]       - Catches additional status.
//
//  Return Value:
//      S_OK if successful, or Win32 error as HRESULT if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusterObject::HrSaveProperties(
    IN OUT  CClusProperties::CClusPropertyVector &  cpvProps,
    IN      BOOL                                    bPrivate,
    OUT     VARIANT *                               pvarStatusCode
    )
{
    HRESULT         _hr = S_FALSE;
    CClusPropList   _cplPropList( TRUE );       // always add the prop...
    DWORD           sc;

    sc = _cplPropList.ScAllocPropList( 8192 );
    _hr = HRESULT_FROM_WIN32( sc );
    if ( SUCCEEDED( _hr ) )
    {
        _hr = HrBuildPropertyList( cpvProps, _cplPropList );
        if ( SUCCEEDED( _hr ) )
        {
            DWORD   _sc = ERROR_SUCCESS;

            _sc = ScWriteProperties( _cplPropList, bPrivate );

            pvarStatusCode->vt      = VT_ERROR;                             // fill in the error code info
            pvarStatusCode->scode   = _sc;

            if ( _sc == ERROR_RESOURCE_PROPERTIES_STORED )
            {
                _hr = S_OK;
            } // if: if ERROR_RESOURCE_PROPERTIES_STORED then convert to S_OK...
            else
            {
                _hr = HRESULT_FROM_WIN32( _sc );
            } // else: simply use the status code as is...
        } // if:
    } // if:

    return _hr;

} //*** CClusterObject::HrSaveProperties()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusterObject::HrBuildPropertyList
//
//  Description:
//      Build a proper property list from the passed in properties collection.
//
//  Arguments:
//      cpvProps        [IN, OUT]   - The vector that is the properties.
//      rcplPropList    [OUT]       - The property list to add to.
//
//  Return Value:
//      S_OK if successful, or Win32 error as HRESULT if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusterObject::HrBuildPropertyList(
    IN OUT  CClusProperties::CClusPropertyVector &  cpvProps,
    OUT     CClusPropList &                         rcplPropList
    )
{
    HRESULT                                                 _hr = S_OK;
    CComObject< CClusProperty > *                           _pProperty = 0;
    CClusProperties::CClusPropertyVector::iterator          _itCurrent = cpvProps.begin();
    CClusProperties::CClusPropertyVector::const_iterator    _itLast  = cpvProps.end();
    DWORD                                                   _sc = ERROR_SUCCESS;
    CLUSTER_PROPERTY_FORMAT                                 _cpfFormat = CLUSPROP_FORMAT_UNKNOWN;

    for ( ; ( _itCurrent != _itLast ) && ( SUCCEEDED( _hr ) ); _itCurrent++ )
    {
        _pProperty = *_itCurrent;

        _hr = _pProperty->get_Format( &_cpfFormat );
        if ( SUCCEEDED( _hr ) )
        {
            if ( _pProperty->Modified() )
            {
                if ( _pProperty->IsDefaultValued() )
                {
                    _sc = rcplPropList.ScSetPropToDefault( _pProperty->Name(), _cpfFormat );
                    _hr = HRESULT_FROM_WIN32( _sc );
                    continue;
                } // if: property was set to its default state
                else
                {
                    switch( _cpfFormat )
                    {
                        case CLUSPROP_FORMAT_DWORD :
                        {
                            DWORD   dwValue = 0;

                            _hr = HrConvertVariantToDword( _pProperty->Value(), &dwValue );
                            if ( SUCCEEDED( _hr ) )
                            {
                                _sc = rcplPropList.ScAddProp( _pProperty->Name(), dwValue, (DWORD) 0 );
                                _hr = HRESULT_FROM_WIN32( _sc );
                            } // if:
                            break;
                        } // case:

#if CLUSAPI_VERSION >= 0x0500

                        case CLUSPROP_FORMAT_LONG :
                        {
                            long    lValue = 0L;

                            _hr = HrConvertVariantToLong( _pProperty->Value(), &lValue );
                            if ( SUCCEEDED( _hr ) )
                            {
                                _sc = rcplPropList.ScAddProp( _pProperty->Name(), lValue, 0L );
                                _hr = HRESULT_FROM_WIN32( _sc );
                            } // if:
                            break;
                        } // case:

#endif // CLUSAPI_VERSION >= 0x0500

                            case CLUSPROP_FORMAT_ULARGE_INTEGER :
                            {
                                ULONGLONG   ullValue = 0;

                                _hr = HrConvertVariantToULONGLONG( _pProperty->Value(), &ullValue );
                                if ( SUCCEEDED( _hr ) )
                                {
                                    _sc = rcplPropList.ScAddProp( _pProperty->Name(), ullValue, 0 );
                                    _hr = HRESULT_FROM_WIN32( _sc );
                                } // if:
                                break;
                            } // case:

                            case CLUSPROP_FORMAT_SZ :
                            case CLUSPROP_FORMAT_EXPAND_SZ :
                            {
                                _sc = rcplPropList.ScAddProp( _pProperty->Name(), _pProperty->Value().bstrVal );
                                _hr = HRESULT_FROM_WIN32( _sc );
                                break;
                            } // case:

                            case CLUSPROP_FORMAT_MULTI_SZ:
                            {
                                _hr = HrAddMultiSzProp( rcplPropList, _pProperty->Name(), _pProperty->Values() );
                                break;
                            } // case:

                            case CLUSPROP_FORMAT_BINARY:
                            {
                                _hr = HrAddBinaryProp(
                                                rcplPropList,
                                                _pProperty->Name(),
                                                _pProperty->Value()
                                                );
                                break;
                            } // case:
                        } // end switch

                        _pProperty->Modified( FALSE );
                } // else: common property was not deleted
            } // if: property was modified
        } // if: we got the property format

    } // for: property in the collection


    return _hr;

} //*** CClusterObject::HrBuildPropertyList()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusterObject::HrConvertVariantToDword
//
//  Description:
//      Convert the passed in varint to a DWORD.
//
//  Arguments:
//      rvarValue   [IN]    - The variant value to convert.
//      pdwValue    [OUT]   - Catches the converted value.
//
//  Return Value:
//      S_OK if successful, or E_INVALIDARG if the value cannot be converted.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusterObject::HrConvertVariantToDword(
    IN  const CComVariant & rvarValue,
    OUT PDWORD              pdwValue
    )
{
    HRESULT _hr = S_OK;

    switch ( rvarValue.vt )
    {
        case VT_I2:
        {
            *pdwValue = (DWORD) rvarValue.iVal;
            break;
        } // case:

        case VT_I4:
        {
            *pdwValue = (DWORD) rvarValue.lVal;
            break;
        } // case:

        case VT_BOOL:
        {
            *pdwValue = (DWORD) rvarValue.boolVal;
            break;
        } // case:

        default:
        {
            _hr = E_INVALIDARG;
            break;
        } // default:
    } // switch:

    return _hr;

} //*** CClusterObject::HrConvertVariantToDword()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusterObject::HrConvertVariantToLong
//
//  Description:
//      Convert the passed in varint to a long.
//
//  Arguments:
//      rvarValue   [IN]    - The variant value to convert.
//      plValue     [OUT]   - Catches the converted value.
//
//  Return Value:
//      S_OK if successful, or E_INVALIDARG if the value cannot be converted.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusterObject::HrConvertVariantToLong(
    IN  const CComVariant & rvarValue,
    OUT long *              plValue
    )
{
    HRESULT _hr = S_OK;

    switch ( rvarValue.vt )
    {
        case VT_I2:
        {
            *plValue = (long) rvarValue.iVal;
            break;
        } // case:

        case VT_I4:
        {
            *plValue = rvarValue.lVal;
            break;
        } // case:

        case VT_BOOL:
        {
            *plValue = (long) rvarValue.boolVal;
            break;
        } // case:

        default:
        {
            _hr = E_INVALIDARG;
            break;
        } // default:
    } // switch:

    return _hr;

} //*** CClusterObject::HrConvertVariantToLong()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusterObject::HrConvertVariantToULONGLONG
//
//  Description:
//      Convert the passed in varint to a ULONGLONG.
//
//  Arguments:
//      rvarValue   [IN]    - The variant value to convert.
//      pullValue   [OUT]   - Catches the converted value.
//
//  Return Value:
//      S_OK if successful, or E_INVALIDARG if the value cannot be converted.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusterObject::HrConvertVariantToULONGLONG(
    IN  const CComVariant & rvarValue,
    OUT PULONGLONG          pullValue
    )
{
    HRESULT _hr = S_OK;

    switch ( rvarValue.vt )
    {
        case VT_I8:
        {
            *pullValue = rvarValue.ulVal;
            break;
        } // case:

        case VT_R8:
        {
            *pullValue = (ULONGLONG) rvarValue.dblVal;
            break;
        } // case:

        default:
        {
            _hr = E_INVALIDARG;
            break;
        } // default:
    } // switch:

    return _hr;

} //*** CClusterObject::HrConvertVariantToULONGLONG()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusterObject::HrAddBinaryProp
//
//  Description:
//      Create a binary property from the passed in variant and add it to the
//      property list so it can be saved into the cluster DB.
//
//  Arguments:
//      rcplPropList    [IN OUT]    - The property list to add the binary
//                                  property to.
//      pszPropName     [IN]        - The name of the multisz property.
//      rvarPropValue   [IN]        - The value that is the binary property.
//
//  Return Value:
//      S_OK if successful, or Win32 error as HRESULT if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusterObject::HrAddBinaryProp(
    IN OUT  CClusPropList &     rcplPropList,
    IN      LPCWSTR             pszPropName,
    IN      const CComVariant & rvarPropValue
    )
{
    ASSERT( rvarPropValue.vt & VT_ARRAY );

    HRESULT     _hr = E_INVALIDARG;
    SAFEARRAY * _psa = rvarPropValue.parray;
    long        _cb;
    PBYTE       _pb;

    if ( _psa != NULL )
    {
        _hr = HrSafeArraySizeof( _psa, 1, &_cb );
        if ( SUCCEEDED( _hr ) )
        {
            _hr = ::SafeArrayAccessData( _psa, (PVOID *) &_pb );
            if ( SUCCEEDED( _hr ) )
            {
                DWORD   _sc = rcplPropList.ScAddProp( pszPropName, _pb, _cb, NULL, 0 );

                _hr = HRESULT_FROM_WIN32( _sc );

                //
                // release the pointer into the SafeArray
                //

                ::SafeArrayUnaccessData( _psa );
            } // if:
        } // if:
    } // if:

    return _hr;

} //*** CClusterObject::HrAddBinaryProp()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CClusterObject::HrAddMultiSzProp
//
//  Description:
//      Create a multisz property from the passed in property values and add it
//      to the property list so it can be saved in the cluster DB.
//
//  Arguments:
//      rcplPropList    [IN OUT]    - The property list to add the multisz to.
//      pszPropName     [IN]        - The name of the multisz property.
//      rPropertyValues [IN]        - The values that are the multisz property.
//
//  Return Value:
//      S_OK if successful, or Win32 error as HRESULT if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusterObject::HrAddMultiSzProp(
    IN OUT  CClusPropList &                             rcplPropList,
    IN      LPCWSTR                                     pszPropName,
    IN      const CComObject< CClusPropertyValues > &   rPropertyValues
    )
{
    HRESULT                                                 _hr = E_INVALIDARG;
    const CClusPropertyValues::CClusPropertyValueVector &   _rPropValuesList = rPropertyValues.ValuesList();

    //
    // KB: Only going to iterate one value and its data!!
    //
    if ( !_rPropValuesList.empty() )
    {
        CClusPropertyValues::CClusPropertyValueVector::const_iterator   _itPropValue = _rPropValuesList.begin();
        const CComObject< CClusPropertyValueData > *                    _pPropertyValueData = (*_itPropValue)->Data();

        if ( _pPropertyValueData != NULL )
        {
            LPWSTR  _psz    = NULL;
            DWORD   _sc     = ERROR_SUCCESS;

            _hr = _pPropertyValueData->HrFillMultiSzBuffer( &_psz );
            if ( SUCCEEDED( _hr ) )
            {
                _sc = rcplPropList.ScAddMultiSzProp( pszPropName, _psz, NULL );
                _hr = HRESULT_FROM_WIN32( _sc );

                ::LocalFree( _psz );
            } // if:
        } // if:
    } // if:

    return _hr;

} //*** CClusterObject::HrAddMultiSzProp()