CLucene - a full-featured, c++ search engine
API Documentation

---

IndexReader.h

Go to the documentation of this file.

/*------------------------------------------------------------------------------
* Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team
* 
* Distributable under the terms of either the Apache License (Version 2.0) or 
* the GNU Lesser General Public License, as specified in the COPYING file.
------------------------------------------------------------------------------*/
#ifndef _lucene_index_IndexReader_
#define _lucene_index_IndexReader_


CL_CLASS_DEF(store,Directory)
//#include "CLucene/store/FSDirectory.h"
CL_CLASS_DEF(store,LuceneLock)
CL_CLASS_DEF(document,Document)
#include "CLucene/util/Array.h"

//#include "CLucene/index/TermVector.h"
//#include "SegmentInfos.h"
//#include "Terms.h"
CL_CLASS_DEF(index,TermFreqVector)
CL_CLASS_DEF(index,TermEnum)
CL_CLASS_DEF(index,Term)
CL_CLASS_DEF(index,TermDocs)
CL_CLASS_DEF(index,TermPositions)
CL_CLASS_DEF(store,Directory)
#include "CLucene/LuceneThreads.h"
#include "CLucene/util/VoidMapSetDefinitions.h"


CL_NS_DEF(index)

// Need this forward declaration as IndexReader and SegmentInfos depend on each other
class SegmentInfos;

class CLUCENE_EXPORT IndexReader :LUCENE_BASE{
    void aquireWriteLock();
protected:
    IndexReader(CL_NS(store)::Directory* dir);

        IndexReader(CL_NS(store)::Directory* directory, SegmentInfos* segmentInfos, bool closeDirectory);
        

        virtual void doClose() = 0;

    virtual void doSetNorm(int32_t doc, const TCHAR* field, uint8_t value) = 0;
      
    virtual void doUndeleteAll() = 0;


    virtual void doDelete(const int32_t docNum) = 0;

public:
        //Callback for classes that need to know if IndexReader is closing.
        typedef void (*CloseCallback)(IndexReader*, void*);
        
    virtual void doCommit() = 0;
        class Internal;
        Internal* internal;
        
  
        enum FieldOption {
                // all fields
                ALL = 1,
                // all indexed fields
                INDEXED = 2,
                // all fields which are not indexed
                UNINDEXED = 4,
                // all fields which are indexed with termvectors enables
                INDEXED_WITH_TERMVECTOR = 8,
                // all fields which are indexed but don't have termvectors enabled
                INDEXED_NO_TERMVECTOR = 16,
                // all fields where termvectors are enabled. Please note that only standard termvector fields are returned
                TERMVECTOR = 32,
                // all field with termvectors wiht positions enabled
                TERMVECTOR_WITH_POSITION = 64,
                // all fields where termvectors with offset position are set
                TERMVECTOR_WITH_OFFSET = 128,
                // all fields where termvectors with offset and position values set
                TERMVECTOR_WITH_POSITION_OFFSET = 256,
                // all fields that store payloads
                STORES_PAYLOADS = 512
        };


        DEFINE_MUTEX(THIS_LOCK)
        
        
        virtual void commit();
        
        
        void undeleteAll();

        virtual void getFieldNames(FieldOption fldOption, StringArrayWithDeletor& retarray) = 0;
        
        _CL_DEPRECATED( getFieldNames(FieldOption, StringArrayWithDeletor&) ) virtual TCHAR** getFieldNames();
        _CL_DEPRECATED( getFieldNames(FieldOption, StringArrayWithDeletor&) ) virtual TCHAR** getFieldNames(bool indexed);

        virtual uint8_t* norms(const TCHAR* field) = 0;
        
        
        virtual void norms(const TCHAR* field, uint8_t* bytes) = 0;

    void setNorm(int32_t doc, const TCHAR* field, float_t value);
  
    void setNorm(int32_t doc, const TCHAR* field, uint8_t value);

    virtual ~IndexReader();

        static IndexReader* open(const char* path);

        static IndexReader* open( CL_NS(store)::Directory* directory, bool closeDirectory=false);

        static uint64_t lastModified(const char* directory);

        static uint64_t lastModified(const CL_NS(store)::Directory* directory);

        
        static int64_t getCurrentVersion(CL_NS(store)::Directory* directory);
        
        static int64_t getCurrentVersion(const char* directory);
        
        int64_t getVersion();
        
        bool isCurrent();


        virtual bool getTermFreqVectors(int32_t docNumber, CL_NS(util)::Array<TermFreqVector*>& result) =0;
        
        virtual TermFreqVector* getTermFreqVector(int32_t docNumber, const TCHAR* field) = 0;
        
        static bool indexExists(const char* directory);

        static bool indexExists(const CL_NS(store)::Directory* directory);

        virtual int32_t numDocs() = 0;

        virtual int32_t maxDoc() const = 0;

        virtual bool document(int32_t n, CL_NS(document)::Document*) =0;
        
        _CL_DEPRECATED( document(i, document) ) CL_NS(document)::Document* document(const int32_t n);

        virtual bool isDeleted(const int32_t n) = 0;

        virtual bool hasDeletions() const = 0;

        virtual bool hasNorms(const TCHAR* field);

        virtual TermEnum* terms() const =0;

        virtual TermEnum* terms(const Term* t) const = 0;

        virtual int32_t docFreq(const Term* t) const = 0;

        /* Returns an unpositioned TermPositions enumerator.
         * @memory Caller must clean up
         */
        virtual TermPositions* termPositions() const = 0;
        
        TermPositions* termPositions(Term* term) const;

        virtual TermDocs* termDocs() const = 0;

        TermDocs* termDocs(Term* term) const;

        void deleteDocument(const int32_t docNum);

        _CL_DEPRECATED( deleteDocument ) void deleteDoc(const int32_t docNum){ deleteDocument(docNum); }

        int32_t deleteDocuments(Term* term);

        _CL_DEPRECATED( deleteDocuments ) int32_t deleteTerm(Term* term){ return deleteDocuments(term); }

        void close();

        static bool isLocked(CL_NS(store)::Directory* directory);
        
        static bool isLocked(const char* directory);


        static void unlock(CL_NS(store)::Directory* directory);
        static void unlock(const char* path);

        CL_NS(store)::Directory* getDirectory();

        static bool isLuceneFile(const char* filename);

        void addCloseCallback(CloseCallback callback, void* parameter);

};

CL_NS_END
#endif

---

clucene.sourceforge.net