enquire.h

Go to the documentation of this file.

 
/* Copyright 1999,2000,2001 BrightStation PLC
 * Copyright 2001,2002 Ananova Ltd
 * Copyright 2002,2003,2004,2005,2006,2007,2008,2009,2011,2012,2013,2014,2015,2016 Olly Betts
 * Copyright 2009 Lemur Consulting Ltd
 * Copyright 2011 Action Without Borders
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
 * USA
 */
 
#ifndef XAPIAN_INCLUDED_ENQUIRE_H
#define XAPIAN_INCLUDED_ENQUIRE_H
 
#if !defined XAPIAN_IN_XAPIAN_H && !defined XAPIAN_LIB_BUILD
# error Never use <xapian/enquire.h> directly; include <xapian.h> instead.
#endif
 
#include "xapian/deprecated.h"
#include <string>
 
#include <xapian/attributes.h>
#include <xapian/eset.h>
#include <xapian/intrusive_ptr.h>
#include <xapian/mset.h>
#include <xapian/stem.h>
#include <xapian/types.h>
#include <xapian/termiterator.h>
#include <xapian/visibility.h>
 
namespace Xapian {
 
class Database;
class Document;
class ErrorHandler;
class ExpandDecider;
class KeyMaker;
class MatchSpy;
class Query;
class Weight;
 
class XAPIAN_VISIBILITY_DEFAULT RSet {
    public:
        class Internal;
 
        Xapian::Internal::intrusive_ptr<Internal> internal;
 
        RSet(const RSet &rset);
 
        void operator=(const RSet &rset);
 
#ifdef XAPIAN_MOVE_SEMANTICS
        RSet(RSet && o);
 
        RSet & operator=(RSet && o);
#endif
 
        RSet();
 
        ~RSet();
 
        Xapian::doccount size() const;
 
        bool empty() const;
 
        void add_document(Xapian::docid did);
 
        void add_document(const Xapian::MSetIterator & i) { add_document(*i); }
 
        void remove_document(Xapian::docid did);
 
        void remove_document(const Xapian::MSetIterator & i) { remove_document(*i); }
 
        bool contains(Xapian::docid did) const;
 
        bool contains(const Xapian::MSetIterator & i) const { return contains(*i); }
 
        std::string get_description() const;
};
 
class XAPIAN_VISIBILITY_DEFAULT MatchDecider {
        void operator=(const MatchDecider &);
 
        MatchDecider(const MatchDecider &);
 
    public:
        MatchDecider() { }
 
        virtual bool operator()(const Xapian::Document &doc) const = 0;
 
        virtual ~MatchDecider();
};
 
class XAPIAN_VISIBILITY_DEFAULT Enquire {
    public:
        Enquire(const Enquire & other);
 
        void operator=(const Enquire & other);
 
#ifdef XAPIAN_MOVE_SEMANTICS
        Enquire(Enquire&& o);
 
        Enquire& operator=(Enquire&& o);
#endif
 
        class Internal;
        Xapian::Internal::intrusive_ptr<Internal> internal;
 
        explicit Enquire(const Database &database);
 
        XAPIAN_DEPRECATED_EX(Enquire(const Database &database, ErrorHandler * errorhandler_));
 
        ~Enquire();
 
        void set_query(const Xapian::Query & query, Xapian::termcount qlen = 0);
 
        const Xapian::Query & get_query() const;
 
        void add_matchspy(MatchSpy * spy);
 
        void clear_matchspies();
 
        void set_weighting_scheme(const Weight &weight_);
 
        void set_expansion_scheme(const std::string &eweightname_,
                                  double expand_k_ = 1.0) const;
 
        void set_collapse_key(Xapian::valueno collapse_key,
                              Xapian::doccount collapse_max = 1);
 
        typedef enum {
            ASCENDING = 1,
            DESCENDING = 0,
            DONT_CARE = 2
        } docid_order;
 
        void set_docid_order(docid_order order);
 
        void set_cutoff(int percent_cutoff, double weight_cutoff = 0);
 
        void set_sort_by_relevance();
 
        void set_sort_by_value(Xapian::valueno sort_key, bool reverse);
 
        void set_sort_by_key(Xapian::KeyMaker * sorter, bool reverse);
 
        void set_sort_by_value_then_relevance(Xapian::valueno sort_key,
                                              bool reverse);
 
        void set_sort_by_key_then_relevance(Xapian::KeyMaker * sorter,
                                            bool reverse);
 
        void set_sort_by_relevance_then_value(Xapian::valueno sort_key,
                                              bool reverse);
 
        void set_sort_by_relevance_then_key(Xapian::KeyMaker * sorter,
                                            bool reverse);
 
        void set_time_limit(double time_limit);
 
        MSet get_mset(Xapian::doccount first, Xapian::doccount maxitems,
                      Xapian::doccount checkatleast = 0,
                      const RSet * omrset = 0,
                      const MatchDecider * mdecider = 0) const;
 
        MSet get_mset(Xapian::doccount first, Xapian::doccount maxitems,
                      const RSet * omrset,
                      const MatchDecider * mdecider = 0) const {
            return get_mset(first, maxitems, 0, omrset, mdecider);
        }
 
        static const int INCLUDE_QUERY_TERMS = 1;
 
        static const int USE_EXACT_TERMFREQ = 2;
 
        ESet get_eset(Xapian::termcount maxitems,
                      const RSet & omrset,
                      int flags = 0,
                      const Xapian::ExpandDecider * edecider = 0,
                      double min_wt = 0.0) const;
 
        ESet get_eset(Xapian::termcount maxitems, const RSet & omrset,
                             const Xapian::ExpandDecider * edecider) const {
            return get_eset(maxitems, omrset, 0, edecider);
        }
 
        XAPIAN_DEPRECATED(ESet get_eset(Xapian::termcount maxitems,
                          const RSet & rset,
                          int flags,
                          double k,
                          const Xapian::ExpandDecider * edecider = NULL,
                          double min_wt = 0.0) const) {
            set_expansion_scheme("trad", k);
            return get_eset(maxitems, rset, flags, edecider, min_wt);
        }
 
        TermIterator get_matching_terms_begin(Xapian::docid did) const;
 
        TermIterator XAPIAN_NOTHROW(get_matching_terms_end(Xapian::docid /*did*/) const) {
            return TermIterator();
        }
 
        TermIterator get_matching_terms_begin(const MSetIterator &it) const;
 
        TermIterator XAPIAN_NOTHROW(get_matching_terms_end(const MSetIterator &/*it*/) const) {
            return TermIterator();
        }
 
        std::string get_description() const;
};
 
}
 
#endif /* XAPIAN_INCLUDED_ENQUIRE_H */