Microsoft/WindowsXP-SP1
Microsoft/WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
f7ca35dddd
WindowsXP-SP1/base/fs/hsm/wsb/wsbcltn.cpp

1728 lines
38 KiB
C++
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
<EFBFBD> 1998 Seagate Software, Inc. All rights reserved
Module Name:
wsbcltn.cpp
Abstract:
These classes provide support for collections (lists) of "collectable"
objects.
Author:
Chuck Bardeen [cbardeen] 29-Oct-1996
Revision History:
--*/
#include "stdafx.h"
#include "wsbcltn.h"
HRESULT
CWsbCollection::Contains(
IN IUnknown* pCollectable
)
/*++
Implements:
IWsbCollection::Contains().
--*/
{
HRESULT hr = S_OK;
CComPtr<IWsbCollectable> pOut;
WsbTraceIn(OLESTR("CWsbCollection::Contains"), OLESTR(""));
hr = Find(pCollectable, IID_IWsbCollectable, (void**) &pOut);
if (hr == WSB_E_NOTFOUND) {
hr = S_FALSE;
}
WsbTraceOut(OLESTR("CWsbCollection::Contains"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbCollection::FinalConstruct(
void
)
/*++
Implements:
CComObjectRoot::FinalConstruct().
--*/
{
HRESULT hr = S_OK;
try {
WsbAffirmHr(CWsbPersistStream::FinalConstruct());
m_entries = 0;
InitializeCriticalSection(&m_CritSec);
} WsbCatch(hr);
return(hr);
}
void
CWsbCollection::FinalRelease(
void
)
/*++
Implements:
CComObjectRoot::FinalRelease().
--*/
{
DeleteCriticalSection(&m_CritSec);
CWsbPersistStream::FinalRelease();
}
HRESULT
CWsbCollection::Find(
IN IUnknown* pCollectable,
IN REFIID riid,
OUT void** ppElement
)
/*++
Implements:
IWsbCollection::Find().
--*/
{
CComPtr<IWsbEnum> pEnum;
HRESULT hr = S_OK;
BOOL matched = FALSE;
WsbTraceIn(OLESTR("CWsbCollection::Find"), OLESTR("riid = <%ls>"), WsbGuidAsString(riid));
try {
WsbAssert(0 != ppElement, E_POINTER);
WsbAffirmHr(Enum(&pEnum));
WsbAffirmHr(pEnum->Find(pCollectable, riid, ppElement));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CWsbCollection::Find"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbCollection::GetEntries(
OUT ULONG* pEntries
)
/*++
Implements:
IWsbCollection::GetEntries().
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CWsbCollection::GetEntries"), OLESTR(""));
try {
WsbAssert(0 != pEntries, E_POINTER);
*pEntries = m_entries;
} WsbCatch(hr);
WsbTraceOut(OLESTR("CWsbCollection::GetEntries"), OLESTR("hr = <%ls>, entries = <%ls>"), WsbHrAsString(hr), WsbPtrToUlongAsString(pEntries));
return(S_OK);
}
HRESULT
CWsbCollection::IsEmpty(
void
)
/*++
Implements:
IWsbCollection::IsEmpty().
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CWsbCollection::IsEmpty"), OLESTR(""));
if (0 != m_entries) {
hr = S_FALSE;
}
WsbTraceOut(OLESTR("CWsbCollection::IsEmpty"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbCollection::IsLocked(
void
)
/*++
Implements:
IWsbCollection::IsLocked().
--*/
{
HRESULT hr = S_OK;
BOOL tryEnter = FALSE;
WsbTraceIn(OLESTR("CWsbCollection::IsLocked"), OLESTR(""));
tryEnter = TryEnterCriticalSection(&m_CritSec);
if (tryEnter == 0) {
//
// Another thread has the collection locked
//
hr = S_OK;
} else {
//
// We got the lock, so unlock it
LeaveCriticalSection(&m_CritSec);
hr = S_FALSE;
}
WsbTraceOut(OLESTR("CWsbCollection::IsLocked"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return( hr );
}
HRESULT
CWsbCollection::Lock(
void
)
/*++
Implements:
CComObjectRoot::Lock().
--*/
{
WsbTrace(OLESTR("CWsbCollection::Lock - waiting for critical section\n"));
EnterCriticalSection(&m_CritSec);
WsbTrace(OLESTR("CWsbCollection::Lock - got critical section\n"));
return(S_OK);
}
HRESULT
CWsbCollection::OccurencesOf(
IN IUnknown* pCollectable,
OUT ULONG* pOccurences
)
/*++
Implements:
IWsbCollection::OccurrencesOf().
--*/
{
CComPtr<IWsbCollectable> pCollectableEnum;
CComPtr<IWsbEnum> pEnum;
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CWsbCollection::OccurencesOf"), OLESTR(""));
Lock();
try {
WsbAssert(0 != pCollectable, E_POINTER);
WsbAssert(0 != pOccurences, E_POINTER);
// Initialize the return value.
*pOccurences = 0;
// Get an enumerator.
WsbAffirmHr(Enum(&pEnum));
// Start at the front of the list.
for (hr = pEnum->Find(pCollectable, IID_IWsbCollectable, (void**) &pCollectableEnum);
SUCCEEDED(hr);
hr = pEnum->FindNext(pCollectable, IID_IWsbCollectable, (void**) &pCollectableEnum)) {
(*pOccurences)++;
pCollectableEnum = 0;
}
// We should always hit the end of the collection, so then
// change the return code to the appropriate value.
if (hr == WSB_E_NOTFOUND) {
if (0 == *pOccurences) {
hr = S_FALSE;
} else {
hr = S_OK;
}
}
} WsbCatch(hr);
Unlock();
WsbTraceOut(OLESTR("CWsbCollection::OccurencesOf"), OLESTR("hr = <%ls>, occurences = <%ls>"), WsbHrAsString(hr), WsbPtrToUlongAsString(pOccurences));
return(hr);
}
HRESULT
CWsbCollection::RemoveAndRelease(
IN IUnknown* pCollectable
)
/*++
Implements:
IWsbCollection::RemoveAndRelease().
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CWsbCollection::RemoveAndRelease"), OLESTR(""));
try {
WsbAssert(0 != pCollectable, E_POINTER);
WsbAffirmHr(Remove(pCollectable, IID_IWsbCollectable, NULL));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CWsbCollection::RemoveAndRelease"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbCollection::Test(
OUT USHORT* passed,
OUT USHORT* failed
)
/*++
Implements:
IWsbTestable::Test().
--*/
{
*passed = 0;
*failed = 0;
HRESULT hr = S_OK;
#if !defined(WSB_NO_TEST)
CComPtr<IWsbGuid> pGuid1;
CComPtr<IWsbGuid> pGuid2;
CComPtr<IWsbGuid> pGuid3;
CComPtr<IWsbGuid> pGuid4;
ULONG entries;
WsbTraceIn(OLESTR("CWsbCollection::Test"), OLESTR(""));
try {
// Clear out any entries that might be present.
hr = S_OK;
try {
WsbAssertHr(RemoveAllAndRelease());
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// There shouldn't be any entries.
hr = S_OK;
try {
WsbAssertHr(GetEntries(&entries));
WsbAssert(0 == entries, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// It should be empty.
hr = S_OK;
try {
WsbAssert(IsEmpty() == S_OK, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// We need some collectable items to exercise the collection.
WsbAssertHr(CoCreateInstance(CLSID_CWsbGuid, NULL, CLSCTX_ALL, IID_IWsbGuid, (void**) &pGuid1));
WsbAssertHr(pGuid1->SetGuid(CLSID_CWsbGuid));
// Add the item to the collection.
hr = S_OK;
try {
WsbAssertHr(Add(pGuid1));
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// There should be 1 entry.
hr = S_OK;
try {
WsbAssertHr(GetEntries(&entries));
WsbAssert(1 == entries, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// It should not be empty.
hr = S_OK;
try {
WsbAssert(IsEmpty() == S_FALSE, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// Does it think it has the item?
hr = S_OK;
try {
WsbAssertHr(Find(pGuid1, IID_IWsbGuid, (void**) &pGuid2));
WsbAssert(pGuid1->IsEqual(pGuid2) == S_OK, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// Add some more items
pGuid2 = 0;
WsbAssertHr(CoCreateInstance(CLSID_CWsbGuid, NULL, CLSCTX_ALL, IID_IWsbGuid, (void**) &pGuid2));
WsbAssertHr(pGuid2->SetGuid(CLSID_CWsbGuid));
WsbAssertHr(CoCreateInstance(CLSID_CWsbGuid, NULL, CLSCTX_ALL, IID_IWsbGuid, (void**) &pGuid3));
WsbAssertHr(pGuid3->SetGuid(IID_IWsbGuid));
// Add the items to the collection.
hr = S_OK;
try {
WsbAssertHr(Add(pGuid2));
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
hr = S_OK;
try {
WsbAssertHr(Add(pGuid3));
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// There should be 3 entries.
hr = S_OK;
try {
WsbAssertHr(GetEntries(&entries));
WsbAssert(3 == entries, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// How many copies does it have?
hr = S_OK;
try {
WsbAssertHr(OccurencesOf(pGuid1, &entries));
WsbAssert(2 == entries, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
hr = S_OK;
try {
WsbAssertHr(OccurencesOf(pGuid3, &entries));
WsbAssert(1 == entries, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// Remove one of the two identical items.
hr = S_OK;
try {
WsbAssertHr(Remove(pGuid1, IID_IWsbGuid, (void**) &pGuid4));
WsbAssertHr(pGuid1->IsEqual(pGuid4));
pGuid4 = 0;
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// There should be 2 entries.
hr = S_OK;
try {
WsbAssertHr(GetEntries(&entries));
WsbAssert(2 == entries, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// How many copies does it have?
hr = S_OK;
try {
WsbAssertHr(OccurencesOf(pGuid1, &entries));
WsbAssert(1 == entries, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
hr = S_OK;
try {
WsbAssertHr(OccurencesOf(pGuid3, &entries));
WsbAssert(1 == entries, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// Can we find an entry?
hr = S_OK;
try {
WsbAssertHr(Find(pGuid3, IID_IWsbGuid, (void**) &pGuid4));
WsbAssertHr(pGuid4->IsEqual(pGuid3));
pGuid4 = 0;
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// Does the collection still contain it?
hr = S_OK;
try {
WsbAssert(Contains(pGuid1) == S_OK, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// Remove the last of the two identical items, and verify
// that it can't be found. Then puit it back.
hr = S_OK;
try {
WsbAssertHr(Remove(pGuid1, IID_IWsbGuid, (void**) &pGuid4));
WsbAssert(Contains(pGuid1) == S_FALSE, E_FAIL);
WsbAssertHr(Add(pGuid4));
pGuid4 = 0;
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// Try out the persistence stuff.
{
CComPtr<IPersistFile> pFile1;
CComPtr<IPersistFile> pFile2;
CComPtr<IWsbCollection> pCollect2;
WsbAssertHr(((IUnknown*)(IWsbCollection*)this)->QueryInterface(IID_IPersistFile, (void**) &pFile1));
WsbAssertHr(CoCreateInstance(CLSID_CWsbOrderedCollection, NULL, CLSCTX_ALL, IID_IPersistFile, (void**) &pFile2));
// The item should be dirty.
hr = S_OK;
try {
WsbAssert(pFile1->IsDirty() == S_OK, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// Save the item, and remember.
hr = S_OK;
try {
WsbAssertHr(pFile1->Save(OLESTR("c:\\WsbTests\\WsbCollection.tst"), TRUE));
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// It shouldn't be dirty.
hr = S_OK;
try {
WsbAssert(pFile1->IsDirty() == S_FALSE, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// Load it back in to another instance.
hr = S_OK;
try {
WsbAssertHr(pFile2->Load(OLESTR("c:\\WsbTests\\WsbCollection.tst"), 0));
WsbAssertHr(pFile2->QueryInterface(IID_IWsbCollection, (void**) &pCollect2));
WsbAssert(pCollect2->Contains(pGuid1) == S_OK, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
}
// Remove and Release all the items.
hr = S_OK;
try {
WsbAssertHr(RemoveAllAndRelease());
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
// It should be empty.
hr = S_OK;
try {
WsbAssert(IsEmpty() == S_OK, E_FAIL);
} WsbCatch(hr);
if (hr == S_OK) {
(*passed)++;
} else {
(*failed)++;
}
} WsbCatch(hr);
// Tally up the results
if (*failed) {
hr = S_FALSE;
} else {
hr = S_OK;
}
WsbTraceOut(OLESTR("CWsbCollection::Test"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
#endif // WSB_NO_TEST
return(hr);
}
HRESULT
CWsbCollection::Unlock(
void
)
/*++
Implements:
CComObjectRoot::Unlock().
--*/
{
LeaveCriticalSection(&m_CritSec);
WsbTrace(OLESTR("CWsbCollection::Unlock - freed critical section\n"));
return(S_OK);
}
// Class: CWsbIndexedCollection
HRESULT
CWsbIndexedCollection::Add(
IN IUnknown* pCollectable
)
/*++
Implements:
IWsbCollection::Add().
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CWsbIndexedCollection::Add"), OLESTR(""));
Lock();
try {
WsbAssert(0 != pCollectable, E_POINTER);
WsbAffirmHr(AddAt(pCollectable, m_entries));
} WsbCatch(hr);
Unlock();
WsbTraceOut(OLESTR("CWsbIndexedCollection::Add"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbIndexedCollection::Append(
IUnknown* pCollectable
)
/*++
Implements:
IWsbIndexedCollection::Append().
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CWsbIndexedCollection::Append"), OLESTR(""));
hr = Add(pCollectable);
WsbTraceOut(OLESTR("CWsbIndexedCollection::Append"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbIndexedCollection::Enum(
OUT IWsbEnum** ppEnum
)
/*++
Implements:
IWsbCollection::Enum().
--*/
{
HRESULT hr = S_OK;
CComPtr<IWsbEnum> pEnum;
WsbTraceIn(OLESTR("CWsbIndexedCollection::Enum"), OLESTR(""));
try {
WsbAssert(0 != ppEnum, E_POINTER);
// Create the instance, initialize it to point to this collection, and
// return the pointer to the caller.
WsbAffirmHr(CoCreateInstance(CLSID_CWsbIndexedEnum, NULL, CLSCTX_ALL, IID_IWsbEnum, (void**) &pEnum));
WsbAffirmHr(pEnum->Init((IWsbCollection*) ((IWsbIndexedCollection*) this)));
*ppEnum = pEnum;
(*ppEnum)->AddRef();
} WsbCatch(hr);
WsbTraceOut(OLESTR("CWsbIndexedCollection::Enum"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbIndexedCollection::EnumUnknown(
OUT IEnumUnknown** ppEnum
)
/*++
Implements:
IWsbCollection::EnumUnknown().
--*/
{
HRESULT hr = S_OK;
CComPtr<IWsbEnum> pWsbEnum;
WsbTraceIn(OLESTR("CWsbIndexedCollection::EnumUnknown"), OLESTR(""));
try {
WsbAssert(0 != ppEnum, E_POINTER);
// Get the IWsbEnum interface, and then query for the IEnumUknown interface.
WsbAffirmHr(Enum(&pWsbEnum));
WsbAffirmHr(pWsbEnum->QueryInterface(IID_IEnumUnknown, (void**) ppEnum));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CWsbIndexedCollection::EnumUnknown"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbIndexedCollection::First(
IN REFIID riid,
OUT void** ppElement
)
/*++
Implements:
IWsbCollection::First().
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CWsbIndexedCollection::First"), OLESTR("iid = <%ls>"), WsbGuidAsString(riid));
try {
WsbAssert(0 != ppElement, E_POINTER);
WsbAffirm(m_entries != 0, WSB_E_NOTFOUND);
WsbAffirmHr(At(0, riid, ppElement));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CWsbIndexedCollection::First"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbIndexedCollection::Index(
IN IUnknown* pCollectable,
OUT ULONG* pIndex
)
/*++
Implements:
IWsbIndexedCollection::Index().
--*/
{
HRESULT hr = S_OK;
CComPtr<IWsbCollectable> pOut;
WsbTraceIn(OLESTR("CWsbIndexedCollection::Index"), OLESTR(""));
try {
WsbAssert(0 != pCollectable, E_POINTER);
WsbAssert(0 != pIndex, E_POINTER);
// Find the first occurence of the item.
WsbAffirmHr(CopyIfMatches(WSB_COLLECTION_MIN_INDEX, m_entries, pCollectable, 1, IID_IWsbCollectable, (void**) &pOut, NULL, pIndex));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CWsbIndexedCollection::Index"), OLESTR("hr = <%ls>, index = <%ls>"), WsbHrAsString(hr), WsbPtrToUlongAsString(pIndex));
return(hr);
}
HRESULT
CWsbIndexedCollection::Last(
IN REFIID riid,
OUT void** ppElement
)
/*++
Implements:
IWsbCollection::Last().
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CWsbIndexedCollection::Last"), OLESTR("iid = <%ls>"), WsbGuidAsString(riid));
try {
// As long as we have some entires, get the last one.
WsbAssert(0 != ppElement, E_POINTER);
WsbAffirm(m_entries != 0, WSB_E_NOTFOUND);
WsbAffirmHr(At(m_entries - 1, riid, ppElement));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CWsbIndexedCollection::Last"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbIndexedCollection::Prepend(
IN IUnknown* pCollectable
)
/*++
Implements:
IWsbIndexedCollection::Prepend().
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CWsbIndexedCollection::Prepend"), OLESTR(""));
try {
WsbAssert(0 != pCollectable, E_POINTER);
WsbAffirmHr(AddAt(pCollectable, 0));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CWsbIndexedCollection::Prepend"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbIndexedCollection::Remove(
IN IUnknown* pCollectable,
IN REFIID riid,
OUT void** ppElement
)
/*++
Implements:
IWsbCollection::Remove().
--*/
{
HRESULT hr = S_OK;
ULONG index;
WsbTraceIn(OLESTR("CWsbIndexedCollection::Remove"), OLESTR(""));
Lock();
try {
// Can we find it in our array?
WsbAffirmHr(Index(pCollectable, &index));
// Remove it from the specified offset.
WsbAffirmHr(RemoveAt(index, riid, ppElement));
} WsbCatch(hr);
Unlock();
WsbTraceOut(OLESTR("CWsbIndexedCollection::Remove"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbIndexedCollection::RemoveAllAndRelease(
void
)
/*++
Implements:
IWsbIndexedCollection::RemoveAllAndRelease().
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CWsbIndexedCollection::RemoveAllAndRelease"), OLESTR(""));
Lock();
try {
// Start at the end of the list, and keep removing from the
// back. For some types of collections, this may not be the most
// efficient way to remove all the elements.
if (m_entries > 0) {
ULONG index = m_entries - 1;
while (index > 0) {
WsbAffirmHr(RemoveAt(index, IID_IWsbCollectable, NULL));
--index;
}
WsbAffirmHr(RemoveAt(index, IID_IWsbCollectable, NULL));
}
} WsbCatch(hr);
Unlock();
WsbTraceOut(OLESTR("CWsbIndexedCollection::RemoveAllAndRelease"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbIndexedCollection::Test(
OUT USHORT* passed,
OUT USHORT* failed
)
/*++
Implements:
IWsbTestable::Test().
--*/
{
*passed = 0;
*failed = 0;
HRESULT hr = S_OK;
#if !defined(WSB_NO_TEST)
WsbTraceIn(OLESTR("CWsbIndexedCollection::Test"), OLESTR(""));
try {
// First run the standard tests for all collections.
WsbAffirmHr(CWsbCollection::Test(passed, failed));
// Now do the test that are specific for an indexed collection
// Tally up the results
if (*failed) {
hr = S_FALSE;
} else {
hr = S_OK;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("CWsbIndexedCollection::Test"), OLESTR("hr =<%ls>, testsRun = <%u>"), WsbHrAsString(hr));
#endif // WSB_NO_TEST
return(hr);
}
// Class: CWsbOrderedCollection
HRESULT
CWsbOrderedCollection::AddAt(
IN IUnknown* pCollectable,
IN ULONG index
)
/*++
Implements:
IWsbIndexedCollection::AddAt().
--*/
{
HRESULT hr = S_OK;
IWsbCollectable** pCollectableNew;
WsbTraceIn(OLESTR("CWsbOrderedCollection::AddAt"), OLESTR("index = <%lu>"), index);
Lock();
try {
// Are we beyond the end of the collection?
WsbAffirm(index <= m_entries, WSB_E_OUTOFBOUNDS);
// Is it full?
if (m_entries >= m_maxEntries) {
// Could we grow?
WsbAffirm(((WSB_COLLECTION_MAX_INDEX - m_maxEntries) >= m_growBy), WSB_E_TOOLARGE);
// Try to allocate a bigger array.
pCollectableNew = (IWsbCollectable**) WsbRealloc((void*) m_pCollectable, (m_maxEntries + m_growBy) * sizeof(IWsbCollectable*));
WsbAffirm(pCollectableNew != NULL, E_OUTOFMEMORY);
m_pCollectable = pCollectableNew;
m_maxEntries += m_growBy;
}
// If we have room, then add it to the collection.
// First shift any existing entries.
for (ULONG tmpIndex = m_entries; tmpIndex > index; tmpIndex--) {
m_pCollectable[tmpIndex] = m_pCollectable[tmpIndex - 1];
}
// Now add the new entry.
m_entries++;
WsbAffirmHr(pCollectable->QueryInterface(IID_IWsbCollectable,
(void**)&m_pCollectable[index]));
m_isDirty = TRUE;
} WsbCatch(hr);
Unlock();
WsbTraceOut(OLESTR("CWsbOrderedCollection::AddAt"), OLESTR("hr =<%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbOrderedCollection::At(
IN ULONG index,
IN REFIID riid,
OUT void** ppElement
)
/*++
Implements:
IWsbIndexedCollection::At().
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CWsbOrderedCollection::At"), OLESTR("index = <%lu>, riid = <%ls>"), index, WsbGuidAsString(riid));
Lock();
try {
WsbAffirm(index < m_entries, WSB_E_OUTOFBOUNDS);
WsbAssert(0 != ppElement, E_POINTER);
// If they asked for an interface, then try to get the desired
// interface for the item specified.
WsbAffirmHr((m_pCollectable[index])->QueryInterface(riid, (void**) ppElement));
} WsbCatch(hr);
Unlock();
WsbTraceOut(OLESTR("CWsbOrderedCollection::At"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbOrderedCollection::Copy(
IN ULONG start,
IN ULONG stop,
IN REFIID riid,
OUT void** elements,
OUT ULONG* pElementsFetched
)
/*++
Implements:
IWsbIndexedCollection::Copy().
--*/
{
HRESULT hr = S_OK;
ULONG toDo;
ULONG copied = 0;
ULONG index;
BOOL isIncrement = TRUE;
WsbTraceIn(OLESTR("CWsbOrderedCollection::Copy"), OLESTR("start = <%lu>, stop = <%lu>, riid = <%ls>"), start, stop, WsbGuidAsString(riid));
Lock();
try {
WsbAssert(0 != elements, E_POINTER);
WsbAssert(0 != pElementsFetched, E_POINTER);
WsbAffirm(start < m_entries, WSB_E_NOTFOUND);
// Determine how many elements to copy, and the order in which we are
// going (increasing vs. decreasing).
if (start <= stop) {
toDo = stop - start + 1;
} else {
toDo = start - stop + 1;
isIncrement = FALSE;
}
// Iterate over all the items in the range specified, and copy
// the interface in to the target array.
for (copied = 0, index = start; ((copied < toDo) && (index < m_entries)); copied++, isIncrement ? index++ : index--) {
WsbAffirmHr(m_pCollectable[index]->QueryInterface(riid, (void**) &(elements[copied])));
}
// Let them know if we didn't fill up the return buffer.
if (copied < toDo) {
hr = S_FALSE;
}
} WsbCatch(hr);
*pElementsFetched = copied;
Unlock();
WsbTraceOut(OLESTR("CWsbOrderedCollection::Copy"), OLESTR("hr = <%ls>, elementsFetched = <%lu>"), WsbHrAsString(hr), copied);
return(hr);
}
HRESULT
CWsbOrderedCollection::CopyIfMatches(
ULONG start,
ULONG stop,
IUnknown* pObject,
ULONG element,
REFIID riid,
void** elements,
ULONG* pElementsFetched,
ULONG* pStoppedAt
)
/*++
Implements:
IWsbIndexedCollection::CopyIfMatches().
--*/
{
HRESULT hr = S_OK;
ULONG copied = 0;
ULONG index = start;
ULONG end = stop;
BOOL done = FALSE;
CComPtr<IWsbCollectable> pCollectable;
WsbTraceIn(OLESTR("CWsbOrderedCollection::CopyIfMatches"), OLESTR("start = <%lu>, stop = <%lu>, riid = <%ls>"), start, stop, WsbGuidAsString(riid));
Lock();
try {
WsbAssert(0 != elements, E_POINTER);
WsbAssert(0 != pStoppedAt, E_POINTER);
WsbAssert((1 == element) || (0 != pElementsFetched), E_POINTER);
WsbAssert(0 != element, E_INVALIDARG);
WsbAffirm(start < m_entries, WSB_E_NOTFOUND);
WsbAffirmHr(pObject->QueryInterface(IID_IWsbCollectable,
(void **)&pCollectable));
if (start <= stop) {
// Incrementing.
if (stop >= m_entries) {
end = m_entries - 1;
}
// Continue from here to the end of the range.
while (!done) {
if (pCollectable->IsEqual(m_pCollectable[index]) == S_OK) {
WsbAffirmHr(m_pCollectable[index]->QueryInterface(riid, (void**) &(elements[copied])));
copied++;
}
if ((copied < element) && (index < end)) {
index++;
}
else {
done = TRUE;
}
}
} else {
// Decrementing..
while (!done) {
if (m_pCollectable[index]->IsEqual(pCollectable) == S_OK) {
WsbAffirmHr(m_pCollectable[index]->QueryInterface(riid, (void**) &(elements[copied])));
copied++;
}
if ((copied < element) && (index > end)) {
index--;
}
else {
done = TRUE;
}
}
}
if (0 != pElementsFetched) {
*pElementsFetched = copied;
}
*pStoppedAt = index;
// If we didn't find anything, then let them know.
WsbAffirm(0 != copied, WSB_E_NOTFOUND);
// Let them know if we didn't fill the output buffer,
// and t=let them know the last index that was checked.
if (copied < element) {
hr = S_FALSE;
}
} WsbCatch(hr);
Unlock();
WsbTraceOut(OLESTR("CWsbOrderedCollection::CopyIfMatches"), OLESTR("hr = <%ls>, elementsFetched = <%lu>, stoppedAt = <%ls>"), WsbHrAsString(hr), copied, WsbPtrToUlongAsString(pStoppedAt));
return(hr);
}
HRESULT
CWsbOrderedCollection::FinalConstruct(
void
)
/*++
Implements:
CComObjectRoot::FinalConstruct().
--*/
{
HRESULT hr = S_OK;
try {
WsbAffirmHr(CWsbCollection::FinalConstruct());
m_pCollectable = NULL;
m_maxEntries = 0;
m_growBy = 256;
} WsbCatch(hr);
return(hr);
}
void
CWsbOrderedCollection::FinalRelease(
void
)
/*++
Implements:
CComObjectRoot::FinalRelease().
--*/
{
if (0 != m_pCollectable) {
Lock();
RemoveAllAndRelease();
WsbFree((void*) m_pCollectable);
Unlock();
}
CWsbCollection::FinalRelease();
}
HRESULT
CWsbOrderedCollection::GetClassID(
OUT CLSID* pClsid
)
/*++
Implements:
IPersist::GetClassID().
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CWsbOrderedCollection::GetClassID"), OLESTR(""));
try {
WsbAssert(0 != pClsid, E_POINTER);
*pClsid = CLSID_CWsbOrderedCollection;
} WsbCatch(hr);
WsbTraceOut(OLESTR("CWsbOrderedCollection::GetClassID"), OLESTR("hr = <%ls>, CLSID = <%ls>"), WsbHrAsString(hr), WsbGuidAsString(*pClsid));
return(hr);
}
HRESULT
CWsbOrderedCollection::GetSizeMax(
OUT ULARGE_INTEGER* pSize
)
/*++
Implements:
IPersistStream::GetSizeMax().
--*/
{
HRESULT hr = S_OK;
IPersistStream* pPersistStream;
ULARGE_INTEGER size;
WsbTraceIn(OLESTR("CWsbOrderedCollection::GetSizeMax"), OLESTR(""));
try {
WsbAssert(0 == pSize, E_POINTER);
// The size of the header information.
pSize->QuadPart = 3 * WsbPersistSizeOf(ULONG);
// If we have entries, then add in the size for the maximum number
// of entries, assuming that they are all the same size.
if (m_entries != 0) {
WsbAffirmHr(First(IID_IPersistStream, (void**) &pPersistStream));
WsbAffirmHr(pPersistStream->GetSizeMax(&size));
pSize->QuadPart += (m_maxEntries * (size.QuadPart));
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("CWsbOrderedCollection::GetSizeMax"), OLESTR("hr = <%ls>, Size = <%ls>"), WsbHrAsString(hr), WsbPtrToUliAsString(pSize));
return(hr);
}
HRESULT
CWsbOrderedCollection::Load(
IN IStream* pStream
)
/*++
Implements:
IPersistStream::Load().
--*/
{
HRESULT hr = S_OK;
CComPtr<IWsbCollectable> pCollectable;
ULONG entries;
ULONG growBy;
ULONG maxEntries;
WsbTraceIn(OLESTR("CWsbOrderedCollection::Load"),
OLESTR("m_entries = %ld, m_maxEntries = %ld, m_growBy = %ld, m_pCollectable = %p"),
m_entries, m_maxEntries, m_growBy, m_pCollectable);
Lock();
try {
IWsbCollectable** pTmp;
// Make sure the collection starts empty
if (m_entries != 0) {
WsbAffirmHr(RemoveAllAndRelease());
}
// Do the easy stuff, but make sure that this order matches the order
// in the save method.
WsbAffirmHr(WsbLoadFromStream(pStream, &entries));
WsbAffirmHr(WsbLoadFromStream(pStream, &maxEntries));
WsbAffirmHr(WsbLoadFromStream(pStream, &growBy));
WsbAffirm(entries <= maxEntries, WSB_E_PERSISTENCE_FILE_CORRUPT);
// Allocate space for the array.
if (entries > m_maxEntries) {
pTmp = (IWsbCollectable**) WsbRealloc(m_pCollectable,
maxEntries * sizeof(IWsbCollectable*));
WsbAffirm(0 != pTmp, E_OUTOFMEMORY);
// Remember our new buffer.
m_pCollectable = pTmp;
m_maxEntries = maxEntries;
}
m_growBy = growBy;
// Now do the items in the collection.
for (ULONG index = 0; (index < entries); index++) {
WsbAffirmHr(OleLoadFromStream(pStream, IID_IWsbCollectable, (void**) &pCollectable));
WsbAffirmHr(Append(pCollectable));
pCollectable = 0;
}
} WsbCatch(hr);
Unlock();
WsbTraceOut(OLESTR("CWsbOrderedCollection::Load"),
OLESTR("m_entries = %ld, m_maxEntries = %ld, m_growBy = %ld, m_pCollectable = %p"),
m_entries, m_maxEntries, m_growBy, m_pCollectable);
return(hr);
}
HRESULT
CWsbOrderedCollection::RemoveAt(
IN ULONG index,
IN REFIID riid,
OUT void** ppElement
)
/*++
Implements:
IWsbIndexedCollection::RemoveAt().
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CWsbOrderedCollection::RemoveAt"), OLESTR("index = <%lu>, riid = <%ls>"), index, WsbGuidAsString(riid));
Lock();
try {
// Make sure that the index is in range.
WsbAffirm(index < m_entries, WSB_E_OUTOFBOUNDS);
// If they asked for an interface, then try to get the desired
// interface for the item specified.
if (0 != ppElement) {
WsbAffirmHr(m_pCollectable[index]->QueryInterface(riid, (void**) ppElement));
}
// Remove the item
m_pCollectable[index]->Release();
// Now shift all the items in the collection.
for (ULONG tmpIndex = index; (tmpIndex < (m_entries - 1)); tmpIndex++) {
m_pCollectable[tmpIndex] = m_pCollectable[tmpIndex + 1];
}
m_entries--;
m_isDirty = TRUE;
// If the collection has really shrunk in size, then we
// should free up some memory.
if ((m_maxEntries - m_entries) >= (2 * m_growBy)) {
// Try to allocate a smaller array.
IWsbCollectable** pCollectableNew = (IWsbCollectable**) WsbRealloc((void*) m_pCollectable, (m_maxEntries - m_growBy) * sizeof(IWsbCollectable*));
WsbAffirm(pCollectableNew != NULL, E_OUTOFMEMORY);
m_pCollectable = pCollectableNew;
m_maxEntries -= m_growBy;
}
} WsbCatch(hr);
Unlock();
WsbTraceOut(OLESTR("CWsbOrderedCollection::RemoveAt"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
CWsbOrderedCollection::Save(
IN IStream* pStream,
IN BOOL clearDirty
)
/*++
Implements:
IPersistStream::Save().
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CWsbOrderedCollection::Save"), OLESTR("clearDirty = <%ls>"), WsbBoolAsString(clearDirty));
Lock();
try {
// Check for consistency first
WsbAffirm(m_entries <= m_maxEntries, WSB_E_INVALID_DATA);
// Do the easy stuff, but make sure that this order matches the order
// in the load method.
WsbAffirmHr(WsbSaveToStream(pStream, m_entries));
WsbAffirmHr(WsbSaveToStream(pStream, m_maxEntries));
WsbAffirmHr(WsbSaveToStream(pStream, m_growBy));
// Now do the items in the collection.
if (m_entries > 0) {
CComPtr<IWsbEnum> pEnum;
CComPtr<IPersistStream> pPersistStream;
// We need to enumerate the items in the collection.
WsbAffirmHr(Enum(&pEnum));
for (hr = pEnum->First(IID_IPersistStream, (void**) &pPersistStream);
SUCCEEDED(hr);
hr = pEnum->Next(IID_IPersistStream, (void**) &pPersistStream)) {
hr = OleSaveToStream(pPersistStream, pStream);
pPersistStream = 0;
}
WsbAssert(hr == WSB_E_NOTFOUND, hr);
hr = S_OK;
}
// If we got it saved and we were asked to clear the dirty bit, then
// do so now.
if (clearDirty) {
m_isDirty = FALSE;
}
} WsbCatch(hr);
Unlock();
WsbTraceOut(OLESTR("CWsbOrderedCollection::Save"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
Reference in New Issue Copy Permalink