Windows编程

开发平台：
Visual C++

OBJECT.CPP：源码内容
							/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
    Object.cpp
Abstract:
    ObjectTypeList class
    
Author:
Environment:
    User mode
Revision History :
--*/
#include "adssmp.h"
#pragma hdrstop
ObjectTypeList::ObjectTypeList()
{
    _pObjList = NULL;
    _dwCurrentIndex = 0;
    _dwMaxElements = 0;
    _dwUBound  = 0;
    _dwLBound = 0;
}
HRESULT
ObjectTypeList::CreateObjectTypeList(
    VARIANT vFilter,
    ObjectTypeList ** ppObjectTypeList
){
    ObjectTypeList * pObjectTypeList = NULL;
    HRESULT hr = S_OK;
    pObjectTypeList = new ObjectTypeList;
    if (!pObjectTypeList) {
        hr = E_OUTOFMEMORY;
        BAIL_ON_FAILURE(hr);
    }
    hr = BuildObjectArray(
            vFilter,
            &pObjectTypeList->_pObjList,
            &pObjectTypeList->_dwMaxElements
            );
    if (FAILED(hr)) {
        hr = BuildDefaultObjectArray(
                gpFilters,
                gdwMaxFilters,
                &pObjectTypeList->_pObjList,
                &pObjectTypeList->_dwMaxElements
                );
        BAIL_ON_FAILURE(hr);
    }
    hr = SafeArrayGetUBound(
                pObjectTypeList->_pObjList,
                1,
                (long FAR *)&pObjectTypeList->_dwUBound
                );
    BAIL_ON_FAILURE(hr);
    hr = SafeArrayGetLBound(
                pObjectTypeList->_pObjList,
                1,
                (long FAR *)&pObjectTypeList->_dwLBound
                );
    BAIL_ON_FAILURE(hr);
    pObjectTypeList->_dwCurrentIndex = pObjectTypeList->_dwLBound;
    *ppObjectTypeList = pObjectTypeList;
    RRETURN(S_OK);
error:
    if (pObjectTypeList) {
        delete pObjectTypeList;
    }
    RRETURN(hr);
}
ObjectTypeList::~ObjectTypeList()
{
    HRESULT hr = S_OK;
    if (_pObjList) {
        hr = SafeArrayDestroy(_pObjList);
    }
}
HRESULT
ObjectTypeList::GetCurrentObject(PDWORD pdwObject)
{
    HRESULT hr = S_OK;
    if (_dwCurrentIndex > _dwUBound) {
        return(E_FAIL);
    }
    hr = SafeArrayGetElement(
                    _pObjList,
                    (long FAR *)&_dwCurrentIndex,
                    (void *)pdwObject
                    );
    RRETURN(hr);
}
HRESULT
ObjectTypeList::Next()
{
    HRESULT hr = S_OK;
    _dwCurrentIndex++;
    if (_dwCurrentIndex > _dwUBound) {
        return(E_FAIL);
    }
    return(hr);
}
HRESULT
ObjectTypeList::Reset()
{
    HRESULT hr = S_OK;
    return(hr);
}
HRESULT
IsValidFilter(
    LPWSTR ObjectName,
    DWORD *pdwFilterId,
    PFILTERS pFilters,
    DWORD dwMaxFilters
){
    DWORD i = 0;
    for (i = 0; i < dwMaxFilters; i++) {
        if (!_wcsicmp(ObjectName, (pFilters + i)->szObjectName)) {
            *pdwFilterId = (pFilters + i)->dwFilterId;
            RRETURN(S_OK);
        }
    }
    *pdwFilterId = 0;
    RRETURN(E_FAIL);
}
HRESULT
BuildDefaultObjectArray(
    PFILTERS  pFilters,
    DWORD dwMaxFilters,
    SAFEARRAY ** ppFilter,
    DWORD * pdwNumElements
){
    DWORD i;
    HRESULT hr = S_OK;
    SAFEARRAYBOUND sabNewArray;
    SAFEARRAY * pFilter = NULL;
    sabNewArray.cElements = dwMaxFilters;
    sabNewArray.lLbound =  0;
    pFilter =   SafeArrayCreate(
                        VT_I4,
                        1,
                        &sabNewArray
                        );
    if (!pFilter){
        hr = E_OUTOFMEMORY;
        BAIL_ON_FAILURE(hr);
    }
    for (i = 0; i < dwMaxFilters; i++) {
        hr = SafeArrayPutElement(
                pFilter,
                (long *)&i,
                (void *)&((pFilters + i)->dwFilterId)
            );
        BAIL_ON_FAILURE(hr);
    }
    *ppFilter = pFilter;
    *pdwNumElements = dwMaxFilters;
    RRETURN(S_OK);
error:
    if (pFilter) {
        SafeArrayDestroy(pFilter);
    }
    *ppFilter = NULL;
    *pdwNumElements = 0;
    RRETURN(hr);
}
HRESULT
BuildObjectArray(
    VARIANT var,
    SAFEARRAY ** ppFilter,
    DWORD * pdwNumElements
){
    LONG uDestCount = 0;
    LONG dwSLBound = 0;
    LONG dwSUBound = 0;
    VARIANT v;
    LONG i;
    HRESULT hr = S_OK;
    SAFEARRAYBOUND sabNewArray;
    DWORD dwFilterId;
    SAFEARRAY * pFilter = NULL;
    if(!((V_VT(&var) &  VT_VARIANT) &&  V_ISARRAY(&var))) {
        RRETURN(E_FAIL);
    }
    //
    // Check that there is only one dimension in this array
    //
    if ((V_ARRAY(&var))->cDims != 1) {
        hr = E_FAIL;
        BAIL_ON_FAILURE(hr);
    }
    //
    // Check that there is atleast one element in this array
    //
    if ((V_ARRAY(&var))->rgsabound[0].cElements == 0){
        hr = E_FAIL;
        BAIL_ON_FAILURE(hr);
    }
    //
    // We know that this is a valid single dimension array
    //
    hr = SafeArrayGetLBound(V_ARRAY(&var),
                            1,
                            (long FAR *)&dwSLBound
                            );
    BAIL_ON_FAILURE(hr);
    hr = SafeArrayGetUBound(V_ARRAY(&var),
                            1,
                            (long FAR *)&dwSUBound
                            );
    BAIL_ON_FAILURE(hr);
    sabNewArray.cElements = dwSUBound - dwSLBound + 1;
    sabNewArray.lLbound = dwSLBound;
    pFilter = SafeArrayCreate(
                    VT_I4,
                    1,
                    &sabNewArray
                    );
    if (!pFilter) {
        hr = E_OUTOFMEMORY;
        BAIL_ON_FAILURE(hr);
    }
    for (i = dwSLBound; i <= dwSUBound; i++) {
        VariantInit(&v);
        hr = SafeArrayGetElement(V_ARRAY(&var),
                                (long FAR *)&i,
                                &v
                                );
        if (FAILED(hr)) {
            continue;
        }
        hr = IsValidFilter(
                V_BSTR(&v),
                &dwFilterId,
                gpFilters,
                gdwMaxFilters
                );
        if (FAILED(hr)) {
            continue;
        }
        hr = SafeArrayPutElement(
                pFilter,
                (long*)&uDestCount,
                (void *)&dwFilterId
                );
        if(FAILED(hr)){
            continue;
        }
        uDestCount++;
    }
    //
    // There was nothing of value that could be retrieved from the
    // filter.
    //
    if (!uDestCount ) {
        hr = E_FAIL;
        BAIL_ON_FAILURE(hr);
    }
    *pdwNumElements  = uDestCount;
    *ppFilter = pFilter;
    RRETURN(S_OK);
error:
    if (pFilter) {
        SafeArrayDestroy(pFilter);
    }
    *ppFilter = NULL;
    *pdwNumElements = 0;
    RRETURN(hr);
}

						