TnbSharedQueue.h

[詳解]

#pragma once
#include "TnbQueue.h"
#include "TnbSharedMemory.h"
#include "TnbSync.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP, size_t SIZ=10000>
class CSharedQueueT : public ICollectionMidT<TYP> , public IQueueT<TYP> , CCopyImpossible
{
    DEFSUPER(ICollectionMidT<TYP>);
 
    struct TInfo
    {
        size_t  bufferSize;     
        size_t  dataSize;       
        INDEX   readIndex;      
        INDEX   addIndex;       
        TYP     atData[SIZ];    
    };
 
    CSharedStructT<TInfo>   m_ssInfo;       
    CSyncMutex *            m_psyncData;    
 
    class CSmOpenListener : public CSharedStructT<TInfo>::IListener
    {
    public:
        virtual void OnAction(TInfo* P)
        {
            P->bufferSize   = SIZ;
            P->dataSize = 0;
            P->readIndex        = 0;
            P->addIndex     = 0;
        }
    };
 
protected:
 
    virtual const TYP* m_GetConstPointer(INDEX index) const
    {
        if ( m_psyncData == NULL ){ return NULL; }
        if ( ! IsInRange(index) ){ return NULL; }
        INDEX tmp = (m_ssInfo->readIndex) + index;
        tmp %= (m_ssInfo->bufferSize);
        return &(m_ssInfo->atData[tmp]);
    }
 
    virtual TYP* m_GetPointer(INDEX index)
    {
        if ( m_psyncData == NULL ){ return NULL; }
        if ( ! IsInRange(index) ){ return NULL; }
        INDEX tmp = (m_ssInfo->readIndex) + index;
        tmp %= (m_ssInfo->bufferSize);
        return &(m_ssInfo->atData[tmp]);
    }
 
public:
 
    CSharedQueueT(bool boCanClose = true) : _super(), m_ssInfo(boCanClose)
    {
        m_psyncData = NULL;
    }
 
    virtual ~CSharedQueueT(void)
    {
        Close();
    }
 
    bool Open(LPCTSTR lpszName)
    {
        Close();
        CSmOpenListener l;
        if ( m_ssInfo.Open(lpszName,&l) )
        {
            m_psyncData = new CSyncMutex(false, CStr::Fmt(_T("%s_Sync"), lpszName));
            if ( m_psyncData == NULL )
            {
                m_ssInfo.Close();
            }
        }
        return m_psyncData != NULL;
    }
 
    void Close(void)
    {
        m_ssInfo.Close();
        if ( m_psyncData != NULL )
        {
            delete m_psyncData;
            m_psyncData = NULL;
        }
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const
    {
        if ( m_psyncData == NULL ){ return false; }
        return m_psyncData->Lock();
    }
 
    virtual void Unlock(void) const
    {
        if ( m_psyncData == NULL ){ return; }
        m_psyncData->Unlock();
    }
 
    virtual size_t GetSize(void) const 
    {
        if ( m_psyncData == NULL ){ return 0; }
        return m_ssInfo->dataSize;
    }
 
    virtual INDEX Add(const TYP& t)
    {
        size_t r = GetSize();
        return (AddElements(1, &t) == 1) ? r : INVALID_INDEX;
    }
 
    virtual bool RemoveAll(void)
    {
        if ( m_psyncData == NULL ){ return true; }
        return TakeElements(m_ssInfo->dataSize) != INVALID_SIZE;
    }
 
    virtual size_t AddElements(size_t size, const TYP* P = NULL)
    {
        if ( m_psyncData == NULL )
        {
            return INVALID_SIZE; 
        }
        EXCLUSIVE(m_psyncData);
        if ( (m_ssInfo->dataSize) + size > (m_ssInfo->bufferSize) )
        {
            return INVALID_SIZE;    //それ以上になるならエラー
        }
        size_t bs   = m_ssInfo->bufferSize;
        INDEX tmp   = m_ssInfo->addIndex;
        if ( P != NULL )
        {
            loop ( i, size )
            {
                m_ssInfo->atData[tmp++] = *P++;
                if ( tmp >= bs )
                {
                    tmp -= bs;
                }
            }
        }
        else
        {
            loop ( i, size )
            {
                m_ssInfo->atData[tmp++] = TYP();
                if ( tmp >= bs )
                {
                    tmp -= bs;
                }
            }
        }
        (m_ssInfo->addIndex) += size;
        (m_ssInfo->addIndex) %= bs;
        (m_ssInfo->dataSize) += size;
        return size;
    }
 
    virtual size_t TakeElements(size_t size, TYP* P = NULL)
    {
        if ( m_psyncData == NULL )
        {
            return INVALID_SIZE;
        }
        EXCLUSIVE(m_psyncData);
        if ( (m_ssInfo->dataSize) < size )
        {
            return INVALID_SIZE;    //キューにその長さの情報がないのでエラー
        }
        size_t bs = m_ssInfo->bufferSize;
        if ( P != NULL )
        {
            INDEX tmp = m_ssInfo->readIndex;
            loop ( i, size )
            {
                *P++ = m_ssInfo->atData[tmp];
                if ( ++tmp >= bs )
                {
                    tmp -= bs;
                }
            }
        }
        (m_ssInfo->readIndex) += size;
        (m_ssInfo->readIndex) %= bs;
        (m_ssInfo->dataSize) -= size;
        return size;
    }
 
    size_t GetFreeSize(void) const
    {
        if ( m_psyncData == NULL )
        {
            return 0;
        }
        return (m_ssInfo->bufferSize) - (m_ssInfo->dataSize);
    }
 
private:
    friend class CSharedQueueTest;
};
 
 
 
}; // TNB