/////////////////////////////////////////////////////////////////
// HRESULT CRow::OpenRowset
//
/////////////////////////////////////////////////////////////////
HRESULT CRow::OpenRowset(CAggregate* pCAggregate, DBID* pTableID, DBID* pIndexID, REFIID riid, ULONG cPropSets, DBPROPSET* rgPropSets, IUnknown** ppIUnknown)
{
HRESULT hr = E_FAIL; // HRESULT
if(!m_pIScopedOperations)
return E_FAIL;
WCHAR wszTableName[MAX_QUERY_LEN+1];
WCHAR wszIndexName[MAX_QUERY_LEN+1];
// From IOpenRowset, get a rowset object
DBIDToString(pTableID, wszTableName, MAX_QUERY_LEN);
DBIDToString(pIndexID, wszIndexName, MAX_QUERY_LEN);
XTEST_(hr = m_pIScopedOperations->OpenRowset(
pCAggregate, // pUnkOuter
pTableID, // pTableID
pIndexID, // pIndexID
riid, // refiid
cPropSets, // cProperties
rgPropSets, // rgProperties
ppIUnknown),S_OK); // IRowset pointer
TRACE_METHOD(hr, L"IScopedOperations::OpenRowset(0x%p, %s, %s, %s, %d, 0x%p, &0x%p)", pCAggregate, wszTableName, wszIndexName, GetInterfaceName(riid), cPropSets, rgPropSets, ppIUnknown ? *ppIUnknown : NULL);
//Display Errors (if occurred)
TESTC(hr = DisplayPropErrors(hr, cPropSets, rgPropSets));
//Handle Aggregation
if(pCAggregate)
TESTC(hr = pCAggregate->HandleAggregation(riid, ppIUnknown));
CLEANUP:
return hr;
}
////////////////////////////////////////////////////////////////
// GetAxisRowset
//
// Get the axis info and rowset for the first axis.
// Return IRowset interface for the axis rowset.
//
/////////////////////////////////////////////////////////////////
HRESULT CDataset::GetAxisRowset(CAggregate* pCAggregate, DBCOUNTITEM iAxis, REFIID riid, ULONG cPropSets, DBPROPSET* rgPropSets, IUnknown** ppIUnknown)
{
HRESULT hr = E_FAIL;
if(m_pIMDDataset)
{
//GetAxisInfo (if not already)
if(m_cAxis == 0)
TESTC(hr = GetAxisInfo(&m_cAxis, &m_rgAxisInfo));
//GetAxisRowset
if(m_cAxis)
{
XTEST_(hr = m_pIMDDataset->GetAxisRowset(
pCAggregate,
iAxis,
riid,
cPropSets,
rgPropSets,
ppIUnknown),S_OK);
TRACE_METHOD(hr, L"IMDDataset::GetAxisRowset(0x%p, %d, %s, %d, 0x%p, &0x%p)", pCAggregate, iAxis, GetInterfaceName(riid), cPropSets, rgPropSets, ppIUnknown ? *ppIUnknown : NULL);
}
//Display Errors (if occurred)
TESTC(hr = DisplayPropErrors(hr, cPropSets, rgPropSets));
//Handle Aggregation
if(pCAggregate)
TESTC(hr = pCAggregate->HandleAggregation(riid, ppIUnknown));
}
CLEANUP:
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CDataSource::AdminCreateDataSource
//
/////////////////////////////////////////////////////////////////
HRESULT CDataSource::AdminCreateDataSource(CAggregate* pCAggregate, ULONG cPropSets, DBPROPSET* rgPropSets, REFIID riid, IUnknown** ppIUnknown)
{
HRESULT hr = S_OK;
DWORD dwCreateOpts = GetOptions()->m_dwCreateOpts;
if(m_pIDBDataSourceAdmin)
{
//IDBDataSourceAdmin::CreateDataSource
XTEST(hr = m_pIDBDataSourceAdmin->CreateDataSource(cPropSets, rgPropSets, pCAggregate, riid, ppIUnknown));
TRACE_METHOD(hr, L"IDBDataSourceAdmin::CreateDataSource(%d, 0x%p, 0x%p, %s, &0x%p)", cPropSets, rgPropSets, pCAggregate, GetInterfaceName(riid), ppIUnknown ? *ppIUnknown : NULL);
//Display any property errors...
TESTC(hr = DisplayPropErrors(hr, cPropSets, rgPropSets));
//Handle Aggregation
if(pCAggregate)
pCAggregate->HandleAggregation(riid, ppIUnknown);
//We are now Initialized
m_fInitialized = TRUE;
//Obtain all interfaces, now that we are initialized
TESTC(hr = AutoQI(dwCreateOpts));
}
CLEANUP:
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CDataset::DisplayObject
//
/////////////////////////////////////////////////////////////////
HRESULT CDataset::DisplayObject()
{
HRESULT hr = S_OK;
BINDCOLS eBindCols = (GetOptions()->m_dwAccessorOpts & ACCESSOR_BIND_BOOKMARK ? BIND_ALLCOLS : BIND_ALLCOLSEXPECTBOOKMARK);
if(m_pCMDIChild)
{
//Reset Cursor
m_pCMDIChild->m_pCDataGrid->m_fLastFetchForward = FALSE;
m_pCMDIChild->m_pCDataGrid->m_lCurPos = 0;
//First Clear the existing Window...
TESTC(hr = m_pCMDIChild->m_pCDataGrid->ClearAll());
}
//Create ColumnInfo
TESTC(hr = GetColInfo());
//Create Accessors and Setup bindings
TESTC(hr = CreateAccessors(eBindCols));
if(m_pCMDIChild)
{
//Refresh the Columns and Rows
TESTC(hr = m_pCMDIChild->m_pCDataGrid->RefreshData());
}
//Display the object...
TESTC(hr = CDataAccess::DisplayObject());
CLEANUP:
if(m_pCMDIChild)
m_pCMDIChild->UpdateControls();
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CAsynchBase::Initialize
//
/////////////////////////////////////////////////////////////////
HRESULT CAsynchBase::Initialize()
{
HRESULT hr = S_OK;
DWORD dwCreateOpts = GetOptions()->m_dwCreateOpts;
if(!m_pIDBInitialize)
goto CLEANUP;
//Initailize
//NOTE: Expect S_OK or DB_E_CANCELED, since canceling the dialog always returns DB_E_CANCELED
XTEST_(hr = m_pIDBInitialize->Initialize(), DB_E_CANCELED);
TRACE_METHOD(hr, L"IDBInitialize::Initialize()");
//Display any property errors...
TESTC(hr = DisplayPropErrors(hr, IID_IDBProperties, m_pIDBInitialize));
//We are now Initialized
m_fInitialized = TRUE;
//Obtain all interfaces, now that we are initialized
TESTC(hr = AutoQI(dwCreateOpts));
//Also "redraw" the object now that more interfaces are available for use
//For Example: If the rowset was originally obtained Asynchronously and now interfaces
//to obtain columns and data are available, display the object...
TESTC(hr = DisplayObject());
CLEANUP:
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CRow::DisplayObject
//
/////////////////////////////////////////////////////////////////
HRESULT CRow::DisplayObject()
{
HRESULT hr = S_OK;
BINDCOLS eBindCols = (GetOptions()->m_dwAccessorOpts & ACCESSOR_BIND_BOOKMARK ? BIND_ALLCOLS : BIND_ALLCOLSEXPECTBOOKMARK);
if(m_pCMDIChild)
{
//First Clear the existing Window...
m_pCMDIChild->m_pCDataGrid->m_fLastFetchForward = FALSE;
m_pCMDIChild->m_pCDataGrid->m_lCurPos = 0;
TESTC(hr = m_pCMDIChild->m_pCDataGrid->ClearAll());
}
//Setup ColumnAccess Structures, (based off the ColumnInfo)
TESTC(hr = SetupColAccess(eBindCols));
if(m_pCMDIChild)
{
//Refresh the Columns and Rows
TESTC(hr = m_pCMDIChild->m_pCDataGrid->RefreshData());
}
//Delegate
TESTC(hr = CDataAccess::DisplayObject());
CLEANUP:
if(m_pCMDIChild)
m_pCMDIChild->UpdateControls();
return hr;
}
////////////////////////////////////////////////////////////////
// CStream::ReadBytes
//
/////////////////////////////////////////////////////////////////
HRESULT CStream::ReadBytes(REFIID riid, DBLENGTH ulOffset, DBLENGTH cBytes, DBLENGTH cbMaxSize, void* pBuffer, DBLENGTH* pcbRead)
{
HRESULT hr = S_OK;
BOOL bUseDefault = FALSE;
ULONG cbRead = 0;
cBytes = min(cBytes, cbMaxSize);
//Determine object type
if(riid != IID_ISequentialStream && riid != IID_ILockBytes && riid != IID_IStream)
bUseDefault = TRUE;
//IID_ISequentialStream
if((riid == IID_ISequentialStream && m_pISequentialStream) || (bUseDefault && m_pISequentialStream))
{
//ISequentialStream::Read
//TODO64: I*::Read only takes a ULONG
//NOTE: ::Read can post errorinfo objects in the case of warnings. SQLOLEDB's XML Stream
//object will post execution errors on the last read...
XTEST_(hr = m_pISequentialStream->Read(pBuffer, (ULONG)cBytes, &cbRead),S_FALSE);
TESTC(TRACE_METHOD(hr, L"ISequentialStream::Read(0x%p, %d, &%d)", pBuffer, cBytes, cbRead));
}
//IID_ILockBytes
else if((riid == IID_ILockBytes && m_pILockBytes) || (bUseDefault && m_pILockBytes))
{
ULARGE_INTEGER ulgOffset;
ulgOffset.QuadPart = ulOffset;
//ILockBytes::ReadAt
//TODO64: I*::Read only takes a ULONG
XTEST_(hr = m_pILockBytes->ReadAt(ulgOffset, pBuffer, (ULONG)cBytes, &cbRead),S_FALSE);
TESTC(TRACE_METHOD(hr, L"ILockBytes::ReadAt(%d, 0x%p, %d, &%d)", ulOffset, pBuffer, cBytes, cbRead));
}
//IID_IStream
else if((riid == IID_IStream && m_pIStream) || (bUseDefault && m_pIStream))
{
//IStream::Read
//TODO64: I*::Read only takes a ULONG
XTEST_(hr = m_pIStream->Read(pBuffer, (ULONG)cBytes, &cbRead),S_FALSE);
TESTC(TRACE_METHOD(hr, L"IStream::Read(0x%p, %d, &%d)", pBuffer, cBytes, cbRead));
}
// else if(m_pIStorage)
// {
//TODO
// }
else
{
TESTC(hr = E_FAIL);
}
CLEANUP:
if(pcbRead)
*pcbRead = cbRead;
return hr;
}
////////////////////////////////////////////////////////////////
// CStream::WriteBytes
//
/////////////////////////////////////////////////////////////////
HRESULT CStream::WriteBytes(REFIID riid, DBLENGTH ulOffset, DBLENGTH cBytes, void* pBuffer, DBLENGTH* pcbWritten)
{
HRESULT hr = S_OK;
BOOL bUseDefault = FALSE;
ULONG cbWritten = 0;
//Determine object type
if(riid != IID_ISequentialStream && riid != IID_ILockBytes && riid != IID_IStream)
bUseDefault = TRUE;
//IID_ISequentialStream
if((riid == IID_ISequentialStream && m_pISequentialStream) || (bUseDefault && m_pISequentialStream))
{
//ISequentialStream::Write
//TODO64: I*::Write only takes a ULONG
XTEST(hr = m_pISequentialStream->Write(pBuffer, (ULONG)cBytes, &cbWritten));
TESTC(TRACE_METHOD(hr, L"ISequentialStream::Write(0x%p, %d, &%d)", pBuffer, cBytes, cbWritten));
}
//IID_ILockBytes
else if((riid == IID_ILockBytes && m_pILockBytes) || (bUseDefault && m_pILockBytes))
{
ULARGE_INTEGER ulgOffset;
ulgOffset.QuadPart = ulOffset;
//ILockBytes::WriteAt
//TODO64: I*::Write only takes a ULONG
XTEST(hr = m_pILockBytes->WriteAt(ulgOffset, pBuffer, (ULONG)cBytes, &cbWritten));
TESTC(TRACE_METHOD(hr, L"ILockBytes::WriteAt(%d, 0x%p, %d, &%d)", ulOffset, pBuffer, cBytes, cbWritten));
}
//IID_IStream
else if((riid == IID_IStream && m_pIStream) || (bUseDefault && m_pIStream))
{
//IStream::Write
//TODO64: I*::Write only takes a ULONG
XTEST(hr = m_pIStream->Write(pBuffer, (ULONG)cBytes, &cbWritten));
TESTC(TRACE_METHOD(hr, L"IStream::Write(0x%p, %d, &%d)", pBuffer, cBytes, cbWritten));
}
// else if(m_pIStorage)
// {
//TODO
// }
else
{
TESTC(hr = E_FAIL);
}
CLEANUP:
if(pcbWritten)
*pcbWritten = cbWritten;
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CDataset::GetCellData
//
/////////////////////////////////////////////////////////////////
HRESULT CDataset::GetCellData(DBORDINAL ulStartCell, DBORDINAL ulEndCell)
{
HRESULT hr = E_FAIL;
if(m_pIMDDataset)
{
//NOTE: Using cbRowSize of IAccessor::CreateAccessor
//Because this method fetches properties for more than one cell,
//the provider should know how long each row is. In this context, a "row" means the area
//allocated in the consumer's buffer to hold all properties pertaining to one cell.
//This information should be given in the cbRowSize parameter of IAccessor::CreateAccessor.
//If the value of this parameter is zero, the consumer wants to fetch only one row of data
//(one cell). In this case, it is an error to specify a ulStartCell different from the
//ulEndCell.
//Because of the above in the OLAP spec, we need to make sure our buffer is large enough
//to hold the number of requested cells...
if(ulEndCell > ulStartCell && m_cbRowSize)
SAFE_REALLOC(m_pData, BYTE, m_cbRowSize * (ulEndCell - ulStartCell + 1));
//IMDDataset::GetCellData
XTEST(hr = m_pIMDDataset->GetCellData(m_hAccessor, ulStartCell, ulEndCell, m_pData));
TESTC(TRACE_METHOD(hr, L"IMDDataset::GetCellData(0x%p, 0x%Id, 0x%Id, 0x%p)", m_hAccessor, ulStartCell, ulEndCell, m_pData));
}
CLEANUP:
return hr;
}
static Res MFSDescribe(Inst inst, mps_lib_FILE *stream, Count depth)
{
Pool pool = CouldBeA(AbstractPool, inst);
MFS mfs = CouldBeA(MFSPool, pool);
Res res;
if (!TESTC(MFSPool, mfs))
return ResPARAM;
if (stream == NULL)
return ResPARAM;
res = NextMethod(Inst, MFSPool, describe)(inst, stream, depth);
if (res != ResOK)
return res;
return WriteF(stream, depth + 2,
"unroundedUnitSize $W\n", (WriteFW)mfs->unroundedUnitSize,
"extendBy $W\n", (WriteFW)mfs->extendBy,
"extendSelf $S\n", WriteFYesNo(mfs->extendSelf),
"unitSize $W\n", (WriteFW)mfs->unitSize,
"freeList $P\n", (WriteFP)mfs->freeList,
"total $W\n", (WriteFW)mfs->total,
"free $W\n", (WriteFW)mfs->free,
"tractList $P\n", (WriteFP)mfs->tractList,
NULL);
}
/////////////////////////////////////////////////////////////////
// HRESULT CDataSource::CreateSession
//
/////////////////////////////////////////////////////////////////
HRESULT CDataSource::CreateSession(CAggregate* pCAggregate, REFIID riid, IUnknown** ppIUnknown)
{
HRESULT hr = S_OK;
if(m_pIDBCreateSession)
{
//CreateSession
TEST(hr = m_pIDBCreateSession->CreateSession(pCAggregate, riid, ppIUnknown));
TESTC(TRACE_METHOD(hr, L"IDBCreateSession::CreateSession(0x%p, %s, &0x%p)", pCAggregate, GetInterfaceName(riid), ppIUnknown ? *ppIUnknown : NULL));
//Handle Aggregation
if(pCAggregate)
TESTC(hr = pCAggregate->HandleAggregation(riid, ppIUnknown));
}
CLEANUP:
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CRow::Bind
//
/////////////////////////////////////////////////////////////////
HRESULT CRow::Bind(CAggregate* pCAggregate, WCHAR* pwszURL, DBBINDURLFLAG dwBindFlags, REFGUID rguidObjectType, REFIID riid, IUnknown** ppIUnknown)
{
HRESULT hr = S_OK;
DBBINDSTATUS dwBindStatus = 0;
if(m_pIBindResource == NULL)
return E_FAIL;
//Open
XTEST(hr = m_pIBindResource->Bind(pCAggregate, pwszURL, dwBindFlags, rguidObjectType, riid, NULL, NULL, &dwBindStatus, ppIUnknown));
TESTC(TRACE_METHOD(hr, L"IBindResource::Bind(0x%p, \"%s\", 0x%08x, %s, %s, NULL, NULL, &0x%p, &0x%p)", pCAggregate, pwszURL, dwBindFlags, GetObjectTypeName(rguidObjectType), GetInterfaceName(riid), &dwBindStatus, ppIUnknown ? *ppIUnknown : NULL));
//Handle Aggregation
if(pCAggregate)
TESTC(hr = pCAggregate->HandleAggregation(riid, ppIUnknown));
CLEANUP:
return hr;
} //CRow::Bind
////////////////////////////////////////////////////////////////
// CMultipleResults::GetResult
//
/////////////////////////////////////////////////////////////////
HRESULT CMultipleResults::GetResult(CAggregate* pCAggregate, DB_LRESERVE lResultFlag, REFIID riid, DBROWCOUNT* pcRowsAffected, IUnknown** ppIUnknown)
{
HRESULT hr = E_FAIL;
//No-op
if(m_pIMultipleResults == NULL)
return E_FAIL;
//IMultipleResults::GetResult...
XTEST(hr = m_pIMultipleResults->GetResult(pCAggregate, lResultFlag, riid, pcRowsAffected, ppIUnknown));
TESTC(TRACE_METHOD(hr, L"IMultipleResults::GetResult(0x%p, %d, %s, &%Id, &0x%p)", pCAggregate, lResultFlag, GetInterfaceName(riid), pcRowsAffected ? *pcRowsAffected : NULL, ppIUnknown ? *ppIUnknown : NULL));
//Handle Aggregation
if(pCAggregate)
TESTC(hr = pCAggregate->HandleAggregation(riid, ppIUnknown));
CLEANUP:
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CRow::CreateCommand
//
/////////////////////////////////////////////////////////////////
HRESULT CRow::CreateCommand(CAggregate* pCAggregate, REFIID riid, IUnknown** ppIUnknown)
{
HRESULT hr = S_OK;
//Obtain the IDBCreateCommand Interface
IDBCreateCommand* pIDBCreateCommand = SOURCE_GETINTERFACE(this, IDBCreateCommand);
if(pIDBCreateCommand)
{
//CreateCommand
XTEST(hr = pIDBCreateCommand->CreateCommand(pCAggregate, riid, ppIUnknown));
TESTC(TRACE_METHOD(hr, L"IDBCreateCommand::CreateCommand(0x%p, %s, &0x%p)", pCAggregate, GetInterfaceName(riid), ppIUnknown ? *ppIUnknown : NULL));
//Handle Aggregation
if(pCAggregate)
TESTC(hr = pCAggregate->HandleAggregation(riid, ppIUnknown));
}
CLEANUP:
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CSession::GetSchemaRowset
//
/////////////////////////////////////////////////////////////////
HRESULT CSession::GetSchemaRowset(CAggregate* pCAggregate, REFGUID guidSchema, ULONG cRestrictions, VARIANT* rgRestrictions, REFIID riid, ULONG cPropSets, DBPROPSET* rgPropSets, IUnknown** ppIUnknown)
{
HRESULT hr = S_OK;
if(!m_pIDBSchemaRowset)
return E_FAIL;
//Schema Rowset
WCHAR wszBuffer[MAX_NAME_LEN+1];
WCHAR* pwszSchemaName = GetSchemaName(guidSchema);
//Try to find the String Resprentation of the guidSchema
if(pwszSchemaName == NULL)
{
StringFromGUID2(guidSchema, wszBuffer, MAX_NAME_LEN);
pwszSchemaName = wszBuffer;
}
//GetSchema Rowset
XTEST_(hr = m_pIDBSchemaRowset->GetRowset(
pCAggregate, // punkOuter
guidSchema, // schema IID
cRestrictions, // # of restrictions
rgRestrictions, // array of restrictions
riid, // rowset interface
cPropSets, // # of properties
rgPropSets, // properties
ppIUnknown),S_OK); // rowset pointer
TRACE_METHOD(hr, L"IDBSchemaRowset::GetRowset(0x%p, %s, %d, 0x%p, %s, %d, 0x%p, &0x%p)", pCAggregate, pwszSchemaName, cRestrictions, rgRestrictions, GetInterfaceName(riid), cPropSets, rgPropSets, ppIUnknown ? *ppIUnknown : NULL);
//Display Errors (if occurred)
TESTC(hr = DisplayPropErrors(hr, cPropSets, rgPropSets));
//Handle Aggregation
if(pCAggregate)
TESTC(hr = pCAggregate->HandleAggregation(riid, ppIUnknown));
CLEANUP:
return hr;
}
////////////////////////////////////////////////////////////////
// CStream::ReadString
//
/////////////////////////////////////////////////////////////////
HRESULT CStream::ReadString(REFIID riid, DBLENGTH ulOffset, DBLENGTH cBytes, DBLENGTH ulMaxSize, WCHAR* pwszBuffer, DBLENGTH* pcbRead)
{
ASSERT(pwszBuffer);
HRESULT hr = S_OK;
pwszBuffer[0] = wEOL;
WCHAR pBuffer[MAX_COL_SIZE+1] = {0};
DWORD dwConvFlags = GetOptions()->m_dwConvFlags;
DBLENGTH cbRead = 0;
cBytes = min(min(sizeof(pBuffer), cBytes), ulMaxSize*sizeof(WCHAR));
//Delegate
TESTC(hr = ReadBytes(riid, ulOffset, cBytes, ulMaxSize*sizeof(WCHAR), pBuffer, &cbRead));
//What type of data are we reading
switch(m_wType)
{
case DBTYPE_WSTR:
case DBTYPE_STR:
//Add a NULL terminator on the end of the data before conversion
//since the spec indicates the stream is not NULL terminated...
//NOTE: We made sure we had a full extra WCHAR in the buffer ahead of time
memset((BYTE*)pBuffer + min(cBytes, cbRead), 0, sizeof(WCHAR));
cbRead += (m_wType == DBTYPE_WSTR) ? sizeof(WCHAR) : sizeof(CHAR);
break;
};
//Now that we have read the data, coerce it into a string for display purposes...
XTESTC_(hr = DataConvert
(
DBSTATUS_S_OK,
cbRead,
sizeof(pBuffer),
(m_wType == DBTYPE_WSTR || m_wType == DBTYPE_STR) ? m_wType : DBTYPE_BYTES,
pBuffer,
0,
0,
DBTYPE_WSTR,
NULL,
NULL,
pwszBuffer,
ulMaxSize*sizeof(WCHAR),
dwConvFlags
),S_OK);
CLEANUP:
if(pcbRead)
*pcbRead = cbRead;
return hr;
}
/////////////////////////////////////////////////////////////////
// CStream::DisplayObject
//
/////////////////////////////////////////////////////////////////
HRESULT CStream::DisplayObject()
{
HRESULT hr = S_OK;
//Display the object...
OnDefOperation();
//Delegate
TESTC(hr = CAsynchBase::DisplayObject());
CLEANUP:
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CConnectionPoint::GetConnectionInterface
//
/////////////////////////////////////////////////////////////////
HRESULT CConnectionPoint::GetConnectionInterface(IID* pIID)
{
HRESULT hr = S_OK;
if(m_pIConnectionPoint)
{
hr = m_pIConnectionPoint->GetConnectionInterface(pIID);
TESTC(TRACE_METHOD(hr, L"IConnectionPoint::GetConnectionInterface(&%s)", GetInterfaceName(pIID ? *pIID : IID_NULL)));
}
CLEANUP:
return hr;
}
//IStream interfaces
HRESULT CStorageBuffer::Seek(LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER * plibNewPosition)
{
HRESULT hr = S_OK;
ULONG ulNewPosition = 0;
//Delegate to the simplier version
TESTC(hr = Seek((LONG)dlibMove.QuadPart, dwOrigin, &ulNewPosition));
CLEANUP:
if(plibNewPosition)
plibNewPosition->QuadPart = ulNewPosition;
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CRow::Open
//
/////////////////////////////////////////////////////////////////
HRESULT CRow::Open(CAggregate* pCAggregate, DBID* pColumnID, REFGUID rguidObjectType, REFIID riid, IUnknown** ppIUnknown)
{
HRESULT hr = S_OK;
if(m_pIRow == NULL)
return E_FAIL;
//Convert the DBID to a string for display...
WCHAR wszBuffer[MAX_QUERY_LEN+1] = {0};
DBIDToString(pColumnID, wszBuffer, MAX_QUERY_LEN);
//Open
XTEST(hr = m_pIRow->Open(pCAggregate, pColumnID, rguidObjectType, 0, riid, ppIUnknown));
TESTC(TRACE_METHOD(hr, L"IRow::Open(0x%p, %s, %s, 0, %s, &0x%p)", pCAggregate, wszBuffer, GetObjectTypeName(rguidObjectType), GetInterfaceName(riid), ppIUnknown ? *ppIUnknown : NULL));
//Handle Aggregation
if(pCAggregate)
TESTC(hr = pCAggregate->HandleAggregation(riid, ppIUnknown));
CLEANUP:
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CRow::GetColumns
//
/////////////////////////////////////////////////////////////////
HRESULT CRow::GetColumns(ULONG cColAccess, DBCOLUMNACCESS* rgColAccess)
{
HRESULT hr = S_OK;
if(m_pIRow == NULL)
return E_FAIL;
//GetColumns
XTEST(hr = m_pIRow->GetColumns(cColAccess, rgColAccess));
TESTC(TRACE_METHOD(hr, L"IRow::GetColumns(%lu, 0x%p)", cColAccess, rgColAccess));
CLEANUP:
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CContainerBase::FindConnectionPoint
//
/////////////////////////////////////////////////////////////////
HRESULT CContainerBase::FindConnectionPoint(REFIID riid, IConnectionPoint** ppIConnectionPoint)
{
HRESULT hr = S_OK;
if(m_pIConnectionPointContainer)
{
//IConnectionPointContainer::FindConnectionPoint
hr = m_pIConnectionPointContainer->FindConnectionPoint(riid, ppIConnectionPoint);
TESTC(TRACE_METHOD(hr, L"IConnectionPointContainer::FindConnectionPoint(%s, &0x%p)", GetInterfaceName(riid), ppIConnectionPoint ? *ppIConnectionPoint : NULL));
}
CLEANUP:
return hr;
}
/////////////////////////////////////////////////////////////////
// GetAxisInfo
//
// Get the axis info for all axis in the current dataset.
// Return count and array of axis info.
//
/////////////////////////////////////////////////////////////////
HRESULT CDataset::GetAxisInfo(DBCOUNTITEM* pcAxis, MDAXISINFO** prgAxisInfo)
{
HRESULT hr = E_FAIL;
if(m_pIMDDataset)
{
//IMDDataset::GetAxisInfo
XTEST(hr = m_pIMDDataset->GetAxisInfo(pcAxis, prgAxisInfo));
TESTC(TRACE_METHOD(hr, L"IMDDataset::GetAxisInfo(%lu, &0x%p)", pcAxis ? *pcAxis : 0, prgAxisInfo ? *prgAxisInfo : NULL));
}
CLEANUP:
return hr;
}
////////////////////////////////////////////////////////////////
// CStream::Seek
//
/////////////////////////////////////////////////////////////////
HRESULT CStream::Seek(LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
{
HRESULT hr = E_INVALIDARG;
if(m_pIStream)
{
//IStream::Seek
TEST(hr = m_pIStream->Seek(dlibMove, dwOrigin, plibNewPosition));
TESTC(TRACE_METHOD(hr, L"IStream::Seek(%lld, %d, &%lld)", dlibMove.QuadPart, dwOrigin, plibNewPosition ? plibNewPosition->QuadPart : 0));
}
CLEANUP:
return hr;
}
////////////////////////////////////////////////////////////////
// CStream::Clone
//
/////////////////////////////////////////////////////////////////
HRESULT CStream::Clone(IStream** ppStream)
{
HRESULT hr = S_OK;
if(m_pIStream)
{
//IStream::Clone
XTEST(hr = m_pIStream->Clone(ppStream));
TESTC(TRACE_METHOD(hr, L"IStream::Clone(&0x%p)", ppStream ? *ppStream : NULL));
}
CLEANUP:
return hr;
}
Res InstDescribe(Inst inst, mps_lib_FILE *stream, Count depth)
{
InstClass klass;
if (!TESTC(Inst, inst))
return ResPARAM;
if (stream == NULL)
return ResPARAM;
klass = ClassOfPoly(Inst, inst);
return WriteF(stream, depth,
"$S $P\n", (WriteFS)ClassName(klass), inst,
NULL);
}
/////////////////////////////////////////////////////////////////
// HRESULT CBinder::CreateBinder
//
/////////////////////////////////////////////////////////////////
HRESULT CBinder::CreateBinder(REFCLSID clsid)
{
HRESULT hr = S_OK;
CComPtr<IBindResource> spBindResource;
//Create the Binder object (optional object)...
XTESTC(hr = m_pCMainWindow->m_pCRootEnumerator->CreateInstance(NULL, clsid, CLSCTX_ALL, IID_IBindResource, (IUnknown**)&spBindResource));
//Delegate
m_guidSource = clsid;
TESTC(hr = CreateObject(NULL, IID_IBindResource, spBindResource));
CLEANUP:
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CSession::GetDataSource
//
/////////////////////////////////////////////////////////////////
HRESULT CSession::GetDataSource(REFIID riid, IUnknown** ppIUnknown)
{
HRESULT hr = S_OK;
//This interface is required to continue...
if(m_pIGetDataSource)
{
//IGetDataSource::GetDataSource
XTEST(hr = m_pIGetDataSource->GetDataSource(riid, ppIUnknown));
TESTC(TRACE_METHOD(hr, L"IGetDataSource::GetDataSource(%s, &0x%p)", GetInterfaceName(riid), ppIUnknown ? *ppIUnknown : NULL));
}
CLEANUP:
return hr;
}
/////////////////////////////////////////////////////////////////////////////
// CAggregate::HandleAggregation
//
/////////////////////////////////////////////////////////////////////////////
HRESULT CAggregate::HandleAggregation(REFIID riid, IUnknown** ppIUnknown)
{
HRESULT hr = S_OK;
IUnknown* pIUnkInner = ppIUnknown ? *ppIUnknown : NULL;
if(pIUnkInner)
{
//This would be a bug in the provider if aggregaiton succeeded
//but the user didn't request IID_IUnknown.
if(riid != IID_IUnknown)
{
//NOTE: We don't want to just continue here since this is dangerous.
//If the provider succeeds, this means the outer object was probably returned rather
//than the inner non-delegating IUnknown, this will cause our outer controlling object
//to have a circular QI problem when asked for an inner interface, and will have refcounting
//problems as well. Might as well let the use know, and don't further this provider bug...
if(IDNO == wMessageBox
(
GetFocus(),
MB_TASKMODAL | MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON1,
wsz_ERROR,
L"Provider Bug: Allowed Aggregation and riid!=IID_IUnknown!\n\n"
L"This may crash your Provider...\n"
L"Do you wish to continue anyway?"
))
{
//return a failure if the user wished not to continue...
TESTC(hr = E_INVALIDARG);
}
}
//We need to "hook" up our objects. So that our outer controlling object
//has a pointer to the inner for delegating QI calls. This must be an non-delegating
//inner IUnknown, (see below). Also the caller of this function will ALWAYS
//release their CAggregate object, and we return a the Aggregate object with our
//reference count. (consistent with COM, calle never releases callers IUnknown, and
//calle always addref's if they hold onto the callers object).
if(SUCCEEDED(hr = SetInner(pIUnkInner)))
{
//SetInner
TRACE_RELEASE(pIUnkInner, L"IUnknown");
hr = QueryInterface(IID_IUnknown, (void**)ppIUnknown);
}
}
CLEANUP:
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CBinder::SetProperties
//
/////////////////////////////////////////////////////////////////
HRESULT CBinder::SetProperties(ULONG cPropSets, DBPROPSET* rgPropSets)
{
HRESULT hr = S_OK;
if(m_pIDBProperties && cPropSets)
{
//SetProperties
XTEST_(hr = m_pIDBProperties->SetProperties(cPropSets, rgPropSets),S_OK);
TRACE_METHOD(hr, L"IDBProperties::SetProperties(%d, 0x%p)", cPropSets, rgPropSets);
//Display any property errors...
TESTC(hr = DisplayPropErrors(hr, cPropSets, rgPropSets));
}
CLEANUP:
return hr;
}
