TnbPriorityQueue.h

[詳解]

#pragma once
#include "TnbListQueue.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP>
class CPriorityQueueT : public ICollectionMidT<TYP>, public IQueueT<TYP>, CCopyImpossible
{
    DEFSUPER(ICollectionMidT<TYP>);
    CListT<CListQueueT<TYP> >   m_listQueue;    
    int                         m_iLevelMax;    
 
    INDEX m_LevelToIndex(int iLevel)
    {
        if ( m_iLevelMax < iLevel )
        {
            return INVALID_INDEX;
        }
        iLevel += m_iLevelMax;
        if ( iLevel < 0 )
        {
            return INVALID_INDEX;
        }
        return iLevel;
    }
 
protected:
 
    virtual const TYP* m_GetConstPointer(INDEX index) const
    {
        if ( index >= 0 )
        {
            try
            {
                for ( INDEX i = m_listQueue.GetSize() - 1; i >= 0; i-- )
                {
                    size_t size = m_listQueue[i].GetSize();
                    if ( size > index )
                    {
                        return &(m_listQueue[i][index]);    //範囲内のはず
                    }
                    index -= size;
                }
            }
            catch(CTnbException& e)
            {
                e.OnCatch();
            }
        }
        return NULL;
    }
 
    virtual TYP* m_GetPointer(INDEX index)
    {
        if ( index >= 0 )
        {
            try
            {
                for ( INDEX i = m_listQueue.GetSize() - 1; i >= 0; i-- )
                {
                    size_t size = m_listQueue[i].GetSize();
                    if ( size > index )
                    {
                        return &(m_listQueue[i][index]);    //範囲内のはず
                    }
                    index -= size;
                }
            }
            catch(CTnbException& e)
            {
                e.OnCatch();
            }
        }
        return NULL;
    }
 
public:
 
    explicit CPriorityQueueT(int iLevel = 3) : _super()
    {
        if ( iLevel < 0 )
        {
            iLevel = -iLevel;
        }
        m_iLevelMax = iLevel;
        CListQueueT<TYP> q;
        loop ( i, iLevel * 2 + 1 )
        {
            m_listQueue.Add(q);
        }
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const
    {
        return m_listQueue.Lock();
    }
 
    virtual void Unlock(void) const
    {
        m_listQueue.Unlock();
    }
 
    virtual size_t GetSize(void) const 
    {
        EXCLUSIVE(this);
        size_t size = 0;
        for ( INDEX i = m_listQueue.GetSize() - 1; i >= 0; i-- )
        {
            size += m_listQueue[i].GetSize();
        }
        return size;
    }
 
 
    virtual INDEX Add(const TYP& t)
    {
        return Add(0, t);
    }
 
    virtual size_t AddElements(size_t size, const TYP* P = NULL)
    {
        return AddElements(0, size, P);
    }
 
    virtual bool RemoveAll(void)
    {
        return m_listQueue.RemoveAll();
    }
    
    size_t GetSize(int iLevel) const 
    {
        EXCLUSIVE(this);
        INDEX index = m_LevelToIndex(iLevel);
        if ( index != INVALID_INDEX )
        {
            return m_listQueue[index].GetSize();
        }
        return INVALID_SIZE;
    }
 
    size_t AddElements(int iLevel, size_t size, const TYP* P = NULL)
    {
        EXCLUSIVE(this);
        if ( P != NULL )
        {
            loop ( i, size )
            {
                Add(iLevel, *P++);
            }
        }
        else
        {
            loop ( i, size )
            {
                Add(iLevel, TYP());
            }
        }
        return size;
    }
 
    INDEX Add(int iLevel, const TYP& t)
    {
        INDEX index = m_LevelToIndex(iLevel);
        if ( index == INVALID_INDEX )
        {
            return INVALID_INDEX;
        }
        return m_listQueue[index].Add(t);
    }
 
    INDEX AddEx(int iLevel, const TYP& t)
    {
        EXCLUSIVE(this);
        return Add(iLevel, t);
    }
 
    size_t Append(int iLevel, const IConstCollectionT<TYP> &c)
    {
        EXCLUSIVE(this);
        INDEX index = m_LevelToIndex(iLevel);
        if ( index == INVALID_SIZE )
        {
            return INVALID_SIZE;
        }
        return m_listQueue[index].Append(c);
    }
 
    virtual TYP Take(void)
    {
        EXCLUSIVE(this);
        for ( INDEX i = m_listQueue.GetSize() - 1; i >= 0; i-- )
        {
            if ( ! m_listQueue[i].IsEmpty() )
            {
                TYP t = m_listQueue[i].Get(0);
                m_listQueue[i].Remove(0);
                return t;
            }
        }
        ASSERT0(false, "CPriorityQueueT::Take()", "キューが空の時取得操作されました。");
        throw CEmptyException();
    }
 
    TYP Take(int iLevel)
    {
        EXCLUSIVE(this);
        INDEX index = m_LevelToIndex(iLevel);
        if ( index != INVALID_INDEX )
        {
            if ( ! m_listQueue[index].IsEmpty() )
            {
                TYP t = m_listQueue[index].Get(0);
                m_listQueue[index].Remove(0);
                return t;
            }
        }
        ASSERT0(false, "CPriorityQueueT::Take()", "キューが空の時取得操作されました。");
        throw CEmptyException();
    }
 
    virtual size_t TakeElements(size_t size, TYP* P = NULL)
    {
        EXCLUSIVE(this);
        if ( size > GetSize() )
        {
            return INVALID_SIZE;
        }
        if ( P != NULL )
        {
            loop ( i, size )
            {
                *P++ = Take();
            }
        }
        else
        {
            loop ( i, size )
            {
                Take();
            }
        }
        return size;
    }
};
 
 
 
}; // TNB