TnbSimpleQueue.h

[詳解]

#pragma once
#include "TnbDef.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP, bool ISI = false, class INV = TYP>
class CSimpleQueueT : CCopyImpossible
{
public:
 
    explicit CSimpleQueueT(size_t size = 10000) : m_bufferSize(size), m_pBuffer(new TYP[size]), m_dataSize(0), m_readIndex(0)
    {
        ASSERT( size != 0 );
    }
    
    virtual ~CSimpleQueueT(void)
    {
        delete[] m_pBuffer;
    }
 
    void SetQueueSize(size_t size)
    {
        ASSERT( size != 0 );
        delete[] m_pBuffer;
        m_bufferSize = size;
        m_pBuffer = new TYP[size];
        m_dataSize = 0;
        m_readIndex = 0;
    }
 
    size_t GetQueueSize(void) const
    {
        return m_bufferSize;
    }
 
    size_t GetSize(void) const 
    {
        return m_dataSize;
    }
 
    bool IsFull(void) const
    {
        if ( GetQueueSize() <= GetSize() )
        {
            return true;
        }
        return false;
    }
 
    INDEX Add(const TYP& t)
    {
        size_t r = GetSize();
        return (AddElements(1, &t) == 1) ? r : INVALID_INDEX;
    }
 
    bool RemoveAll(void)
    {
        SetQueueSize(m_bufferSize);
        return true;
    }
 
    size_t AddElements(size_t size, const TYP* P = NULL)
    {
        if ( (m_dataSize) + size > (m_bufferSize) )
        {
            //それ以上になるならエラー
            return INVALID_SIZE;
        }
        size_t bs = m_bufferSize;
        INDEX tmp = (m_readIndex + m_dataSize) % bs;
        if ( P != NULL )
        {
            loop ( i, size )
            {
                m_pBuffer[tmp++] = *P++;
                if ( tmp >= bs )
                {
                    tmp -= bs;
                }
            }
        }
        else
        {
            loop ( i, size )
            {
                m_pBuffer[tmp++] = TYP();
                if ( tmp >= bs )
                {
                    tmp -= bs;
                }
            }
        }
        m_dataSize += size;
        return size;
    }
 
    TYP Take(void)
    {
        TYP t;
        if ( TakeElements(1, &t) == 1 )
        {
            return t;
        }
        ASSERT0( false, "CSimpleQueueT::Take()", "キューが空の時取得操作されました。" );
        throw CEmptyException();
    }
 
    size_t TakeElements(size_t size, TYP* P = NULL)
    {
        if ( m_dataSize < size )
        {
            //キューにその長さの情報がないのでエラー
            return INVALID_SIZE;
        }
        size_t bs = m_bufferSize;
        if ( P != NULL || ISI )
        {
            INDEX tmp = m_readIndex;
            loop ( i, size )
            {
                if ( P != NULL )
                {
                    *P++ = m_pBuffer[tmp];
                }
                if ( ISI )
                {
                    m_pBuffer[tmp] = INV();
                }
                if ( ++tmp >= bs )
                {
                    tmp -= bs;
                }
            }
        }
        m_readIndex += size;
        m_readIndex %= bs;
        m_dataSize -= size;
        return size;
    }
 
    const TYP& Ref(INDEX index) const
    {
        if ( GetSize() > index )
        {
            INDEX tmp = m_readIndex + index;
            tmp %= m_bufferSize;
            return m_pBuffer[tmp];
        }
        throw CIndexOutOfBoundsException();
    }
 
    TYP& Ref(INDEX index)
    {
        if ( GetSize() > index )
        {
            INDEX tmp = m_readIndex + index;
            tmp %= m_bufferSize;
            return m_pBuffer[tmp];
        }
        throw CIndexOutOfBoundsException();
    }
 
    size_t GetFreeSize(void) const
    {
        return (m_bufferSize) - (m_dataSize);
    }
 
private:
 
    size_t          m_bufferSize;       
    size_t          m_dataSize;     
    INDEX           m_readIndex;        
    TYP*            m_pBuffer;      
};
 
 
 
}; // TNB