Ticket #199: matchspy_changes_13246_13247.patch

xapian-core/tests/api_nodb.cc

@@ -377 +377 @@
     return true;
 }
 
+// tests the string list serialisation classes.
+DEFINE_TESTCASE(stringlistserialise1, !backend)
+{
+    Xapian::StringListSerialiser s1;
+    s1.append("foo");
+    s1.append("");
+    Xapian::StringListSerialiser s2(s1);
+    s2.append("baz");
+    Xapian::StringListUnserialiser p(s2.get());
+    Xapian::StringListUnserialiser end;
+    TEST(p != end);
+    TEST_EQUAL(*p, "foo");
+    ++p;
+    TEST(p != end);
+    TEST_EQUAL(*p, "");
+    p++;
+    TEST(p != end);
+    TEST_EQUAL(*p, "baz");
+    ++p;
+    TEST(p == end);
+    return true;
+}
+
 // Test a scaleweight query applied to a match nothing query
 DEFINE_TESTCASE(scaleweight3, !backend) {
     Xapian::Query matchnothing(Xapian::Query::MatchNothing);

xapian-core/include/xapian/matchspy.h

@@ -157 +157 @@
 };
 
 
+/// Class to serialise a list of strings in a form suitable for
+/// ValueCountMatchSpy.
+class XAPIAN_VISIBILITY_DEFAULT StringListSerialiser {
+  private:
+    std::string serialised;
+
+  public:
+    /// Default constructor.
+    StringListSerialiser() { }
+
+    /// Initialise with a string.
+    /// (The string represents a serialised form, rather than a single value to
+    /// be serialised.)
+    StringListSerialiser(const std::string & initial) : serialised(initial) { }
+
+    /// Initialise from a pair of iterators.
+    template <class Iterator>
+    StringListSerialiser(Iterator begin, Iterator end) : serialised() {
+        while (begin != end) append(*begin++);
+    }
+
+    /// Add a string to the end of the list.
+    void append(const std::string & value);
+
+    /// Get the serialised result.
+    const std::string & get() const { return serialised; }
+};
+
+
+/// Class to unserialise a list of strings serialised by a StringListSerialiser.
+/// The class can be used as an iterator: use the default constructor to get
+/// an end iterator.
+class XAPIAN_VISIBILITY_DEFAULT StringListUnserialiser {
+  private:
+    std::string serialised;
+    std::string curritem;
+    const char * pos;
+
+    /// Read the next item from the serialised form.
+    void read_next();
+
+    /// Compare this iterator with another
+    friend bool operator==(const StringListUnserialiser & a,
+                           const StringListUnserialiser & b);
+    friend bool operator!=(const StringListUnserialiser & a,
+                           const StringListUnserialiser & b);
+
+  public:
+    /// Default constructor - use this to define an end iterator.
+    StringListUnserialiser() : pos(NULL) {}
+
+    /// Constructor which takes a serialised list of strings, and creates an
+    /// iterator pointing to the first of them.
+    StringListUnserialiser(const std::string & in)
+            : serialised(in),
+              pos(serialised.data())
+    {
+        read_next();
+    }
+
+    /// Copy constructor
+    StringListUnserialiser(const StringListUnserialiser & other)
+            : serialised(other.serialised),
+              curritem(other.curritem),
+              pos((other.pos == NULL) ? NULL : serialised.data() + (other.pos - other.serialised.data()))
+    {}
+
+    /// Assignment operator
+    void operator=(const StringListUnserialiser & other) {
+        serialised = other.serialised;
+        curritem = other.curritem;
+        pos = (other.pos == NULL) ? NULL : serialised.data() + (other.pos - other.serialised.data());
+    }
+
+    /// Get the current item
+    std::string operator *() const {
+        return curritem;
+    }
+
+    /// Move to the next item.
+    StringListUnserialiser & operator++() {
+        read_next();
+        return *this;
+    }
+
+    /// Move to the next item (postfix).
+    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);
+}
+
+
 /** A string with a corresponding frequency.
  */
 class XAPIAN_VISIBILITY_DEFAULT StringAndFrequency {
@@ -234 +345 @@
 };
 
 
+/// Class for counting the frequencies of values in the matching documents.
+class XAPIAN_VISIBILITY_DEFAULT MultiValueCountMatchSpy : public ValueCountMatchSpy {
+  public:
+    /// Construct an empty MultiValueCountMatchSpy.
+    MultiValueCountMatchSpy() {}
+
+    /** Construct a MatchSpy which counts the values in a particular slot.
+     *
+     *  Further slots can be added by calling @a add_slot().
+     */
+    MultiValueCountMatchSpy(Xapian::valueno slot_)
+            : ValueCountMatchSpy(slot_) {
+    }
+
+    /** Implementation of virtual operator().
+     *
+     *  This implementation tallies values for a matching document.
+     */
+    void operator()(const Xapian::Document &doc, Xapian::weight wt);
+
+    virtual MatchSpy * clone() const;
+    virtual std::string name() const;
+    virtual std::string serialise() const;
+    virtual MatchSpy * unserialise(const std::string & s,
+                                   const SerialisationContext & context) const;
+    virtual std::string get_description() const;
+};
+
+
 /** A numeric range.
  *
  *  This is used to represent ranges of values returned by the match spies.

xapian-core/api/matchspy.cc

@@ -84 +84 @@
 }
 
 
+void
+StringListSerialiser::append(const string & value)
+{
+    serialised.append(encode_length(value.size()));
+    serialised.append(value);
+}
+
+void
+StringListUnserialiser::read_next()
+{
+    if (pos == NULL) {
+        return;
+    }
+    if (pos == serialised.data() + serialised.size()) {
+        pos = NULL;
+        curritem.resize(0);
+        return;
+    }
+
+    // FIXME - decode_length will throw a NetworkError if the length is too
+    // long - should be a more appropriate error.
+    size_t currlen = decode_length(&pos, serialised.data() + serialised.size(), true);
+    curritem.assign(pos, currlen);
+    pos += currlen;
+}
+
+
 /** Compare two StringAndFrequency objects.
  *
  *  The comparison is firstly by frequency (higher is better), then by string
@@ -245 +272 @@
 }
 
 
+void
+MultiValueCountMatchSpy::operator()(const Document &doc, weight) {
+    ++total;
+    StringListUnserialiser i(doc.get_value(slot));
+    StringListUnserialiser end;
+    for (; i != end; ++i) {
+        string val(*i);
+        if (!val.empty()) ++values[val];
+    }
+}
+
+MatchSpy *
+MultiValueCountMatchSpy::clone() const {
+    return new MultiValueCountMatchSpy(slot);
+}
+
+string
+MultiValueCountMatchSpy::name() const {
+    return "Xapian::MultiValueCountMatchSpy";
+}
+
+string
+MultiValueCountMatchSpy::serialise() const {
+    string result;
+    result += encode_length(slot);
+    return result;
+}
+
+MatchSpy *
+MultiValueCountMatchSpy::unserialise(const string & s,
+                                     const SerialisationContext &) const{
+    const char * p = s.data();
+    const char * end = p + s.size();
+
+    valueno new_slot = decode_length(&p, end, false);
+    if (p != end) {
+        throw NetworkError("Junk at end of serialised MultiValueCountMatchSpy");
+    }
+
+    return new MultiValueCountMatchSpy(new_slot);
+}
+
+string
+MultiValueCountMatchSpy::get_description() const {
+    return "Xapian::MultiValueCountMatchSpy(" + str(total) +
+            " docs seen, looking in " + str(values.size()) + " slots)";
+}
+
+
 inline double sqrd(double x) { return x * x; }
 
 /** Calculate a score based on how evenly distributed the frequencies of a set

xapian-bindings/python/util.i

@@ -396 +396 @@
         }
     }
 
+    %extend StringListUnserialiser {
+        bool __eq__(const StringListUnserialiser &other) {
+            return (*self)==other;
+        }
+        bool __ne__(const StringListUnserialiser &other) {
+            return (*self)!=other;
+        }
+    }
+
     %extend MSet {
         %immutable;
         // access to the items array

xapian-bindings/xapian.i

@@ -473 +473 @@
 %warnfilter(842) Xapian::TradWeight::unserialise;
 %include <xapian/weight.h>
 
+%ignore Xapian::StringListUnserialiser::operator=;
+%ignore Xapian::StringListUnserialiser::operator++;
+%ignore operator==(const StringListUnserialiser &, const StringListUnserialiser &);
+%ignore operator!=(const StringListUnserialiser &, const StringListUnserialiser &);
+%extend Xapian::StringListUnserialiser {
+    std::string get() const {
+        return *(*self);
+    }
+    NEXT(std::string, StringListUnserialiser)
+    bool equals(const StringListUnserialiser &other) const {
+        return (*self) == other;
+    }
+}
+
 %ignore Xapian::NumericRange::operator<;
 %include <xapian/matchspy.h>