include/xapian/matchspy.h

Go to the documentation of this file.

/* Copyright (C) 2007 Olly Betts
 * Copyright (C) 2007 Lemur Consulting Ltd
 *
 * 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_MATCHSPY_H
#define XAPIAN_INCLUDED_MATCHSPY_H

#include <xapian/enquire.h>

#include <map>
#include <set>
#include <string>
#include <vector>

namespace Xapian {

class XAPIAN_VISIBILITY_DEFAULT MultipleMatchDecider : public MatchDecider {
  private:
    std::vector<const MatchDecider *> deciders;

  public:
    void append(const MatchDecider * decider) {
        deciders.push_back(decider);
    }

    bool operator()(const Xapian::Document &doc) const;
};

struct XAPIAN_VISIBILITY_DEFAULT StringAndFrequency {
    std::string str;
    Xapian::doccount frequency;
    StringAndFrequency(std::string str_, Xapian::doccount frequency_)
            : str(str_), frequency(frequency_) {}
};


class XAPIAN_VISIBILITY_DEFAULT StringListSerialiser {
  private:
    std::string serialised;

  public:
    StringListSerialiser() { }

    StringListSerialiser(const std::string & initial) : serialised(initial) { }

    template <class Iterator>
    StringListSerialiser(Iterator begin, Iterator end) : serialised() {
        while (begin != end) append(*begin++);
    }

    void append(const std::string & value);

    const std::string & get() const { return serialised; }
};

class XAPIAN_VISIBILITY_DEFAULT StringListUnserialiser {
  private:
    std::string serialised;
    std::string curritem;
    const char * pos;

    void read_next();

    friend bool operator==(const StringListUnserialiser & a,
                           const StringListUnserialiser & b);
    friend bool operator!=(const StringListUnserialiser & a,
                           const StringListUnserialiser & b);

  public:
    StringListUnserialiser() : pos(NULL) {}

    StringListUnserialiser(const std::string & in)
            : serialised(in),
              pos(serialised.data())
    {
        read_next();
    }

    ~StringListUnserialiser() {}

    StringListUnserialiser(const StringListUnserialiser & other)
            : serialised(other.serialised),
              curritem(other.curritem),
              pos((other.pos == NULL) ? NULL : serialised.data() + (other.pos - other.serialised.data()))
    {}

    void operator=(const StringListUnserialiser & other) {
        serialised = other.serialised;
        curritem = other.curritem;
        pos = (other.pos == NULL) ? NULL : serialised.data() + (other.pos - other.serialised.data());
    }

    std::string operator *() const {
        return curritem;
    }

    StringListUnserialiser & operator++() {
        read_next();
        return *this;
    }

    StringListUnserialiser operator++(int) {
        StringListUnserialiser tmp = *this;
        read_next();
        return tmp;
    }

    // Allow use as an STL iterator
    typedef std::input_iterator_tag iterator_category;
    typedef std::string value_type;
    typedef size_t difference_type;
    typedef std::string * pointer;
    typedef std::string & reference;
};

inline bool operator==(const StringListUnserialiser & a,
                       const StringListUnserialiser & b) {
    return (a.pos == b.pos);
}

inline bool operator!=(const StringListUnserialiser & a,
                       const StringListUnserialiser & b) {
    return (a.pos != b.pos);
}

class XAPIAN_VISIBILITY_DEFAULT ValueCountMatchSpy : public MatchDecider {
  protected:
    mutable Xapian::doccount total;

    mutable std::map<Xapian::valueno, std::map<std::string, Xapian::doccount> > values;

    std::set<Xapian::valueno> multivalues;

  public:
    ValueCountMatchSpy() : total(0) { }

    ValueCountMatchSpy(Xapian::valueno valno, bool multivalue=false) : total(0) {
        add_slot(valno, multivalue);
    }

    void add_slot(Xapian::valueno valno, bool multivalue=false) {
        // Ensure that values[valno] exists.
        (void)values[valno];
        if (multivalue) multivalues.insert(valno);
    }

    const std::map<std::string, Xapian::doccount> &
            get_values(Xapian::valueno valno) const {
        return values[valno];
    }

    size_t get_total() const {
        return total;
    }

    void get_top_values(std::vector<StringAndFrequency> & result,
                        Xapian::valueno valno, size_t maxvalues) const;

    bool operator()(const Xapian::Document &doc) const;
};

class XAPIAN_VISIBILITY_DEFAULT TermCountMatchSpy : public MatchDecider {
  protected:
    mutable Xapian::doccount documents_seen;

    mutable Xapian::termcount terms_seen;

    mutable std::map<std::string, std::map<std::string, Xapian::doccount> > terms;

  public:
    TermCountMatchSpy() : documents_seen(0), terms_seen(0) { }

    TermCountMatchSpy(std::string prefix) : documents_seen(0), terms_seen(0) {
        add_prefix(prefix);
    }

    void add_prefix(std::string prefix) {
        // Ensure that terms[prefix] exists.
        (void)terms[prefix];
    }

    const std::map<std::string, Xapian::doccount> &
            get_terms(std::string prefix) const {
        return terms[prefix];
    }

    size_t get_documents_seen() const {
        return documents_seen;
    }

    size_t get_terms_seen() const {
        return terms_seen;
    }

    void get_top_terms(std::vector<StringAndFrequency> & result,
                       std::string prefix, size_t maxterms) const;

    bool operator()(const Xapian::Document &doc) const;
};



class XAPIAN_VISIBILITY_DEFAULT CategorySelectMatchSpy :
        public ValueCountMatchSpy {
  public:
    CategorySelectMatchSpy() : ValueCountMatchSpy() { }

    CategorySelectMatchSpy(Xapian::valueno valno) : ValueCountMatchSpy(valno) {
    }

    double score_categorisation(Xapian::valueno valno,
                                double desired_no_of_categories = 0.0);

    bool build_numeric_ranges(Xapian::valueno valno, size_t max_ranges);
};

}

#endif // XAPIAN_INCLUDED_MATCHSPY_H

---