indexedfilewriter.h

Go to the documentation of this file.

#pragma once
 
namespace A_UTILS_NS
{
 
//*************************************************************************************************
class cIndexedFileWriter;
 
//*************************************************************************************************
class cIndexedFileAsyncWriter : public cThreadLoop
{
    A_UTILS_D(cIndexedFileAsyncWriter)
 
    protected:
        cIndexedFileWriter*       m_pInstance;
 
    public:
        cIndexedFileAsyncWriter();

        tResult Create(cIndexedFileWriter* pInstance);
 
    protected:
        tResult LoopFunc();
 
};
 
//*************************************************************************************************

class cIndexedFileWriter : public cIndexedFile
{
    A_UTILS_D(cIndexedFileWriter)
 
    public:
        class IChunkDroppedCallback
        {
            public:
                  virtual tResult OnChunkDropped(tUInt64 nIndex,
                                                 tUInt16 nStreamId,
                                                 tUInt16 nFlags,
                                                 tTimeStamp tmTime) = 0;
        };
 
    protected:
        tBool                   m_bIsOpen;
        tBool                   m_bCatchFirstTime;
        tTimeStamp              m_tmTimeOffset;
 
        tInt                    m_nCacheMinStoreAtOnce;
        volatile tInt           m_nCacheFlushPtr;
        volatile tInt           m_nCacheInsertPtr;
        std::atomic<tSize>      m_nCacheUsageCount;
 
        cIndexedFileAsyncWriter m_oWriterThread;
        std::mutex              m_mutexFreedEvent;
        std::mutex              m_mutexCacheUsed;
        std::condition_variable m_CondFreedEvent;
        std::condition_variable m_CondCacheUsed;
        std::atomic<tBool>      m_bCondCacheUsedProcessed;
 
        tInt64                  m_nRefIndex;
        tTimeStamp              m_nLastChunkTime;
 
        tBool                   m_bSyncMode;
 
        cIndexWriteTable        m_oIndexTable;
        volatile tInt32         m_nLastWriteResult;
 
        typedef struct tagStreamInfoAdd
        {
            tUInt8* pData;
            tInt    nIsReference;
        } tStreamInfoAdd;
 
        tStreamInfoHeader       m_asStreamInfo[MAX_INDEXED_STREAMS];
        tStreamInfoAdd          m_asStreamInfoAdd[MAX_INDEXED_STREAMS];
 
        tFilePos                m_nFilePosLastChunk;
 
        cFilename               m_strFileName;
        cFilename               m_strTempFileName;
 
        cFilename               m_strPrefixOfTempSaveFileName;
 
        /*
        * if true the tempfilename (savemode) used an prefix
        */
        tBool                   m_bUsePrefixTempFileExtension;
 
    public:
        cFilename               GetTempSaveFileName();
        tVoid                   SetPrefixTempFileExtension(tBool useMode);

        tBool                   GetPrefixTempFileExtensionMode();

        cString                   GetPrefix();

        cString GetNewFileNameWithPrefix(cString strFilename);
     private:
        tResult CreateAFileWithPrefixdAndAFileWithoutPrefix(cFilename strFilename,
                                                            cFilename &strSaveFilename);
    
        tResult                 RenameTempSaveToFileName();
 
    public:
        A_UTILS_DEPRECATED_MESSAGE("The class 'cIndexedFileWriter' is deprecated. Please use the aquivalent from the "
                                   "adtf_file library instead.")
        cIndexedFileWriter();
        ~cIndexedFileWriter();

        tResult Create(const tChar* strFilename,
                       tInt nCacheSize=-1,
                       tUInt32 ui32Flags=0,
                       tUInt64 ui64FileTimeOffset=0,
                       tTimeStamp tmHistory = 0,
                       tFileSize nHistorySize = 0,
                       IChunkDroppedCallback* pDropCallback = nullptr);

        tResult Close();

        tResult WriteChunk(tUInt16 ui16StreamId,
                           const tVoid* pData,
                           tUInt32 nDataSize,
                           tTimeStamp nTimeStamp,
                           tUInt32 nFlags);
        tResult WriteChunk(tUInt16 ui16StreamId,
                           const tVoid* pData,
                           tUInt32 nDataSize,
                           tTimeStamp nTimeStamp,
                           tUInt32 nFlags,
                           tBool& bIndexEntryAppended);

        tResult SetAdditionalStreamInfo(tUInt16 ui16StreamId,
                                        const tVoid*  pInfoData,
                                        tUInt32 ui32InfoDataSize,
                                        tBool   bUseAsReference=tFalse);
        tResult SetStreamName(tUInt16 ui16StreamId,
                              const tChar* strStreamName);

        tInt GetCacheUsage();

        tResult QuitHistory();
 
    protected:
        tResult Initialize();

        tResult WriteFileHeader();

        tResult WriteFileHeaderExt();

        tResult WriteIndexTable();
 
    protected:
        tResult WriteToCache(const tVoid* pData, tInt nDataSize, const tBool bIsChunkHeader = tFalse);

        tResult StoreToDisk(bool bFlush);

        tVoid UpdateCache();

        tResult AllocCache(tInt nSize);

        tInt64 InternalWrite(const tVoid* pvBuffer,
                             tInt nBufferSize,
                             tBool bUseSegmentSize);
 
    friend class cIndexedFileAsyncWriter;
};
 
} // namespace