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 */