QueryNode.h

Go to the documentation of this file.

//-*- Mode: C++; c-basic-offset: 8; -*-
// QNode.h: interface for the CQNode class.
//

#ifndef QUERY_NODE_H
#define QUERY_NODE_H

#include "../common/utilit.h"
#include "ConcHolder.h"
#include "../PCRE/pcre_rml.h"


class CQueryNode  
{
public:
        bool                            m_bAtomic;  

        bool                            m_bNegated;

        string                          m_Source;
        vector<CTokenNo>                m_Occurrences;

        bool                            m_bUseNodeIndices;
        vector<BYTE>                    m_OccurrenceNodeIndices;

        bool                            m_bUseTokenIdxs;
        vector<DWORD>                   m_OccurrenceTokenIdxs;

        vector<CHit>                    m_Hits;
        const CConcHolder*              m_pHolder;
        vector<size_t>                  m_ChunkLengths;
        vector<int>                     m_CacheIds;


        CQueryNode(bool bUseNodeIndices=false, bool bUseTokenIdxs=false, const CConcHolder *holder=NULL)
                : m_bAtomic(false),
                  m_bNegated(false),
                  m_bUseNodeIndices(bUseNodeIndices),
                  m_bUseTokenIdxs(bUseTokenIdxs),
                  m_pHolder(holder)
        {};
        virtual ~CQueryNode();

        virtual void    Evaluate();     
        virtual void    EvaluateWithoutHits();  

        void    SetNegation(bool Value);
        bool    GetNegation() const;
        void    AddOccurrences(const CQueryNode& FromNode, int start, int end);
        void    ClearAndReserveOccurrences(int size);
        void    SwapOccurrences(CQueryNode& Node);

        void    ConvertOccurrencesToHits (bool bUniqueHits);
        void    ConvertOccurrencesToHitsForPatterns (bool bUniqueHits);
        void    SetHolder(const CConcHolder*    pHolder);
        virtual size_t GetNodeFrequenceByNodeIndex(size_t NodeIndex) const;
};

class CQueryBinaryOperationNode : public CQueryNode 
{
        void hits_add(const CQueryNode& NodeFrom, vector<CHit>::const_iterator First);

protected:
        CQueryNode*     m_pChild1;  
        CQueryNode*     m_pChild2;  
public:
        CQueryBinaryOperationNode() : m_pChild1(NULL), m_pChild2(NULL) {};
        CQueryBinaryOperationNode(CQueryNode *dtr1, CQueryNode *dtr2)
                : CQueryNode(false,false), m_pChild1(dtr1), m_pChild2(dtr2)
        {};

        void Create(const CConcHolder*  pHolder, CQueryNode* child1, CQueryNode* child2, string Operation);
        virtual ~CQueryBinaryOperationNode();

        void hits_and_positions_union();
        void hits_and_positions_intersection();
        void hits_and_positions_difference();

        size_t GetNodeFrequenceByNodeIndex(size_t NodeIndex) const;
};

class CQueryAndOperation        : public CQueryBinaryOperationNode  
{
public:
        CQueryAndOperation();
        void Evaluate();
};

class CQueryOrOperation : public CQueryBinaryOperationNode 
{
public:
        CQueryOrOperation();
        void Evaluate( );
};

class CQueryTokenNode : public CQueryNode
{
        vector<DWORD>           m_IndexItems;
        // the name  of index, on which this node is built (see  CQueryChunkNode and  CQueryTokenNode nodes)
        string                          m_IndexName;
        // true, if it is a chunk (NP, VP and so on)
        bool                            m_bChunk;


        bool BuildRegExp(string RegExpStr, vector<DWORD>& IndexItems);
public:
        // a unique index of the node in query tree
        BYTE                            m_NodeIndex;
        
        CQueryTokenNode(int NodeIndex);
        virtual ~CQueryTokenNode();

        bool    CreateTokenPattern(const CConcHolder* pHolder, const char* src, bool bRegularExpession, bool bExact=false);
        bool    CreateThesPattern(const CConcHolder* pHolder,const char* src);
        bool    CreateMorphAnnotationPattern(const CConcHolder* pHolder,const char* src, const char* IndexName);
        bool    CreateFileList(const CConcHolder* pHolder,const char* src);
        bool    CreateChunkPattern(const CConcHolder* pHolder, const char* ChunkTypeStr);
        bool    CreateNodeByIndexName(const CConcHolder* pHolder, const char* IndexName, const char* Value, bool bRegularExpession);

        void    EvaluateWithoutHits();
        void    Evaluate();
        size_t  GetNodeFrequenceByNodeIndex(size_t NodeIndex) const;

};


class CQuerySequenceNode : public CQueryNode
{
        vector<BYTE>                            m_Distances;    
        vector<CQueryTokenNode*>        m_Items;

        bool AddDistance(const char* s);
        
public:
        
        CQuerySequenceNode();
        virtual ~CQuerySequenceNode();
        bool    Create(const CConcHolder* pHolder, const vector<const CQueryNode*>& SequenceObj, const vector<string>& Distances);

        void    EvaluateWithoutHits();
        void    Evaluate();
        size_t  GetNodeFrequenceByNodeIndex(size_t NodeIndex) const;
};

class CQueryNearNode : public CQueryNode 
{
        CQueryNode*             m_pChild1;  
        CQueryNode*             m_pMiddleChild;   
        CQueryNode*             m_pChild2;  
        BYTE                    m_Distance;

        bool ReadDistanceFromString(const char* s);
        

public:
        
        CQueryNearNode();
        virtual ~CQueryNearNode();
        bool Create(const CConcHolder* pHolder, const char* distance_str, CQueryNode* child1, CQueryNode* child2, CQueryNode* child3 = 0);
        void Evaluate();
        size_t GetNodeFrequenceByNodeIndex(size_t NodeIndex) const;

};

class CQueryWithNode : public CQueryBinaryOperationNode
{
    void OccurIntersectionWithTokenIds();
public:
        CQueryWithNode();
        bool Create(const CConcHolder*  pHolder, CQueryNode* child1, CQueryNode* child2);
        void EvaluateWithoutHits();
        void Evaluate();
};

extern void GetWordForms (const MorphLanguageEnum Langua, const string& src, set<string>& WordForms);


#endif