fileringbuffer.h

Go to the documentation of this file.

 
#ifndef _DISK_RING_BUFFER_H
#define _DISK_RING_BUFFER_H
 
namespace A_UTILS_NS
{
 
template <typename ADDITIONAL_DATA = tUInt8, tUInt8 ALIGNMENT = 1>
class cFileRingBuffer
{
    public:
        struct tItem
        {
            tItem(): nFilePos(-1), nSize(0) {}
            tFilePos nFilePos; 
            tSize nSize; 
            ADDITIONAL_DATA xAdditional; 
        };
 
        class IDropCallback
        {
            public:
                virtual tResult OnDrop(const tItem& sDroppedItem, const tItem& sNextItem) = 0;
        };
 
        struct tItemPiece
        {
            const tVoid* pData; 
            tSize nDataSize; 
        };
 
        typedef std::deque<tItem> tItems;
        typedef typename tItems::const_iterator const_iterator;
 
    private:
        tItems m_oItems;
        cFile* m_pFile;
        tFilePos m_nStartOffset;
        tFilePos m_nCurrentPos;
        tFileSize m_nCurrentSize;
        tFileSize m_nMaxSize;
        tBool m_bBookkeeping;
        IDropCallback* m_pCallback;
        cMemoryBlock m_oAlignmentBuffer;
        tItem m_sRearItem;
 
    public:
        cFileRingBuffer(cFile* pFile, tFilePos nStartOffset = 0,
                        tFileSize nMaxSize = 0, IDropCallback* pDropCallback = nullptr):
            m_pFile(pFile),
            m_nStartOffset(nStartOffset),
            m_nCurrentSize(0),
            m_nMaxSize(nMaxSize),
            m_bBookkeeping(tTrue),
            m_pCallback(pDropCallback)
        {
            pFile->SetFilePos(nStartOffset, cFile::FP_Begin);
            m_nCurrentPos = nStartOffset;
 
            if (ALIGNMENT > 1)
            {
                m_oAlignmentBuffer.Alloc(ALIGNMENT - 1);
                cMemoryBlock::MemZero(m_oAlignmentBuffer.GetPtr(), m_oAlignmentBuffer.GetSize());
            }
 
            FillForAlignment();
        }
 
        const tFileSize& GetCurrentSize()
        {
            return m_nCurrentSize;
        }
 
        tResult StartWrappingAround()
        {
            if (!m_bBookkeeping)
            {
                RETURN_ERROR(ERR_INVALID_STATE);
            }
 
            m_nMaxSize = m_nCurrentSize;
            RETURN_NOERROR;
        }
 
        tResult StartAppending(tItem* pRearDataItem = NULL, tItem* pLastDataItem = NULL)
        {
            if (!m_bBookkeeping)
            {
                RETURN_ERROR(ERR_INVALID_STATE);
            }
 
            m_nMaxSize = 0;
            m_pFile->SetFilePos(0, cFile::FP_End);
            m_nCurrentPos = m_pFile->GetFilePos();
            m_bBookkeeping = tFalse;
 
            if (m_sRearItem.nFilePos == -1 && !m_oItems.empty())
            {
                // we never wrapped around.
                m_sRearItem = m_oItems.back();
            }
 
            if (pRearDataItem)
            {
                *pRearDataItem = m_sRearItem;
            }
 
            if (pLastDataItem)
            {
                if (!m_oItems.empty())
                {
                    *pLastDataItem = m_oItems.back();
                }
                else
                {
                    *pLastDataItem = tItem();
                }
            }
 
            RETURN_NOERROR;
        }
 
        tResult AppendItem(const tVoid* pData, tSize nDataSize,
                           const ADDITIONAL_DATA& xAdditional, tFilePos* pFilePos = nullptr)
        {
            tItemPiece sItem;
            sItem.pData = pData;
            sItem.nDataSize = nDataSize;
            return AppendItem(&sItem, 1, xAdditional, pFilePos);
        }
 
        tResult AppendItem(const tItemPiece* pPieces, tSize nCount,
                           const ADDITIONAL_DATA& xAdditional, tFilePos* pFilePos = nullptr)
        {
            tSize nDataSize = 0;
            for (tSize nPiece = 0; nPiece < nCount; ++nPiece)
            {
                nDataSize += pPieces[nPiece].nDataSize;
            }
 
            if (m_nMaxSize && !m_oItems.empty())
            {
                if (m_nCurrentPos + nDataSize > m_nMaxSize)
                {
                    // in this case we need to wrap around
                    RETURN_IF_FAILED(m_pFile->Truncate(m_nCurrentPos));
                    m_nCurrentSize = m_nCurrentPos;
 
                    m_sRearItem = m_oItems.back();
 
                    //we need remove all items following this postion
                    while (m_oItems.front().nFilePos >= m_nCurrentPos)
                    {
                        RETURN_IF_FAILED(PopFront());
                    }
 
                    m_nCurrentPos = m_oItems.front().nFilePos; // this should be equal to the data offset
                    if (m_pFile->SetFilePos(m_nCurrentPos, cFile::FP_Begin) == -1)
                    {
                        RETURN_ERROR(ERR_UNEXPECTED);
                    }
                }
            }
 
            if (pFilePos)
            {
                *pFilePos = m_nCurrentPos;
            }
 
            tFilePos nWritePos = m_nCurrentPos;
 
            for (tSize nPiece = 0; nPiece < nCount; ++nPiece)
            {
                RETURN_IF_FAILED(m_pFile->WriteAll(pPieces[nPiece].pData, static_cast<tInt>(pPieces[nPiece].nDataSize)));
            }
 
            m_nCurrentPos += nDataSize;
 
            RETURN_IF_FAILED(FillForAlignment());
 
            if (m_nCurrentPos > m_nCurrentSize)
            {
                m_nCurrentSize = m_nCurrentPos;
            }
 
            if (m_bBookkeeping)
            {
                tItem sItem;
                sItem.nFilePos = nWritePos;
                sItem.nSize = nDataSize;
                sItem.xAdditional = xAdditional;
 
                m_oItems.push_back(sItem);
 
                tFilePos nStart = sItem.nFilePos;
                tFilePos nEnd = m_nCurrentPos;
 
                while (m_oItems.size() > 1 &&
                       m_oItems.front().nFilePos >= nStart &&
                       m_oItems.front().nFilePos < nEnd)
                {                    
                    RETURN_IF_FAILED(PopFront());
                }
 
                if (m_sRearItem.nFilePos != -1)
                {
                    // we did wrap around at least once
                    // check if this item did overwrite the current rear item
                    if (m_sRearItem.nFilePos < nEnd)
                    {
                        // it has been overwritten by the current one
                        // and was alread removed from the queue in the while loop above
                        // so the current item is the new rear item.
                        m_sRearItem = m_oItems.back();
                        // make sure that the file ends after the current item
                        RETURN_IF_FAILED(m_pFile->Truncate(m_nCurrentPos));
                        m_nCurrentSize = m_nCurrentPos;
                    }
                }
            }
 
            RETURN_NOERROR;
        }
 
        const_iterator begin() const
        {
            return m_oItems.begin();
        }
 
        const_iterator end() const
        {
            return m_oItems.end();
        }
 
    protected:
        tResult FillForAlignment()
        {
            tFilePos nMod = m_nCurrentPos % ALIGNMENT;
            if (nMod)
            {
                tFilePos nFill = ALIGNMENT - nMod;
                RETURN_IF_FAILED(m_pFile->WriteAll(m_oAlignmentBuffer.GetPtr(), 
                                                   static_cast<tInt>(nFill)));
                m_nCurrentPos += nFill;
            }
 
            RETURN_NOERROR;
        }
 
        tResult PopFront()
        {
            if (m_pCallback)
            {
                static tItem s_sDummy;
 
                tItem& sItem = m_oItems.front();
                tItem* pNext = &s_sDummy;
                if (m_oItems.size() > 1)
                {
                    pNext = &m_oItems[1];
                }
                RETURN_IF_FAILED(m_pCallback->OnDrop(sItem, *pNext));
            }
            m_oItems.pop_front();
            RETURN_NOERROR;
        }
};
 
}
 
#endif