windows-server-2003/admin/activec/nodemgr/containr.h

//____________________________________________________________________________
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1996 - 1999
//
//  File:       Containr.h
//
//  Contents:   declarations of map and pair container classes
//
//  Classes:
//
//  Functions:
//
//  History:    10/8/98   VivekJ   Created
//
//____________________________________________________________________________




//#define MAPDBG
#pragma warning(disable : 4786)
template<typename _T1, typename _T2> class Pair
{
public:
    typedef _T1 First;
    typedef _T2 Second;
    Pair() {}
    Pair(const First& f, const Second& s) : m_First(f), m_Second(s) {}
    Pair(const Pair& p) : m_First(p.m_First), m_Second(p.m_Second) {}
    ~Pair() {}
    Pair& operator=(const Pair& p) { if (this != &p) {m_First = p.m_First; m_Second = p.m_Second; } return *this; }
    //bool operator==(const Pair& p) const { return m_First == p.m_First && m_Second == p.m_Second; }
    //bool operator!=(const Pair& p) const { return !operator==(p); }
    const First& GetFirst() const { return m_First; }
    void SetFirst(const First& f) { m_First = f; };
    const Second& GetSecond() const { return m_Second; }
    void SetSecond(const Second& s) { m_Second = s; };
    First* GetFirstPtr() { return reinterpret_cast<First*>(reinterpret_cast<char*>(this) + offsetof(Pair, m_First)); }
    Second* GetSecondPtr() { return reinterpret_cast<Second*>(reinterpret_cast<char*>(this) + offsetof(Pair, m_Second)); }
    const First* GetFirstPtr() const { return reinterpret_cast<const First*>(reinterpret_cast<const char*>(this) + offsetof(Pair, m_First)); }
    const Second* GetSecondPtr() const { return reinterpret_cast<const Second*>(reinterpret_cast<const char*>(this) + offsetof(Pair, m_Second)); }
private:
    First m_First;
    Second m_Second;
}; // class Pair

template<typename _T, typename _Key> class Map
// This is a temporary class which should be replaced by something that can
// hold smart pointers
{
public:
    typedef _T T;
    typedef _Key Key;

    typedef Pair<T, Key> Element;
    typedef Element* iterator;
    typedef const Element* const_iterator;

    explicit Map(size_t initialSize = 0)
        : m_nSize(0), m_nUsed(0), m_pMap(NULL), m_pNext(NULL)
        #ifdef MAPDBG
        , m_nFinds(0), m_nCompares(0)
        #endif //MAPDBG
    {
        const bool bAllocated = Allocate(initialSize);
        ASSERT(m_nSize == initialSize);
        ASSERT(bAllocated);
    }

    Map(const Map& m)
        : m_nSize(0), m_nUsed(0), m_pMap(NULL), m_pNext(NULL)
        #ifdef MAPDBG
        , m_nFinds(0), m_nCompares(0)
        #endif //MAPDBG
    {
        ASSERT(&m != NULL);
        if (m.m_nUsed == 0)
            return;
        const bool bAllocated = Allocate(m.m_nUsed);
        ASSERT(bAllocated);
        if (!bAllocated)
            return;
        ASSERT(m_nSize == m.m_nUsed);
        ASSERT(m_pMap != NULL);
        m_pNext = UninitializedCopy(m_pMap, m.m_pMap, m_nSize);
        m_nUsed = m_nSize;
    }

    ~Map()
    {
        Destroy();
    }

    Map& operator=(const Map& m)
    {
        ASSERT(&m != NULL);
        if (&m == this)
            return *this;

        Destroy();

        if (m.m_nUsed == 0)
            return *this;

        const bool bAllocated = Allocate(m.m_nUsed);
        ASSERT(bAllocated);
        if (!bAllocated)
            return *this;
        ASSERT(m_nSize == m.m_nUsed);
        ASSERT(m_pMap != NULL);
        m_pNext = UninitializedCopy(m_pMap, m.m_pMap, m_nSize);
        m_nUsed = m_nSize;
        return *this;
    }
    
    const_iterator GetBegin() const
    {
        return m_pMap;
    }

    size_t GetSize() const
    {
        return m_nUsed;
    }

    Element* GetPair(size_t n) const
    {
        if (n >= m_nUsed)
            return NULL;
        else
            return m_pMap + n;
    }

    const_iterator GetEnd() const
    {
        return m_pMap + m_nUsed;
    }

    bool Allocate(size_t nSize)
    {
        ASSERT(m_nSize == 0 || nSize > m_nSize);
        if (nSize <= m_nSize)
            return true;

        Element* pNewMap = reinterpret_cast<Element*>(new char[nSize * sizeof(Element)]);
        ASSERT(pNewMap != NULL);
        if (pNewMap == NULL)
            return false;

        const size_t nUsed = m_nUsed;
        Element* const pCopied = UninitializedCopy(pNewMap, m_pMap, nUsed);
        ASSERT(pCopied != NULL);
        if (pCopied == NULL)
            return false;

        Destroy();
        m_pMap = m_pNext = pNewMap;
        m_nSize = nSize;
        m_nUsed = nUsed;
        return true;
    }

    bool Insert(const T& t, const Key& key)
    {
        ASSERT(&t != NULL);
        ASSERT(&key != NULL);
        Element* const pUnique = FindElement(key, false);
        if (pUnique != NULL)
            return false;
        ASSERT(m_nUsed <= m_nSize);
        if (m_nUsed >= m_nSize)
        {
            const unsigned long nNewSize = m_nSize == 0 ? 1 : m_nSize + (m_nSize + 1) / 2;
            const bool bMoreAllocated = Allocate(nNewSize);
            ASSERT(bMoreAllocated);
            if (!bMoreAllocated)
                return false;
        }
        Element e(t, key);
        Element* const dest = m_pMap + m_nUsed++;
        m_pNext = UninitializedCopy(dest, &e, 1);
        ASSERT(m_pNext != NULL);
        return true;
    }

    bool Remove(const Key& key)
    {
        ASSERT(&key != NULL);
        Element* const e = FindElement(key);
        if (e == NULL)
            return false;
        Element* endOfUsed = m_pMap + m_nUsed--;
        ASSERT(e < endOfUsed);
        ASSERT(e >= m_pMap);
        const size_t numberToCopy = endOfUsed - (e + 1);
        Copy(const_cast<Element*>(e), e+1, numberToCopy);
        (endOfUsed - 1)->~Pair<T, Key>();
        if (m_pNext >= endOfUsed)
            m_pNext = m_pMap;
        return true;
    }
    
    T& operator[](const Key& key) const
    {
        ASSERT(&key != NULL);
        T* const t = Find(key);
        ASSERT(t != NULL);
        return *t;
    }

    T* Find(const Key& key) const
    {
        ASSERT(&key != NULL);
        Element* const e = FindElement(key);
        return e != NULL ? e->GetFirstPtr() : NULL;
    }

    size_t Size() const
    {
        return m_nUsed;
    }

    size_t MaxSize() const
    {
        return m_nSize;
    }

    bool Empty() const
    {
        return m_nUsed > 0;
    }

    void Clear()
    {
        Destroy();
    }

private:
    Element* m_pMap;
    size_t m_nSize;
    size_t m_nUsed;
    mutable Element* m_pNext;
    #ifdef MAPDBG
    mutable unsigned long m_nFinds;
    mutable unsigned long m_nCompares;
    #endif //MAPDBG

    void Destroy()
    {
        if (m_pMap == NULL)
            return;
        Element* const end = m_pMap + m_nUsed;
        Element* i = m_pMap;
        while (i != end)
            (i++)->~Pair<T, Key>();
        delete [] reinterpret_cast<char*>(m_pMap);
        m_pNext = m_pMap = NULL;
        m_nSize = 0;
        m_nUsed = 0;
    }

    Element* FindElement(const Key& key, bool bIncludeInStats = true) const
    {
        ASSERT(&key != NULL);
        #ifdef MAPDBG
        if (bIncludeInStats)
            ++m_nFinds;
        #endif //MAPDBG
        Element* const pNext = m_pNext;
        Element* const end = m_pMap + m_nUsed;
        ASSERT(pNext <= end);
        while (m_pNext != end)
        {
            if (m_pNext->GetSecond() == key)
            {
                #ifdef MAPDBG
                if (bIncludeInStats)
                    TotalStats(m_pNext - pNext);
                #endif //MAPDBG
                return m_pNext++;
            }
            ++m_pNext;
        }
        m_pNext = m_pMap;
        ASSERT(m_pNext != NULL || pNext == NULL);
        ASSERT(m_pNext <= pNext);
        while (m_pNext != pNext)
        {
            if (m_pNext->GetSecond() == key)
            {
                #ifdef MAPDBG
                if (bIncludeInStats)
                    TotalStats((m_pNext - m_pMap) + (end - pNext));
                #endif //MAPDBG
                return m_pNext++;
            }
            ++m_pNext;
        }
        #ifdef MAPDBG
        if (bIncludeInStats)
            TotalStats(m_nUsed);
        #endif //MAPDBG
        return NULL;
    }

    #ifdef MAPDBG
    void TotalStats(unsigned long nComparesPerformed) const
    {
        m_nCompares += nComparesPerformed;
        double average = double(m_nCompares) / double(m_nFinds);
        double const successRatio = nComparesPerformed == 0 ? 100.0 :
            (1.0 - (double(nComparesPerformed) / double(m_nUsed))) * 100.0;
        const size_t nOffset = m_pNext - m_pMap;
        TRACE("Map::find(%u), #%u, offset: %u, comps: %u, ave: %u, %%%u\n",
            (unsigned)(this), m_nFinds, nOffset, nComparesPerformed, (unsigned long)(average),
            (unsigned long)(successRatio));
    }
    #endif // MAPDBG

    static Element* UninitializedCopy(Element* dest, Element* src, size_t nCount)
    {
        if (nCount == 0)
            return dest;

        ASSERT(src != NULL || nCount == 0);
        ASSERT(dest != NULL);
        ASSERT(nCount > 0);
        if (nCount <= 0 || dest == NULL || src == NULL)
            return NULL;

        Element* const originalDest = dest;
        Element* const end = dest + nCount;
        while (dest != end)
            new(dest++) Element(*src++);
        return originalDest;
    }

    static void Copy(Element* dest, const Element* src, size_t nCount)
    {
        ASSERT(dest != NULL);
        ASSERT(src != NULL);
        ASSERT(static_cast<SSIZE_T>(nCount) >= 0);
        ASSERT(dest < src);
        if (nCount <= 0 || dest == NULL || src == NULL || dest >= src)
            return;

        Element* const end = dest + nCount;
        while (dest != end)
            *dest++ = *src++;
    }

}; // class Map