//*************************************************************
//
//  Copyright (c) Microsoft Corporation 1999 - 2000
//  All rights reserved
//
//  variant.hxx
//
//*************************************************************

#include "rsop.hxx"


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Function: CVariant::CVariant
//
// Purpose: Constructor for CVariant class.  Initializes the
//     storage of the variant data.
//
// Params: none
//
// Return value: none
//
// Notes:
//
//------------------------------------------------------------
CVariant::CVariant() :
    _iCurrentArrayIndex(0),
    _cMaxArrayElements(0)
{
    VariantInit(&_var);
}


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Function: CVariant::~CVariant
//
// Purpose: Denstructor for CVariant class.  Frees any data
//     allocated to store variant data.
//
// Params: none
//
// Return value: none
//
// Notes:
//
//------------------------------------------------------------
CVariant::~CVariant()
{
    HRESULT hr;

    hr = VariantClear(&_var);

    ASSERT(SUCCEEDED(hr));
}


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Function: CVariant::SetStringValue
//
// Purpose: Sets the type of the variant to VT_BSTR and creates
//     a bstr to store the string.
//
// Params: wszValue -- this unicode string is the value to
//     which we want to set this variant
//
// Return value: returns S_OK if successful, other
//     error code if not
//
// Notes:  The variant should not be set to a value after
//     this is called -- otherwise, you may lose reference
//     to allocated memory -- the value is meant to be set
//     only once.  
//
//------------------------------------------------------------
HRESULT CVariant::SetStringValue(WCHAR* wszValue)
{
    XBStr xString;

    ASSERT(VT_EMPTY == _var.vt); 

    xString = wszValue;

    if (!xString)
    {
        return E_OUTOFMEMORY;
    }
    
    _var.vt = VT_BSTR;
    _var.bstrVal = xString.Acquire();

    return S_OK;
}


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Function: CVariant::SetLongValue
//
// Purpose: Sets the type of the variant to VT_I4 and creates
//     a bstr to store the string.
//
// Params: lValue -- this LONG value is the value to
//     which we want to set this variant
//
// Return value: returns S_OK if successful, other
//     error code if not
//
// Notes:  The variant should not be set to a value after
//     this is called -- otherwise, you may lose reference
//     to allocated memory -- the value is meant to be set
//     only once.  
//
//------------------------------------------------------------
HRESULT CVariant::SetLongValue(LONG lValue)
{
    ASSERT(VT_EMPTY == _var.vt); 

    _var.vt = VT_I4;
    _var.lVal = lValue;

    return S_OK;
}


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Function: CVariant::SetBoolValue
//
// Purpose: Sets the type of the variant to VT_BOOL and stores the value
//
// Params: bValue -- this boolean value is the value to
//     which we want to set this variant
//
// Return value: returns S_OK if successful, other
//     error code if not
//
// Notes:  The variant should not be set to a value after
//     this is called -- otherwise, you may lose reference
//     to allocated memory -- the value is meant to be set
//     only once.  
//
//------------------------------------------------------------
HRESULT CVariant::SetBoolValue(BOOL bValue)
{
    ASSERT(VT_EMPTY == _var.vt); 

    _var.vt = VT_BOOL;
    _var.boolVal = bValue ? VARIANT_TRUE : VARIANT_FALSE;

    return S_OK;
}


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Function: CVariant::SetNextLongArrayElement
//
// Purpose: Adds an element in an array of strings to a 
//     specified string
//
// Params: Value -- the value to which to add as an element
//         cMaxElements (optional) -- the maximum number
//         of elements in this array -- must be specified
//         the first time this method is called on this object
//
// Return value: returns S_OK if successful, other
//     error code if not
//
// Notes:  
//
//------------------------------------------------------------
HRESULT CVariant::SetNextLongArrayElement(
    LONG  Value,
    DWORD cMaxElements)
{
    HRESULT hr;
    
    //
    // Add the long to the correct index
    // in the array
    //
    hr = SetNextArrayElement(
        VT_I4,
        cMaxElements,
        &Value);

    return hr;
}


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Function: CVariant::SetNextStringArrayElement
//
// Purpose: Adds an element to an array of strings
//
// Params: wszValue -- the value to which to add as an element
//         cMaxElements (optional) -- the maximum number
//         of elements in this array -- must be specified
//         the first time this method is called on this object
//
// Return value: returns S_OK if successful, other
//     error code if not
//
// Notes:  
//
//------------------------------------------------------------
HRESULT CVariant::SetNextStringArrayElement(
    WCHAR* wszValue,
    DWORD  cMaxElements)
{
    HRESULT hr;
    XBStr   xString;

    //
    // Create a bstr from the supplied unicode string
    //
    xString = wszValue;

    if (!xString)
    {
        return E_OUTOFMEMORY;
    }
    
    //
    // Now add the unicode string to the correct index
    // in the array
    //
    hr = SetNextArrayElement(
        VT_BSTR,
        cMaxElements,
        xString);

    //
    // If we've succeeded in setting the element, it now
    // owns the reference, so we release our reference
    //
    if (SUCCEEDED(hr))
    {
        (void) xString.Acquire();
    }

    return hr;
}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Function: CVariant::SetNextByteArrayElement
//
// Purpose: Adds an element in an array of bytes to a byte array 
//
// Params: byteValue -- the value to which to add as an element
//         cMaxElements (optional) -- the maximum number
//         of elements in this array -- must be specified
//         the first time this method is called on this object
//
// Return value: returns S_OK if successful, other
//     error code if not
//
// Notes:  
//
//------------------------------------------------------------
HRESULT CVariant::SetNextByteArrayElement(
    BYTE  byteValue,
    DWORD cMaxElements)
{
    HRESULT hr;
    
    //
    // Add the long to the correct index
    // in the array
    //
    hr = SetNextArrayElement(
        VT_UI1,
        cMaxElements,
        &byteValue);

    return hr;
}



//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Function: CVariant::IsStringValue
//
// Purpose: Determines whether this variant represents a string
//
// Params: 
//
// Return value: returns TRUE if this is a string, FALSE if not
//
//------------------------------------------------------------
BOOL CVariant::IsStringValue()
{
    return VT_BSTR == _var.vt;
}


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Function: CVariant::IsLongValue
//
// Purpose: Determines whether this variant represents a long
//
// Params: 
//
// Return value: returns TRUE if this is a long, FALSE if not
//
//------------------------------------------------------------
BOOL CVariant::IsLongValue()
{
    return VT_I4 == _var.vt;
}


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Function: CVariant::operator VARIANT*()
//
// Purpose: Casts this object into a VARIANT structure pointer
//
// Params: 
//
// Return value: returns a pointer to a VARIANT structure
//
// Notes:  
//
//------------------------------------------------------------
CVariant::operator VARIANT*()
{
    return &_var;
}


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Function: CVariant::SetNextArrayElement
//
// Purpose: Adds an element to an array of objects of arbitrary
//     type
//
// Params: wszValue -- the value to which to set the element
//     cMaxElements (optional) -- the maximum number
//         of elements in this array -- must be specified
//         the first time this method is called on this object
//
// Return value: returns S_OK if successful, other
//     error code if not
//
// Notes:  
//
//------------------------------------------------------------
HRESULT CVariant::SetNextArrayElement(
        VARTYPE varType,
        DWORD   cMaxElements,
        LPVOID  pvData)
{
    HRESULT hr;

    //
    // If this array contains no elements, return the hr
    // that lets the caller know that this array is full
    //
    if ( 0 == cMaxElements )
    {
        return S_FALSE;
    }

    //
    // The first time this method is called on this object,
    // we should allocate space for the array
    //
    if ( !_iCurrentArrayIndex )
    {
        ASSERT( cMaxElements );
        ASSERT( VT_EMPTY == _var.vt );

        //
        // Allocate space for the array with elements
        // of the caller specifed type and number
        //
        hr = InitializeArray(
            varType,
            cMaxElements);

        if (FAILED(hr)) 
        {
            return hr;
        }

        _cMaxArrayElements = cMaxElements;
    } 

    ASSERT( ((DWORD) _iCurrentArrayIndex) < _cMaxArrayElements );

    //
    // Now add the polymorphic object's IUnknown
    // into the array
    //
    hr = SafeArrayPutElement(
        _var.parray,
        &_iCurrentArrayIndex,
        pvData);

    //
    // If we've filled up the array, return S_FALSE to
    // signal that no more elements can be added
    //
    if (SUCCEEDED(hr))
    {
        //
        // Increment our cursor into the array to the
        // next element 
        //
        _iCurrentArrayIndex++;

        //
        // Check our current index -- if it's the same
        // as our maximum, we're full
        //
        if ( ((DWORD) _iCurrentArrayIndex) == _cMaxArrayElements)
        {
            hr = S_FALSE;
        }
    }

    return hr;
}


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Function: CVariant::InitializeArray
//
// Purpose: Private method that allocates space for an array
//     of a specified size and element type
//
// Params: varType -- type of elements that will be in the array
//     cMaxElements -- the size, in elements, of the array
//
// Return value: returns ERROR_SUCCESS if successful, other
//     win32 error code if not
//
// Notes: 
//
//------------------------------------------------------------
HRESULT CVariant::InitializeArray(
    VARTYPE varType,
    DWORD   cMaxElements)
{
    SAFEARRAY*     pSafeArray;
    SAFEARRAYBOUND arrayBound;

    //
    // Set the bounds of the array to be zero-based
    //
    arrayBound.lLbound = 0;
    arrayBound.cElements = cMaxElements;

    //
    // Allocate the array
    //
    pSafeArray = SafeArrayCreate(
        varType,
        1, // 1 dimension
        &arrayBound);

    if (!pSafeArray) 
    {
        return E_OUTOFMEMORY;
    }

    //
    // Set our state to refer to the allocated memory
    // with the specified type
    //
    _var.vt = VT_ARRAY | varType;
    _var.parray = pSafeArray;

    return S_OK;
}