include/xapian/queryparser.h

Go to the documentation of this file.

/* Copyright (C) 2005,2006,2007,2008,2009,2010 Olly Betts
 *
 * 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_QUERYPARSER_H
#define XAPIAN_INCLUDED_QUERYPARSER_H

#include <xapian/base.h>
#include <xapian/query.h>
#include <xapian/termiterator.h>
#include <xapian/visibility.h>

#include <set>
#include <string>

namespace Xapian {

class Database;
class Stem;

class XAPIAN_VISIBILITY_DEFAULT Stopper {
  public:
    virtual bool operator()(const std::string & term) const = 0;

    virtual ~Stopper() { }

    virtual std::string get_description() const;
};

class XAPIAN_VISIBILITY_DEFAULT SimpleStopper : public Stopper {
  private:
    std::set<std::string> stop_words;

  public:
    SimpleStopper() { }

#ifndef __SUNPRO_CC
    template <class Iterator>
    SimpleStopper(Iterator begin, Iterator end) : stop_words(begin, end) { }
#else
    // Sun's C++ doesn't cope with the Iterator pointing to const char *.
    template <class Iterator>
    SimpleStopper(Iterator begin, Iterator end) {
        while (begin != end) stop_words.insert(*begin++);
    }
#endif

    void add(const std::string & word) { stop_words.insert(word); }

    virtual bool operator()(const std::string & term) const {
        return stop_words.find(term) != stop_words.end();
    }

    virtual ~SimpleStopper() { }

    virtual std::string get_description() const;
};

struct XAPIAN_VISIBILITY_DEFAULT ValueRangeProcessor {
    virtual ~ValueRangeProcessor();

    virtual Xapian::valueno operator()(std::string &begin, std::string &end) = 0;
};

class XAPIAN_VISIBILITY_DEFAULT StringValueRangeProcessor : public ValueRangeProcessor {
    Xapian::valueno valno;

  public:
    StringValueRangeProcessor(Xapian::valueno valno_)
        : valno(valno_) { }

    Xapian::valueno operator()(std::string &, std::string &) {
        return valno;
    }
};

class XAPIAN_VISIBILITY_DEFAULT DateValueRangeProcessor : public ValueRangeProcessor {
    Xapian::valueno valno;
    bool prefer_mdy;
    int epoch_year;

  public:
    DateValueRangeProcessor(Xapian::valueno valno_, bool prefer_mdy_ = false,
                            int epoch_year_ = 1970)
        : valno(valno_), prefer_mdy(prefer_mdy_), epoch_year(epoch_year_) { }

    Xapian::valueno operator()(std::string &begin, std::string &end);
};

// Xapian 1.0.0 and 1.0.1 had a conceptually broken implementation of
// NumberValueRangeProcessor which we quickly told people to avoid using.  But
// to keep ABI compatibility, we should keep it around until the next
// incompatible ABI change (in 1.1.0).  So we put the new
// NumberValueRangeProcessor in a subnamespace and then pull it into this one
// with "using v102::NumberValueRangeProcessor".  The old
// NumberValueRangeProcessor still exists with default visibility, but isn't
// declared in an external or internal header, so will only be used when
// dynamically linking with application code built against Xapian 1.0.0 or
// 1.0.1.
#ifndef DOXYGEN
// Hide the v102 namespace from Doxygen as it isn't user-visible.
namespace v102 {
#endif

class XAPIAN_VISIBILITY_DEFAULT NumberValueRangeProcessor : public ValueRangeProcessor {
    Xapian::valueno valno;
    bool prefix;
    std::string str;

  public:
    NumberValueRangeProcessor(Xapian::valueno valno_)
        : valno(valno_), prefix(false) { }

    NumberValueRangeProcessor(Xapian::valueno valno_, const std::string &str_,
                              bool prefix_ = true)
        : valno(valno_), prefix(prefix_), str(str_) { }

    Xapian::valueno operator()(std::string &begin, std::string &end);
};

#ifndef DOXYGEN
}

# ifndef XAPIAN_NO_V102_NUMBER_VRP
using v102::NumberValueRangeProcessor;
# endif
#endif

class XAPIAN_VISIBILITY_DEFAULT QueryParser {
  public:
    class Internal;
    Xapian::Internal::RefCntPtr<Internal> internal;

    typedef enum {
        FLAG_BOOLEAN = 1,
        FLAG_PHRASE = 2,
        FLAG_LOVEHATE = 4,
        FLAG_BOOLEAN_ANY_CASE = 8,
        FLAG_WILDCARD = 16,
        FLAG_PURE_NOT = 32,
        FLAG_PARTIAL = 64,

        FLAG_SPELLING_CORRECTION = 128,

        FLAG_SYNONYM = 256,

        FLAG_AUTO_SYNONYMS = 512,

        FLAG_AUTO_MULTIWORD_SYNONYMS = 1024 | FLAG_AUTO_SYNONYMS,

        FLAG_DEFAULT = FLAG_PHRASE|FLAG_BOOLEAN|FLAG_LOVEHATE
    } feature_flag;

    typedef enum { STEM_NONE, STEM_SOME, STEM_ALL } stem_strategy;

    QueryParser(const QueryParser & o);

    QueryParser & operator=(const QueryParser & o);

    QueryParser();

    ~QueryParser();

    void set_stemmer(const Xapian::Stem & stemmer);

    void set_stemming_strategy(stem_strategy strategy);

    void set_stopper(const Stopper *stop = NULL);

    void set_default_op(Query::op default_op);

    Query::op get_default_op() const;

    void set_database(const Database &db);

    Query parse_query(const std::string &query_string,
                      unsigned flags = FLAG_PHRASE|FLAG_BOOLEAN|FLAG_LOVEHATE,
                      const std::string &default_prefix = "");

    void add_prefix(const std::string &field, const std::string &prefix);

    void add_boolean_prefix(const std::string & field, const std::string &prefix);

    TermIterator stoplist_begin() const;
    TermIterator stoplist_end() const {
        return TermIterator(NULL);
    }

    TermIterator unstem_begin(const std::string &term) const;
    TermIterator unstem_end(const std::string &) const {
        return TermIterator(NULL);
    }

    void add_valuerangeprocessor(Xapian::ValueRangeProcessor * vrproc);

    std::string get_corrected_query_string() const;

    std::string get_description() const;
};

XAPIAN_VISIBILITY_DEFAULT
std::string sortable_serialise(double value);

XAPIAN_VISIBILITY_DEFAULT
double sortable_unserialise(const std::string & value);

}

#endif // XAPIAN_INCLUDED_QUERYPARSER_H

---