You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
663 lines
20 KiB
663 lines
20 KiB
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 2000.
|
|
//
|
|
// File: cmdprutl.cxx
|
|
//
|
|
// Contents: A wrapper for scope properties around ICommand
|
|
//
|
|
// History: 5-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include <pch.cxx>
|
|
#pragma hdrstop
|
|
|
|
#include <cmdprutl.hxx>
|
|
#include <fsciclnt.h>
|
|
#include <guidutil.hxx>
|
|
|
|
static GUID const guidQueryCorePropset = DBPROPSET_CIFRMWRKCORE_EXT;
|
|
static GUID const guidCiFsExt = DBPROPSET_FSCIFRMWRK_EXT;
|
|
static const cFsCiProps = 4;
|
|
static const cInitProps = 2;
|
|
static const cScopePropSets = 2;
|
|
|
|
//
|
|
// utility functions
|
|
//
|
|
extern WCHAR **GetWCharFromVariant ( DBPROP & dbProp, ULONG *cElements );
|
|
extern DWORD * GetDepthsFromVariant( DBPROP & dbProp, ULONG *cElements, ULONG mask );
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CGetCmdProps::CGetCmdProps
|
|
//
|
|
// Synopsis: Constructor - Initializes all, calls GetProperties().
|
|
//
|
|
// History: 5-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CGetCmdProps::CGetCmdProps( ICommand * pICommand )
|
|
:_fGuidValid(FALSE),
|
|
_aDepths(0),
|
|
_aPaths(0),
|
|
_aCatalogs(0),
|
|
_aMachines(0),
|
|
_cDepths(0),
|
|
_cScopes(0),
|
|
_cCatalogs(0),
|
|
_cMachines(0),
|
|
_cGuids(0),
|
|
_type(CiNormal),
|
|
_cPropertySets(0),
|
|
_cCardinality(0xffffffff)
|
|
{
|
|
RtlZeroMemory( &_clientGuid, sizeof GUID );
|
|
|
|
SCODE sc = pICommand->QueryInterface( IID_ICommandProperties,
|
|
_xICmdProp.GetQIPointer() );
|
|
if ( FAILED(sc) )
|
|
THROW( CException(sc) );
|
|
|
|
//
|
|
// Populate our internal data structs
|
|
//
|
|
|
|
GetProperties();
|
|
|
|
SetCardinalityValue();
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CGetCmdProps::GetProperties
|
|
//
|
|
// Synopsis: Retrieves all the properties from ICommandProperties interface.
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: Throws upon failure.
|
|
//
|
|
// History: 5-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//
|
|
// Hack #214: IID_ICommandProperties is intercepted by service layers, which
|
|
// don't like us passing in the magic code to fetch hidden scope
|
|
// properties. But the controlling unknown doesn't recognize
|
|
// IID_IKyleProp and sends it right to us. Implementation is
|
|
// identical to ICommandProperties.
|
|
//
|
|
|
|
GUID IID_IKyleProp = { 0xb4237bc2, 0xe09f, 0x11d1, 0x80, 0xc0, 0x00, 0xc0, 0x4f, 0xa3, 0x54, 0xba };
|
|
|
|
void CGetCmdProps::GetProperties()
|
|
{
|
|
// get all properties including scope props
|
|
|
|
XInterface<ICommandProperties> xTemp;
|
|
SCODE sc = _xICmdProp->QueryInterface( IID_IKyleProp,
|
|
xTemp.GetQIPointer() );
|
|
|
|
const ULONG cPropIdSets = 3141592653;
|
|
DBPROPSET * pDbPropSet;
|
|
ULONG cPropertySets;
|
|
|
|
if ( SUCCEEDED(sc) )
|
|
sc = xTemp->GetProperties( cPropIdSets,
|
|
0,
|
|
&cPropertySets,
|
|
&pDbPropSet );
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
// On this failure, you have to free the properties returned!
|
|
|
|
Win4Assert( DB_E_ERRORSOCCURRED != sc );
|
|
|
|
ciDebugOut(( DEB_ERROR, "Failed to do GetProperties (0x%X)\n", sc ));
|
|
THROW( CException( sc ) );
|
|
}
|
|
|
|
_xPropSet.Set( cPropertySets, (CDbPropSet *) pDbPropSet );
|
|
_cPropertySets = cPropertySets;
|
|
|
|
for ( ULONG i = 0; i < cPropertySets; i++ )
|
|
ProcessPropSet( pDbPropSet[i] );
|
|
} //GetProperties
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CGetCmdProps::SetCardinalityValue
|
|
//
|
|
// Synopsis: validates and sets the Cardinality value
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: none - throws upon failure.
|
|
//
|
|
// History: 5-12-97 mohamedn moved from CQuerySpec
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CGetCmdProps::SetCardinalityValue()
|
|
{
|
|
//
|
|
// Final cardinality check...
|
|
//
|
|
|
|
if ( _cDepths != _cScopes ||
|
|
(_cScopes != _cCatalogs && _cCatalogs != 1) ||
|
|
_cCatalogs != _cMachines )
|
|
{
|
|
ciDebugOut(( DEB_ERROR, "CQuerySpec::QueryInternalQuery -- Cardinality mismatch\n" ));
|
|
THROW( CException( CI_E_CARDINALITY_MISMATCH ) );
|
|
}
|
|
|
|
// The query is distributed if multiple machines or multiple catalogs
|
|
// are present. Multiple scopes on one catalog/machine are handled
|
|
// by a non-distributed query.
|
|
|
|
BOOL fDistributed = FALSE;
|
|
|
|
if (_cCatalogs > 1)
|
|
{
|
|
for ( unsigned i = 0; !fDistributed && i < _cScopes-1; i++ )
|
|
{
|
|
if ( ( _wcsicmp( _aMachines[i], _aMachines[i+1] ) ) ||
|
|
( _wcsicmp( _aCatalogs[i], _aCatalogs[i+1] ) ) )
|
|
{
|
|
fDistributed = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Win4Assert( !" Break here to set single/distributed query" );
|
|
|
|
if ( fDistributed )
|
|
{
|
|
Win4Assert( _cCatalogs > 1 );
|
|
|
|
_cCardinality = _cCatalogs; // distributed case
|
|
}
|
|
else if ( 0 == _cCatalogs )
|
|
{
|
|
_cCardinality = 0; // local case
|
|
}
|
|
else
|
|
{
|
|
_cCardinality = 1; // single machine case.
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CGetCmdProps::PopulateDbProps
|
|
//
|
|
// Synopsis: Creates a new IDBProperties using ICommand properties
|
|
//
|
|
// Arguments: [pIDBProperties] -- IDBProperties interface
|
|
// [iElement] -- specifies which of the distributed properties to use
|
|
//
|
|
// Returns: none - thorws upon failure.
|
|
//
|
|
// History: 5-12-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CGetCmdProps::PopulateDbProps(IDBProperties *pIDBProperties, ULONG iElement )
|
|
{
|
|
Win4Assert( !_xICmdProp.IsNull() ); // src
|
|
Win4Assert( pIDBProperties != 0 ); // destination
|
|
Win4Assert( _cPropertySets != 0 ); // at least one property set exist.
|
|
Win4Assert( _xPropSet.GetPointer() != 0 );
|
|
|
|
DBPROPSET * pPropSet = 0;
|
|
ULONG cPropSets = 0;
|
|
XArrayOLEInPlace<CDbPropSet> xPropSet;
|
|
|
|
CreateNewPropSet(&cPropSets, &pPropSet, iElement);
|
|
|
|
Win4Assert( pPropSet != 0 );
|
|
Win4Assert( cPropSets != 0 );
|
|
|
|
xPropSet.Set(cPropSets,(CDbPropSet *)pPropSet);
|
|
|
|
SCODE sc = pIDBProperties->SetProperties( cPropSets, xPropSet.GetPointer());
|
|
|
|
if ( FAILED(sc) )
|
|
THROW( CException(sc) );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CGetCmdProps::CreateNewPropSet, private
|
|
//
|
|
// Synopsis: Creates new property sets on IDBProperties from ICommand properties.
|
|
//
|
|
// Arguments: [cPropSets] -- count of property sets
|
|
// [ppPropSet] -- to return new property sets
|
|
// [index] -- specifies which of the distributed properties to use
|
|
//
|
|
// Returns: none - throws upon failure.
|
|
//
|
|
// History: 05-12-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void CGetCmdProps::CreateNewPropSet(ULONG *cPropSets, DBPROPSET **ppPropSet, ULONG index)
|
|
{
|
|
XArrayOLEInPlace<CDbPropSet> xPropSet(_cPropertySets);
|
|
ULONG cPropSetsCopied = 0;
|
|
|
|
for ( unsigned i = 0; i < _cPropertySets; i++ )
|
|
{
|
|
if ( _xPropSet[i].guidPropertySet == guidQueryCorePropset )
|
|
{
|
|
CopyPropertySet( xPropSet[cPropSetsCopied], _xPropSet[i], index );
|
|
cPropSetsCopied++;
|
|
}
|
|
else if ( _xPropSet[i].guidPropertySet == guidCiFsExt )
|
|
{
|
|
CopyPropertySet( xPropSet[cPropSetsCopied], _xPropSet[i], index );
|
|
cPropSetsCopied++;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Other property sets just get copied verbatim (e.g. index == 0)
|
|
//
|
|
|
|
CopyPropertySet( xPropSet[cPropSetsCopied], _xPropSet[i], 0 );
|
|
cPropSetsCopied++;
|
|
}
|
|
}
|
|
|
|
*cPropSets = cPropSetsCopied;
|
|
*ppPropSet = xPropSet.Acquire();
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CGetCmdProps::CopyPropertySet, private
|
|
//
|
|
// Synopsis: Copies srcPropSet to destPropSet - using index for distributed props.
|
|
//
|
|
// Arguments: [destPropSet] -- destination prop set
|
|
// [srcPropSet] -- source prop set
|
|
// [index] -- specifies which of the distributed properties to use
|
|
//
|
|
// Returns: none - throws upon failure.
|
|
//
|
|
// History: 05-12-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CGetCmdProps::CopyPropertySet( CDbPropSet &destPropSet, CDbPropSet &srcPropSet, ULONG index )
|
|
{
|
|
RtlZeroMemory( &destPropSet, sizeof (CDbPropSet) );
|
|
RtlCopyMemory( &destPropSet.guidPropertySet, &srcPropSet.guidPropertySet, sizeof GUID );
|
|
|
|
XArrayOLEInPlace<CDbProp> xDestDbPrp(srcPropSet.cProperties);
|
|
|
|
//
|
|
// copy all the properties from the src property set
|
|
//
|
|
for ( unsigned i = 0; i < srcPropSet.cProperties; i++ )
|
|
{
|
|
CDbProp & destProp = xDestDbPrp[i];
|
|
CDbProp & srcProp = (CDbProp &)srcPropSet.rgProperties[i];
|
|
|
|
RtlZeroMemory(&destProp, sizeof (CDbProp) );
|
|
|
|
|
|
if ( srcProp.dwStatus != DBPROPSTATUS_OK )
|
|
{
|
|
destProp.dwPropertyID = srcPropSet.rgProperties[i].dwPropertyID;
|
|
destProp.dwStatus = DBPROPSTATUS_NOTSET;
|
|
destProp.vValue.vt = VT_EMPTY;
|
|
|
|
ciDebugOut(( DEB_TRACE, "PropID: %x, dwStatus: %x\n",
|
|
srcPropSet.rgProperties[i].dwPropertyID, srcProp.dwStatus ));
|
|
continue;
|
|
}
|
|
|
|
if ( destPropSet.guidPropertySet == guidQueryCorePropset )
|
|
{
|
|
switch (srcProp.dwPropertyID)
|
|
{
|
|
case DBPROP_MACHINE:
|
|
|
|
CopyDbProp(destProp, srcProp, index);
|
|
|
|
break;
|
|
|
|
default:
|
|
if ( !destProp.Copy( srcProp ) )
|
|
THROW( CException(E_OUTOFMEMORY) );
|
|
}
|
|
}
|
|
else if ( destPropSet.guidPropertySet == guidCiFsExt )
|
|
{
|
|
switch (srcProp.dwPropertyID)
|
|
{
|
|
case DBPROP_CI_INCLUDE_SCOPES:
|
|
case DBPROP_CI_DEPTHS:
|
|
|
|
//
|
|
// in none-distributed case, Scope and Depth cardinality can be > 1
|
|
//
|
|
|
|
if ( _cCardinality <= 1 )
|
|
{
|
|
if ( !destProp.Copy( srcProp ) )
|
|
THROW( CException(E_OUTOFMEMORY) );
|
|
}
|
|
else
|
|
{
|
|
// distributed case.
|
|
CopyDbProp(destProp, srcProp, index);
|
|
}
|
|
break;
|
|
|
|
case DBPROP_CI_CATALOG_NAME:
|
|
|
|
CopyDbProp(destProp, srcProp, index);
|
|
|
|
break;
|
|
|
|
default:
|
|
if ( !destProp.Copy( srcProp ) )
|
|
THROW( CException(E_OUTOFMEMORY) );
|
|
}
|
|
|
|
} // if-else-if
|
|
else
|
|
{
|
|
if ( !destProp.Copy( srcProp ) )
|
|
THROW( CException(E_OUTOFMEMORY) );
|
|
}
|
|
} // for
|
|
|
|
destPropSet.rgProperties = xDestDbPrp.Acquire();
|
|
destPropSet.cProperties = srcPropSet.cProperties;
|
|
} //CopyPropertySet
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CGetCmdProps::CopyDbProp
|
|
//
|
|
// Synopsis: copies source dbprop to the dest dbprop.
|
|
//
|
|
// Arguments: [destProp] -- destination dbProp
|
|
// [srcProp] -- source dbprop
|
|
// [index] -- specifies which property to copy
|
|
//
|
|
// Returns: None - throws upon failure.
|
|
//
|
|
// History: 05-12-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CGetCmdProps::CopyDbProp(CDbProp &destProp, CDbProp &srcProp, ULONG index)
|
|
{
|
|
RtlCopyMemory(&destProp,&srcProp,sizeof(CDbProp));
|
|
|
|
VARIANT & srcVar = srcProp.vValue;
|
|
VARIANT & destVar= destProp.vValue;
|
|
|
|
RtlZeroMemory( &destVar, sizeof (VARIANT) );
|
|
|
|
//
|
|
// index must be 0 if variant is not a safearray
|
|
//
|
|
if ( !(srcVar.vt & VT_ARRAY) && (0 != index) )
|
|
{
|
|
ciDebugOut(( DEB_ERROR, "index must be zero if not using VT_ARRAY, Index: %x\n", index));
|
|
THROW( CException( STATUS_INVALID_PARAMETER ) );
|
|
}
|
|
else if ( (srcVar.vt & VT_ARRAY) && (index >= srcVar.parray->rgsabound[0].cElements) )
|
|
{
|
|
ciDebugOut(( DEB_ERROR, "index value out of range: %x\n", index ));
|
|
THROW( CException( STATUS_INVALID_PARAMETER ) );
|
|
}
|
|
|
|
//
|
|
// copy dbprop
|
|
//
|
|
switch (srcVar.vt)
|
|
{
|
|
case VT_ARRAY|VT_BSTR:
|
|
{
|
|
SAFEARRAY & sa = *srcVar.parray;
|
|
BSTR * pBstr = (BSTR *)sa.pvData;
|
|
|
|
if ( sa.cDims != 1 )
|
|
THROW( CException( STATUS_INVALID_PARAMETER ) );
|
|
|
|
destVar.vt = VT_BSTR;
|
|
destVar.bstrVal = SysAllocString(pBstr[index]);
|
|
|
|
if ( 0 == destVar.bstrVal )
|
|
THROW( CException(E_OUTOFMEMORY) );
|
|
}
|
|
break;
|
|
|
|
case VT_BSTR:
|
|
{
|
|
destVar.vt = VT_BSTR;
|
|
destVar.bstrVal = SysAllocString(srcVar.bstrVal);
|
|
|
|
if ( 0 == destVar.bstrVal )
|
|
THROW( CException(E_OUTOFMEMORY) );
|
|
}
|
|
break;
|
|
|
|
case VT_ARRAY|VT_I4:
|
|
case VT_ARRAY|VT_UI4:
|
|
{
|
|
SAFEARRAY & sa = *srcVar.parray;
|
|
DWORD * pdwDepths = (DWORD *)sa.pvData;
|
|
|
|
if ( sa.cDims != 1 )
|
|
THROW( CException( STATUS_INVALID_PARAMETER ) );
|
|
|
|
destVar.vt = VT_I4;
|
|
destVar.lVal = pdwDepths[index];
|
|
}
|
|
break;
|
|
|
|
case VT_I4:
|
|
case VT_UI4:
|
|
{
|
|
destVar.vt = VT_I4;
|
|
destVar.lVal = srcVar.lVal;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
ciDebugOut(( DEB_ERROR,"Invalid VARIANT type: %x\n",destVar.vt));
|
|
|
|
THROW( CException( STATUS_INVALID_PARAMETER ) );
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CGetDbProps::ProcessDbInitPropSet
|
|
//
|
|
// Synopsis: Processes the DBPROPSET_INIT property set.
|
|
//
|
|
// Arguments: [propSet] - The property set to process.
|
|
//
|
|
// Returns: none - throws upon failure.
|
|
//
|
|
// History: 1-13-97 srikants Created
|
|
// 5-12-97 mohamedn fs/core prop set splits.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CGetCmdProps::ProcessDbInitPropSet( DBPROPSET & propSet )
|
|
{
|
|
CDbPropSet * pDbPropSet = (CDbPropSet *) &propSet;
|
|
|
|
for ( ULONG i = 0; i < propSet.cProperties; i++ )
|
|
{
|
|
CDbProp * pDbProp = pDbPropSet->GetProperty(i);
|
|
|
|
if ( DBPROPSTATUS_OK != pDbProp->dwStatus )
|
|
{
|
|
ciDebugOut(( DEB_TRACE, "DbProp.dwPropertyID: %x has dwStatus= %x\n",
|
|
pDbProp->dwPropertyID,pDbProp->dwStatus));
|
|
|
|
continue;
|
|
}
|
|
|
|
switch ( pDbProp->dwPropertyID )
|
|
{
|
|
case DBPROP_MACHINE:
|
|
// machine count can be greater than 1
|
|
|
|
_aMachines = GetWCharFromVariant(*pDbProp, &_cMachines);
|
|
|
|
Win4Assert( 0 != _aMachines );
|
|
|
|
break;
|
|
|
|
case DBPROP_CLIENT_CLSID:
|
|
{
|
|
WCHAR **apGuids = GetWCharFromVariant(*pDbProp, &_cGuids);
|
|
|
|
if ( _cGuids == 1 )
|
|
{
|
|
CGuidUtil::StringToGuid( apGuids[0], _clientGuid );
|
|
_fGuidValid = TRUE;
|
|
}
|
|
else
|
|
{
|
|
ciDebugOut(( DEB_ERROR, "Invalid value for PropertyID(%x)\n",
|
|
pDbProp->dwPropertyID ));
|
|
|
|
THROW( CException(STATUS_INVALID_PARAMETER) );
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ciDebugOut(( DEB_ERROR, "InvalidPropertyID(%x)\n",
|
|
pDbProp->dwPropertyID ));
|
|
|
|
THROW( CException(STATUS_INVALID_PARAMETER) );
|
|
}
|
|
}
|
|
} //ProcessDbInitPropSet
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CGetCmdProps::ProcessCiFsExtPropSet
|
|
//
|
|
// Synopsis: Processes the FSCI extension property set.
|
|
//
|
|
// Arguments: [propSet] - The propety set to process.
|
|
// Returns: none - throws upon failure.
|
|
//
|
|
// History: 1-13-97 srikants Created
|
|
// 5-12-97 mohamedn fs/core prop set splits.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CGetCmdProps::ProcessCiFsExtPropSet( DBPROPSET & propSet )
|
|
{
|
|
CDbPropSet * pDbPropSet = (CDbPropSet *) &propSet;
|
|
|
|
for ( ULONG i = 0; i < propSet.cProperties; i++ )
|
|
{
|
|
CDbProp * pDbProp = pDbPropSet->GetProperty(i);
|
|
|
|
if ( pDbProp->dwStatus != DBPROPSTATUS_OK )
|
|
{
|
|
ciDebugOut(( DEB_TRACE, "PropStatus (0x%X) for (%d) th property\n",
|
|
pDbProp->dwStatus, i ));
|
|
continue;
|
|
}
|
|
|
|
switch ( pDbProp->dwPropertyID )
|
|
{
|
|
case DBPROP_CI_CATALOG_NAME:
|
|
_aCatalogs = GetWCharFromVariant(*pDbProp,&_cCatalogs);
|
|
break;
|
|
|
|
case DBPROP_CI_DEPTHS:
|
|
_aDepths = GetDepthsFromVariant(*pDbProp, &_cDepths,
|
|
(ULONG)~( QUERY_SHALLOW |
|
|
QUERY_DEEP |
|
|
QUERY_PHYSICAL_PATH |
|
|
QUERY_VIRTUAL_PATH ) );
|
|
break;
|
|
|
|
case DBPROP_CI_INCLUDE_SCOPES:
|
|
_aPaths = GetWCharFromVariant(*pDbProp, &_cScopes);
|
|
break;
|
|
|
|
case DBPROP_CI_QUERY_TYPE:
|
|
switch ( pDbProp->vValue.vt)
|
|
{
|
|
case VT_I4:
|
|
case VT_UI4:
|
|
_type = (CiMetaData) pDbProp->vValue.ulVal;
|
|
break;
|
|
|
|
default:
|
|
ciDebugOut(( DEB_ERROR, "DBPROP_CI_QUERY_TYPE: invalid variant type: %x\n",
|
|
pDbProp->vValue.vt ));
|
|
|
|
THROW( CException(STATUS_INVALID_PARAMETER) );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
//
|
|
// skip extra properties
|
|
//
|
|
ciDebugOut(( DEB_TRACE, "non-Native PropID(%x)\n",
|
|
pDbProp->dwPropertyID ));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CGetCmdProps::ProcessPropSet
|
|
//
|
|
// Synopsis: Processes the given property set.
|
|
//
|
|
// Arguments: [propSet] -
|
|
//
|
|
// History: 1-13-97 srikants Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CGetCmdProps::ProcessPropSet( DBPROPSET & propSet )
|
|
{
|
|
if ( propSet.guidPropertySet == guidCiFsExt )
|
|
{
|
|
ProcessCiFsExtPropSet( propSet );
|
|
}
|
|
else if ( propSet.guidPropertySet == guidQueryCorePropset )
|
|
{
|
|
ProcessDbInitPropSet( propSet );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// skip other property sets -- not needed for Indexing Service.
|
|
//
|
|
}
|
|
}
|
|
|