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

---

SearchHeader.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_search_SearchHeader_
#define _lucene_search_SearchHeader_

#if defined(_LUCENE_PRAGMA_ONCE)
# pragma once
#endif

#include "CLucene/index/IndexReader.h"
#include "CLucene/index/Term.h"
#include "Filter.h"
#include "CLucene/document/Document.h"
#include "Sort.h"
#include "CLucene/util/VoidList.h"
#include "Explanation.h"
#include "Similarity.h"

CL_NS_DEF(search)

        //predefine classes
        class Scorer;
        class Query;
        class Hits;
        class Sort;
        class FieldDoc;
        class TopFieldDocs;
   
        struct ScoreDoc {
                int32_t doc;

                float_t score;
        };

        class TopDocs:LUCENE_BASE {
        public:
                int32_t totalHits;

                ScoreDoc* scoreDocs;
                int32_t scoreDocsLength;

                TopDocs(const int32_t th, ScoreDoc* sds, int32_t scoreDocsLength);
                ~TopDocs();
        };

    // Lower-level search API.
    // @see Searcher#search(Query,HitCollector)
        class HitCollector: LUCENE_BASE {
    public:
      virtual void collect(const int32_t doc, const float_t score) = 0;
                virtual ~HitCollector(){}
    };

        class Weight: LUCENE_BASE {
    public:
                virtual ~Weight(){
                };

      virtual Query* getQuery() = 0;

      virtual float_t getValue() = 0;

      virtual float_t sumOfSquaredWeights() = 0;

      virtual void normalize(float_t norm) = 0;

      virtual Scorer* scorer(CL_NS(index)::IndexReader* reader) = 0;

      virtual void explain(CL_NS(index)::IndexReader* reader, int32_t doc, Explanation* ret) = 0;

      virtual TCHAR* toString(){
         return STRDUP_TtoT(_T("Weight"));
      }
   };

   class HitDoc:LUCENE_BASE {
    public:
                float_t score;
                int32_t id;
                CL_NS(document)::Document* doc;
                
                HitDoc* next;                                     // in doubly-linked cache
                HitDoc* prev;                                     // in doubly-linked cache
                
                HitDoc(const float_t s, const int32_t i);
                ~HitDoc();
    };



    // A ranked list of documents, used to hold search results. 
   class Hits:LUCENE_BASE {
    private:
                Query* query;
                Searcher* searcher;
                Filter* filter;
                const Sort* sort;

                size_t _length;                           // the total number of hits
                CL_NS(util)::CLVector<HitDoc*, CL_NS(util)::Deletor::Object<HitDoc> > hitDocs;    // cache of hits retrieved

                HitDoc* first;                            // head of LRU cache
                HitDoc* last;                             // tail of LRU cache
                int32_t numDocs;                          // number cached
                int32_t maxDocs;                          // max to cache

    public:
                Hits(Searcher* s, Query* q, Filter* f, const Sort* sort=NULL);
                ~Hits();

                int32_t length() const;
            
                CL_NS(document)::Document& doc(const int32_t n);
              
                int32_t id (const int32_t n);
            
                float_t score(const int32_t n);
              
        private:
                // Tries to add new documents to hitDocs.
                // Ensures that the hit numbered <code>_min</code> has been retrieved.
                void getMoreDocs(const size_t _min);
            
                HitDoc* getHitDoc(const size_t n);
            
                void addToFront(HitDoc* hitDoc);
            
                void remove(const HitDoc* hitDoc);

  };

   class Searchable: LUCENE_BASE {
   public:
        virtual ~Searchable(){
        }

      virtual void _search(Query* query, Filter* filter, HitCollector* results) = 0;

      virtual void close() = 0;

      virtual int32_t docFreq(const CL_NS(index)::Term* term) const = 0;

      virtual int32_t maxDoc() const = 0;

      virtual TopDocs* _search(Query* query, Filter* filter, const int32_t n) = 0;

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

      virtual Query* rewrite(Query* query) = 0;

      virtual void explain(Query* query, int32_t doc, Explanation* ret) = 0;

                virtual TopFieldDocs* _search(Query* query, Filter* filter, const int32_t n, const Sort* sort) = 0;
   };



        class Searcher:public Searchable {
        private:
                Similarity* similarity;

                public:
                Searcher(){
                        similarity = Similarity::getDefault();
                }
                virtual ~Searcher(){
                }

                // Returns the documents matching <code>query</code>.
                Hits* search(Query* query) {
                        return search(query, (Filter*)NULL );
                }

                // Returns the documents matching <code>query</code> and
                //      <code>filter</code>. 
                Hits* search(Query* query, Filter* filter) {
                        return _CLNEW Hits(this, query, filter);
                }

                Hits* search(Query* query, const Sort* sort){
                        return _CLNEW Hits(this, query, NULL, sort);
                }

                Hits* search(Query* query, Filter* filter, const Sort* sort){
                        return _CLNEW Hits(this, query, filter, sort);
                }

                void _search(Query* query, HitCollector* results) {
                        Searchable::_search(query, NULL, results);
                }

                void setSimilarity(Similarity* similarity) {
                        this->similarity = similarity;
                }

                Similarity* getSimilarity(){
                        return this->similarity;
                }
        };

        class Query :LUCENE_BASE {
        private:
                // query boost factor
                float_t boost;
        protected:
                Query(const Query& clone);
        public:
                Query();
                virtual ~Query();

                void setBoost(float_t b);

                float_t getBoost() const;

        Weight* weight(Searcher* searcher);

        virtual Query* rewrite(CL_NS(index)::IndexReader* reader);
        
         virtual Query* combine(Query** queries);

        static Query* mergeBooleanQueries(Query** queries);

        Similarity* getSimilarity(Searcher* searcher);
        
        virtual Query* clone() const = 0;
        virtual const TCHAR* getQueryName() const = 0;
        bool instanceOf(const TCHAR* other) const;
        
        virtual TCHAR* toString(const TCHAR* field) const = 0;
        
        virtual bool equals(Query* other) const = 0;
        virtual size_t hashCode() const = 0;
        
        TCHAR* toString() const;

                
                virtual Weight* _createWeight(Searcher* searcher);
                
        };


CL_NS_END
#endif

---

clucene.sourceforge.net