indexreadtable.h

Go to the documentation of this file.

 
#ifndef _INDEX_READ_TABLE_CLASS_HEADER_
#define _INDEX_READ_TABLE_CLASS_HEADER_
 
 
 
namespace A_UTILS_NS
{
 
class DOEXPORT cIndexReadTable
{
    A_UTILS_D(cIndexReadTable)
 
    private:
        struct tIndexTable
        {
            tIndexTable():nIndexTableOffset(0), nIndexCount(0), tmLastIndex(0), nIndexOffset(0) {}
 
            tUInt64 nIndexTableOffset;
            tUInt64 nIndexCount;
            //the timestamp of the last index entry
            tTimeStamp tmLastIndex;
            //the chunk position of the last index entry
            tUInt64 nIndexOffset;
        };
 
        struct tMasterIndexTable: public tIndexTable
        {
            tMasterIndexTable() :
                pMasterChunkRefTable(nullptr)
            {}
 
            IIndexedFile::tChunkRef *pMasterChunkRefTable;
        };
 
        struct tStreamIndexTable: public tIndexTable
        {
            tStreamIndexTable() :
                pStreamInfoHeader(nullptr),
                pStreamRefTable(nullptr),
                pAdditionalStreamInfo(nullptr)
            {}
 
            IIndexedFile::tStreamInfoHeader* pStreamInfoHeader;
            IIndexedFile::tStreamRef* pStreamRefTable;
            tVoid* pAdditionalStreamInfo;
        };
 
        typedef std::vector<tStreamIndexTable> tStreamIndexTableVector;
 
        // master table
        tMasterIndexTable           m_oMasterIndexTable;
 
        // stream tables
        tStreamIndexTable  m_aStreamIndexTables[MAX_INDEXED_STREAMS + 1];
 
        // pointer to indexed source file
        cIndexedFile                *m_pIndexedFile;
        IIndexedFile::tFileHeader   *m_pFileHeader;
 
    public:
 
        tResult Create(cIndexedFile *pIndexedFile);
 
        tResult ReadIndexTable();
 
        tResult Free();
 
        const tChar* GetStreamName(tUInt16 ui16StreamId);
 
        const IIndexedFile::tStreamInfoHeader* GetStreamInfo(tUInt16 ui16StreamId);
 
 
        tTimeStamp GetFirstTime(tUInt16 ui16StreamId);
 
        tTimeStamp GetLastTime(tUInt16 ui16StreamId);
 
        const void* GetAdditionalStreamInfo(tUInt16 ui16StreamId);
 
        tInt64 GetItemCount(tUInt16 ui16StreamId);        
 
        tResult AdjustChunkHeader(IIndexedFile::tChunkHeader* pHeader);
 
        tResult FillChunkHeaderFromIndex(tUInt32 ui32MasterIdx, IIndexedFile::tChunkHeader* pHeader,
                                         tInt64* pChunkIndex, tInt64* pChunkOffset);
 
        tInt32 LookupChunkRef(tUInt16 ui16StreamId, tInt64 nPos,
                               tInt nTimeFormat, tInt64 *pChunkIndex,
                               tInt64* pChunkOffset, tInt64* pEndChunkIndex,
                               tInt64* pMasterIndex);
 
        tResult FindNearestEntryWithFlags(tUInt16 ui16StreamId, tUInt64 nChunkIndex,
                                          tUInt16 nChunkFlags, tInt64* pMasterIndex);
 
        tResult ValidateRawMasterIndex(tUInt32 ui32RefMasterTableIndex);
 
    private:
 
 
        tResult SetIndexOffsetInfos(tUInt16 ui16StreamId,
            IIndexedFile::tAdditionalIndexInfo& rAdditionalIndexInfo);
 
        tResult AddStreamIndexTableEntry(tUInt16 ui16StreamId, IIndexedFile::tStreamRef* pStreamRef,
                                         IIndexedFile::tStreamInfoHeader* pStreamInfo,
                                         tVoid *pAdditionalStreamInfo,
                                         tUInt64 uiCount);
 
        tResult AddMasterIndexTableEntry(void* pRefTbl, tUInt64 uiCount);
 
        tResult GetStreamRef(tUInt16 ui16StreamId, tUInt32 ui32StreamIdx,
                             IIndexedFile::tStreamRef *pStreamRef);
};
 
} // namespace
#endif // _INDEX_READ_TABLE_CLASS_HEADER_