fxcollection.cpp

Go to the documentation of this file.

/*++
 
Copyright (c) Microsoft Corporation
 
Module Name:
 
    FxCollection.cpp
 
Abstract:
 
    This module implements a simple collection class to operate on
    objects derived from FxObject.
 
Author:
 
 
 
Environment:
 
    Both kernel and user mode
 
Revision History:
 
--*/
 
#include "fxsupportpch.hpp"
 
FxCollectionInternal::FxCollectionInternal(
    VOID
    )
{
    m_Count = 0;
    InitializeListHead(&m_ListHead);
}
 
FxCollectionInternal::~FxCollectionInternal(
    VOID
    )
{
    Clear();
}
 
VOID
FxCollectionInternal::Clear(
    VOID
    )
{
    while (!IsListEmpty(&m_ListHead)) {
        Remove(0);
    }
}
 
ULONG
FxCollectionInternal::Count(
    VOID
    )
{
    return m_Count;
}
 
BOOLEAN
FxCollectionInternal::Add(
    __in PFX_DRIVER_GLOBALS FxDriverGlobals,
    __in FxObject *Item
    )
{
    FxCollectionEntry *pNode;
 
    pNode = AllocateEntry(FxDriverGlobals);
 
    if (pNode != NULL) {
        InsertTailList(&m_ListHead, &pNode->m_ListEntry);
 
        AddEntry(pNode, Item);
    }
 
    return pNode != NULL;
}
 
_Must_inspect_result_
FxCollectionEntry*
FxCollectionInternal::FindEntry(
    __in ULONG Index
    )
{
    PLIST_ENTRY ple;
    ULONG i;
 
    if (Index >= m_Count) {
        return NULL;
    }
 
    for (i = 0, ple = m_ListHead.Flink;
         ple != &m_ListHead;
         ple = ple->Flink, i++) {
        if (i != Index) {
            continue;
        }
 
        return CONTAINING_RECORD(ple, FxCollectionEntry, m_ListEntry);
    }
 
    return NULL;
}
 
_Must_inspect_result_
FxCollectionEntry*
FxCollectionInternal::FindEntryByObject(
    __in FxObject* Object
    )
{
    PLIST_ENTRY ple;
 
    for (ple = m_ListHead.Flink; ple != &m_ListHead; ple = ple->Flink) {
        FxCollectionEntry* pNode;
 
        pNode = CONTAINING_RECORD(ple, FxCollectionEntry, m_ListEntry);
        if (pNode->m_Object == Object) {
            return pNode;
        }
    }
 
    return NULL;
}
 
NTSTATUS
FxCollectionInternal::Remove(
    __in ULONG Index
    )
{
    FxCollectionEntry *pNode;
 
    pNode = FindEntry(Index);
 
    if (pNode != NULL) {
        return RemoveEntry(pNode);
    }
    else {
        return STATUS_NOT_FOUND;
    }
}
 
_Must_inspect_result_
NTSTATUS
FxCollectionInternal::RemoveItem(
    __in FxObject* Item
    )
{
    FxCollectionEntry* pNode;
 
    pNode = FindEntryByObject(Item);
 
    if (pNode != NULL) {
        return RemoveEntry(pNode);
    }
 
    return STATUS_NOT_FOUND;
}
 
VOID
FxCollectionInternal::CleanupEntry(
    __in FxCollectionEntry* Entry
    )
{
    RemoveEntryList(&Entry->m_ListEntry);
    delete Entry;
 
    m_Count--;
}
 
NTSTATUS
FxCollectionInternal::RemoveEntry(
    __in FxCollectionEntry* Entry
    )
{
    CleanupEntryObject(Entry->m_Object);
    CleanupEntry(Entry);
 
    return STATUS_SUCCESS;
}
 
_Must_inspect_result_
FxObject*
FxCollectionInternal::GetItem(
    __in ULONG Index
    )
 
{
    FxCollectionEntry* pNode;
 
    pNode = FindEntry(Index);
    if (pNode != NULL) {
        return pNode->m_Object;
    }
    else {
        return NULL;
    }
}
 
_Must_inspect_result_
FxObject*
FxCollectionInternal::GetFirstItem(
    VOID
    )
{
    if (IsListEmpty(&m_ListHead)) {
        return NULL;
    }
    else {
        return CONTAINING_RECORD(m_ListHead.Flink,
                                 FxCollectionEntry,
                                 m_ListEntry)->m_Object;
    }
}
 
_Must_inspect_result_
FxObject*
FxCollectionInternal::GetLastItem(
    VOID
    )
{
    if (IsListEmpty(&m_ListHead)) {
        return NULL;
    }
    else {
        return CONTAINING_RECORD(m_ListHead.Blink,
                                 FxCollectionEntry,
                                 m_ListEntry)->m_Object;
    }
}
 
FxCollection::FxCollection(
    __in PFX_DRIVER_GLOBALS FxDriverGlobals
    ) :
    FxNonPagedObject(FX_TYPE_COLLECTION, sizeof(FxCollection), FxDriverGlobals)
{
}
 
FxCollection::FxCollection(
    __in PFX_DRIVER_GLOBALS FxDriverGlobals,
    __in WDFTYPE Type,
    __in USHORT Size
    ) : FxNonPagedObject(Type, Size, FxDriverGlobals)
{
}
 
FxCollection::~FxCollection(
    VOID
    )
{
    Clear();
}
 
VOID
FxCollection::StealCollection(
    __in FxCollection* Collection
    )
{
    PLIST_ENTRY ple;
 
    m_Count = Collection->m_Count;
    Collection->m_Count = 0;
 
    while (!IsListEmpty(&Collection->m_ListHead)) {
        FxCollectionEntry* pEntry;
 
        ple = RemoveHeadList(&Collection->m_ListHead);
        pEntry = CONTAINING_RECORD(ple, FxCollectionEntry, m_ListEntry);
 
        //
        // When we are tracking reference tags, the tag associated with the
        // reference matters.  When we added the object to Collection, we used
        // that pointer as the tag.  We must remove that tag and readd the
        // reference using the this value as a tag.
        //
        // Obviously, order is important here.  Add the reference first so that
        // we know the relese will make the object go away.
        //
        pEntry->m_Object->ADDREF(this);
        pEntry->m_Object->RELEASE(Collection);
 
        InsertTailList(&m_ListHead, ple);
    }
}