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_

#if defined(_LUCENE_PRAGMA_ONCE)
# pragma once
#endif

#include "CLucene/store/Directory.h"
#include "CLucene/store/FSDirectory.h"
#include "CLucene/store/Lock.h"
#include "CLucene/document/Document.h"
#include "CLucene/index/TermVector.h"
#include "SegmentInfos.h"
#include "Terms.h"


CL_NS_DEF(index)



class IndexReader :LUCENE_BASE{
public:
        //Callback for classes that need to know if IndexReader is closing.
        typedef void (*CloseCallback)(IndexReader*, void*);

        class CloseCallbackCompare:public CL_NS(util)::Compare::_base{
        public:
                bool operator()( CloseCallback t1, CloseCallback t2 ) const{
                        return t1 > t2;
                }
                static void doDelete(CloseCallback dummy){
                }
        };
        
        
        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
        };


private:
        CL_NS(store)::LuceneLock* writeLock;

    bool directoryOwner;
    bool stale;
    bool hasChanges;
    bool closeDirectory;
    
    SegmentInfos* segmentInfos;

    CL_NS(store)::Directory* directory;
        typedef CL_NS(util)::CLSet<CloseCallback, void*, 
                CloseCallbackCompare,
                CloseCallbackCompare> CloseCallbackMap;
        CloseCallbackMap closeCallbacks;
        
    virtual void doCommit() = 0;
  
    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:

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

        virtual void getFieldNames(FieldOption fldOption, CL_NS(util)::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, 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() { return directory; }

        static bool isLuceneFile(const char* filename);

        void addCloseCallback(CloseCallback callback, void* parameter);

protected:
        class LockWith:public CL_NS(store)::LuceneLockWith<IndexReader*>{
        public:
                CL_NS(store)::Directory* directory;
                IndexReader* indexReader;

                //Constructor   
                LockWith(CL_NS(store)::LuceneLock* lock, CL_NS(store)::Directory* dir);

                //Reads the segmentinfo file and depending on the number of segments found
                //it returns a MultiReader or a SegmentReader
                IndexReader* doBody();

        };
        friend class IndexReader::LockWith;

    class CommitLockWith:public CL_NS(store)::LuceneLockWith<void>{
    private:
            IndexReader* reader;
        public:
                        
            //Constructor       
            CommitLockWith( CL_NS(store)::LuceneLock* lock, IndexReader* r );
            void doBody();
        };
        friend class IndexReader::CommitLockWith;
};

CL_NS_END
#endif

---

clucene.sourceforge.net