IndexSetForQueryingStage.h

Go to the documentation of this file.

#ifndef IndexSetForQueryingStage_h
#define IndexSetForQueryingStage_h


#include "../common/bserialize.h"
// Flags for CIndexItem::m_IndexItemOffsetAndFlags

const DWORD TheOnlyOccurIsInEndOccurNo = 1<<31;
const DWORD EndOfSentenceForBigrams = 1<<30;
const DWORD AllFlags = TheOnlyOccurIsInEndOccurNo  | EndOfSentenceForBigrams;

class CIndexItem 
{
        // pointer to CStringIndexSet::m_StringBuffer and flags;
        DWORD                           m_IndexItemOffsetAndFlags;

        // upper bound offset of occurrences in CIndexSetForQueryingStage::m_OccursFp
        DWORD                           m_EndOccurOffset;

public:
        DWORD   GetIndexItemOffsetAndFlags() const
        {
                return m_IndexItemOffsetAndFlags;
        };
        void    SetIndexItemOffsetAndFlags(DWORD Value) 
        {
                m_IndexItemOffsetAndFlags = Value;
        };

        static size_t GetMaximalNumberOfRunningTokens()
        {
                return ~0 & ~AllFlags; 
        };

        DWORD   GetIndexItemOffset() const
        {
                return m_IndexItemOffsetAndFlags & ~AllFlags;
        };
        
        void    SetIndexItemOffset(DWORD Value) 
        {
        m_IndexItemOffsetAndFlags &= AllFlags;
                m_IndexItemOffsetAndFlags |= Value & ~AllFlags;
        };
        DWORD   GetItemIndexFlags() const
        {
                return m_IndexItemOffsetAndFlags & AllFlags;
        };
        void    AddItemIndexFlags(DWORD Value) 
        {
                m_IndexItemOffsetAndFlags |= Value & AllFlags;
        };
        DWORD GetEndOccurOffset() const 
        {
                return m_EndOccurOffset;
        };
        void SetEndOccurOffset(DWORD EndOccurOffset)  
        {
                m_EndOccurOffset = EndOccurOffset;
        };
    bool HasOneOccurrence () const 
    {
        return (m_IndexItemOffsetAndFlags & TheOnlyOccurIsInEndOccurNo) != 0;
    }
};

inline size_t get_size_in_bytes (const CIndexItem& t)
{
        return 8;
};

inline size_t save_to_bytes(const CIndexItem& i, BYTE* buf)
{
        buf += save_to_bytes(i.GetIndexItemOffsetAndFlags(), buf);
        buf += save_to_bytes(i.GetEndOccurOffset(), buf);
        return get_size_in_bytes(i);
}

inline size_t restore_from_bytes(CIndexItem& i, const BYTE* buf)
{
        DWORD d;

        buf += restore_from_bytes(d, buf);
        i.SetIndexItemOffsetAndFlags(d);

        buf += restore_from_bytes(d, buf);
        i.SetEndOccurOffset(d);

        return get_size_in_bytes(i);
}


class CStringIndexator; 
class CItemIndexForLoading;

class CIndexSetForQueryingStage 
{
        FILE*                   m_OccursFp;
        
        
        void    CloseOccursFile();
        bool    LoadPeriodDevision();
        

protected:

        void    AssertHasPath() const;
        void    AddOccurs (size_t IndexItemNo, const bool bOneOccurrence, const size_t StartOccurNo, const size_t EndOccurNo, vector<CTokenNo>& Occurs, size_t PeriodNo, COccurrBuffer& OccursBuffer, CShortOccurCache* pCacheByIndexSet, int& CacheId) const;
        string  GetOccursFileName() const;
        string  GetOccHdrFileName() const;
        
        
        string  GetPeriodsDevisionFileName () const;
        string  GetFileNameForInfos() const;
        file_off_t      GetOccurrsFileSize() const;
        size_t  GetStartOccurNo(size_t IndexNo) const;
        bool    BuildPeriodsDivisionAndCompress (const DWORD TokenId, vector<CTokenNo>& InputTokens);
        bool    AddOneIndexItem (CItemIndexForLoading& M, FILE* res_fp, size_t& CurrPositionInResFile, const CTokenNo EndTokeNo);
        bool    WritePeriodsDivision ();


public:
        vector<CIndexItem>                              m_Index;

        PeriodsDivisionMap                      m_EndPeriodOffsets;

        const CStringIndexator*         m_pParent;

        bool                                            m_bCompressOccurrences;


        CIndexSetForQueryingStage(const CStringIndexator*               pParent);
        ~CIndexSetForQueryingStage();
        virtual string GetName() const = 0;
        bool    LoadIndexSet(bool bLoadHeaderOfOccurrences = true);
        bool    DestroyIndexSet ();
        void ReadAllOccurrences (size_t IndexItemNo, vector<CTokenNo>& Occurs) const;
    
};



#endif