indexreadtable_v201_v301.h

Go to the documentation of this file.

 
#ifndef INDEX_READ_TABLE_V201_V301_CLASS_HEADER
#define INDEX_READ_TABLE_V201_V301_CLASS_HEADER
 
#include <ifhd/v201_v301/indexedfile_types_v201_v301.h>
#include <ifhd/v201_v301/indexedfile_v201_v301.h>
 
namespace ifhd
{
namespace v201_v301
{

class IndexReadTable
{
    private:
        struct IndexTable
        {
            IndexTable():index_table_offset(0), index_count(0), last_index(0), index_offset(0) {}
 
            uint64_t index_table_offset;
            uint64_t index_count;
            //the timestamp of the last index entry
            timestamp_t last_index;
            //the chunk position of the last index entry
            uint64_t index_offset;
        };
 
        struct MasterIndexTable: public IndexTable
        {
            MasterIndexTable() :
                master_chunk_ref_table(nullptr)
            {}
 
            ChunkRef *master_chunk_ref_table;
        };
 
        struct StreamIndexTable: public IndexTable
        {
            StreamIndexTable() :
                stream_info_header(nullptr),
                stream_ref_table(nullptr),
                additional_stream_info(nullptr)
            {}
 
            StreamInfoHeader* stream_info_header;
            StreamRef* stream_ref_table;
            void* additional_stream_info;
        };
 
        typedef std::vector<StreamIndexTable> StreamIndexTableVector;
 
        // master table
        MasterIndexTable           _master_index_table;
 
        // stream tables
        StreamIndexTable  _stream_index_tables[max_indexed_streams + 1];
 
        // pointer to indexed source file
        IndexedFile*      _indexed_file;
        FileHeader*       _file_header;
 
    public:

        void create(IndexedFile *indexed_file);

        void readIndexTable();

        void free();

        std::string getStreamName(uint16_t stream_id) const;

        bool streamExists(uint16_t stream_id) const;

        const StreamInfoHeader* getStreamInfo(uint16_t stream_id) const;
 

        timestamp_t getFirstTime(uint16_t stream_id) const;

        timestamp_t getLastTime(uint16_t stream_id) const;

        const void* getAdditionalStreamInfo(uint16_t stream_id) const;

        int64_t getItemCount(uint16_t stream_id) const;

        void adjustChunkHeader(ChunkHeader* header);

        void fillChunkHeaderFromIndex(uint32_t master_idx, ChunkHeader* header,
                                      int64_t* chunk_index,
                                      int64_t* chunk_offset);

        void validatePosition(uint16_t stream_id, int64_t pos, TimeFormat time_format) const;

        void lookupChunkRef(uint16_t stream_id, int64_t pos,
                               TimeFormat time_format, int64_t *chunk_index,
                               int64_t* chunk_offset, int64_t* end_chunk_index,
                               int64_t* master_index) const;

        bool findNearestEntryWithFlags(uint16_t stream_id, uint64_t chunk_index,
                                       uint16_t chunk_flags, uint64_t* master_index);

        bool validateRawMasterIndex(int32_t ref_master_table_index);
 
    private:
 

        void setIndexOffsetInfos(uint16_t stream_id,
            AdditionalIndexInfo& additional_index_info);

        void addStreamIndexTableEntry(uint16_t stream_id, StreamRef* stream_ref,
                                         StreamInfoHeader* stream_info,
                                         void* additional_stream_info,
                                         uint64_t count);

        void addMasterIndexTableEntry(void* ref_tbl, uint64_t count);

        void getStreamRef(uint16_t stream_id, uint32_t stream_idx,
                             StreamRef *stream_ref) const;
};
 
} //namespace
} // namespace
#endif // _INDEX_READ_TABLE_V201_V301_CLASS_HEADER_