Ticket #186: ref-counted-subclassables.patch

xapian-bindings/perl/perl.i

@@ -343 +343 @@
 }
 %}
 
-%feature("shadow") Xapian::QueryParser::add_valuerangeprocessor
-%{
-sub add_valuerangeprocessor {
-    my ($self, $vrproc) = @_;
-    push @{$self{_vrproc}}, $vrproc;
-    Search::Xapianc::QueryParser_add_valuerangeprocessor( @_ );
-}
-%}
-
 /* Xapian::SimpleStopper */
 %feature("shadow") Xapian::SimpleStopper::SimpleStopper
 %{

xapian-bindings/python/extra.i

@@ -728 +728 @@
 Enquire.get_query = _enquire_get_query
 del _enquire_get_query
 
-# When we set a ValueRangeProcessor into the QueryParser, keep a python
-# reference so it won't be deleted. This hack can probably be removed once
-# xapian bug #186 is fixed.
-__queryparser_add_valuerangeprocessor_orig = QueryParser.add_valuerangeprocessor
-def _queryparser_add_valuerangeprocessor(self, vrproc):
-    if not hasattr(self, '_vrps'):
-        self._vrps = []
-    self._vrps.append(vrproc)
-    return __queryparser_add_valuerangeprocessor_orig(self, vrproc)
-_queryparser_add_valuerangeprocessor.__doc__ = __queryparser_add_valuerangeprocessor_orig.__doc__
-QueryParser.add_valuerangeprocessor = _queryparser_add_valuerangeprocessor
-del _queryparser_add_valuerangeprocessor
-
 # When we set a FieldProcessor into the QueryParser, keep a python
 # reference so it won't be deleted. This hack can probably be removed once
 # xapian bug #186 is fixed.

xapian-bindings/xapian-headers.i

@@ -324 +324 @@
 SUBCLASSABLE(Xapian, FieldProcessor)
 SUBCLASSABLE(Xapian, Stopper)
 SUBCLASSABLE(Xapian, ValueRangeProcessor)
+%warnfilter(SWIGWARN_TYPE_UNDEFINED_CLASS) Xapian::ValueRangeProcessor;
+%feature("ref") Xapian::ValueRangeProcessor "$this->ref();"
+%feature("unref") Xapian::ValueRangeProcessor "$this->unref();"
 STANDARD_IGNORES(Xapian, QueryParser)
 %ignore Xapian::QueryParser::QueryParser(const QueryParser &);
 %include <xapian/queryparser.h>

xapian-core/include/xapian/intrusive_ptr.h

@@ -5 +5 @@
 //  Based on Boost's intrusive_ptr.hpp
 //
 //  Copyright (c) 2001, 2002 Peter Dimov
-//  Copyright (c) 2011 Olly Betts
+//  Copyright (c) 2011, 2013 Olly Betts
 //
 // Distributed under the Boost Software License, Version 1.0.
 //
@@ -175 +175 @@
     return a != b.get();
 }
 
+/// Base class for objects managed by opt_intrusive_ptr.
+class opt_intrusive_base : public intrusive_base {
+  public:
+    opt_intrusive_base(const opt_intrusive_base&) : intrusive_base() { }
+
+    opt_intrusive_base& operator=(const opt_intrusive_base&) {
+        // Don't touch _refs.
+        return *this;
+    }
+
+    /** Construct object which is initially not reference counted.
+     *
+     *  The reference counting starts if release_() is called.
+     */
+    opt_intrusive_base() : intrusive_base() { }
+
+    /* Subclasses of opt_intrusive_base may be deleted by calling delete on a
+     * pointer to intrusive_base*.
+     */
+    virtual ~opt_intrusive_base() { }
+
+    /** Start reference counting.
+     *
+     *  The object is constructed with _refs set to 0, meaning it isn't being
+     *  reference counted.
+     *
+     *  Calling release() sets _refs to 1 if it is 0, and from then
+     *  opt_intrusive_ptr will increment and decrement _refs.  If it is
+     *  decremented to 1, the object is deleted.
+     */
+    void release() const {
+        if (_refs == 0)
+            _refs = 1;
+    }
+
+    void ref() const {
+        if (_refs == 0)
+            _refs = 2;
+        else
+            ++_refs;
+    }
+
+    void unref() const {
+        if (--_refs == 1)
+            delete this;
+    }
+};
+
+//
+//  opt_intrusive_ptr
+//
+
+/// A smart pointer that uses intrusive reference counting.
+template<class T> class opt_intrusive_ptr
+{
+private:
+
+    typedef opt_intrusive_ptr this_type;
+
+public:
+
+    opt_intrusive_ptr(): px( 0 )
+    {
+    }
+
+    opt_intrusive_ptr( T * p): px( p )
+    {
+        if( px != 0 && px->_refs ) ++px->_refs;
+    }
+
+    template<class U>
+    opt_intrusive_ptr( opt_intrusive_ptr<U> const & rhs )
+    : px( rhs.get() )
+    {
+        if( px != 0 && px->_refs ) ++px->_refs;
+    }
+
+    opt_intrusive_ptr(opt_intrusive_ptr const & rhs): px( rhs.px )
+    {
+        if( px != 0 && px->_refs ) ++px->_refs;
+    }
+
+    ~opt_intrusive_ptr()
+    {
+        if( px != 0 && px->_refs && --px->_refs == 1 ) delete px;
+    }
+
+    opt_intrusive_ptr & operator=(opt_intrusive_ptr const & rhs)
+    {
+        this_type(rhs).swap(*this);
+        return *this;
+    }
+
+    opt_intrusive_ptr & operator=(T * rhs)
+    {
+        this_type(rhs).swap(*this);
+        return *this;
+    }
+
+    T * get() const
+    {
+        return px;
+    }
+
+    T & operator*() const
+    {
+        return *px;
+    }
+
+    T * operator->() const
+    {
+        return px;
+    }
+
+    void swap(opt_intrusive_ptr & rhs)
+    {
+        T * tmp = px;
+        px = rhs.px;
+        rhs.px = tmp;
+    }
+
+private:
+
+    T * px;
+};
+
+template<class T, class U> inline bool operator==(opt_intrusive_ptr<T> const & a, opt_intrusive_ptr<U> const & b)
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=(opt_intrusive_ptr<T> const & a, opt_intrusive_ptr<U> const & b)
+{
+    return a.get() != b.get();
+}
+
+template<class T, class U> inline bool operator==(opt_intrusive_ptr<T> const & a, U * b)
+{
+    return a.get() == b;
+}
+
+template<class T, class U> inline bool operator!=(opt_intrusive_ptr<T> const & a, U * b)
+{
+    return a.get() != b;
+}
+
+template<class T, class U> inline bool operator==(T * a, opt_intrusive_ptr<U> const & b)
+{
+    return a == b.get();
+}
+
+template<class T, class U> inline bool operator!=(T * a, opt_intrusive_ptr<U> const & b)
+{
+    return a != b.get();
+}
+
 }
 }
 

xapian-core/include/xapian/queryparser.h

@@ -1 +1 @@
 /** @file queryparser.h
  * @brief parsing a user query string to build a Xapian::Query object
  */
-/* Copyright (C) 2005,2006,2007,2008,2009,2010,2011,2012 Olly Betts
+/* Copyright (C) 2005,2006,2007,2008,2009,2010,2011,2012,2013 Olly Betts
  * Copyright (C) 2010 Adam Sjøgren
  *
  * This program is free software; you can redistribute it and/or
@@ -85 +85 @@
 };
 
 /// Base class for value range processors.
-struct XAPIAN_VISIBILITY_DEFAULT ValueRangeProcessor {
+struct XAPIAN_VISIBILITY_DEFAULT ValueRangeProcessor
+    : public Xapian::Internal::opt_intrusive_base {
     /// Destructor.
     virtual ~ValueRangeProcessor();
 

xapian-core/queryparser/queryparser.lemony

@@ -1 +1 @@
 %include {
 /* queryparser.lemony: build a Xapian::Query object from a user query string.
  *
- * Copyright (C) 2004,2005,2006,2007,2008,2009,2010,2011,2012 Olly Betts
+ * Copyright (C) 2004,2005,2006,2007,2008,2009,2010,2011,2012,2013 Olly Betts
  * Copyright (C) 2007,2008,2009 Lemur Consulting Ltd
  * Copyright (C) 2010 Adam Sjøgren
  *
@@ -252 +252 @@
     }
 
     Term * value_range(const string &a, const string &b) {
-        list<ValueRangeProcessor *>::const_iterator i;
+        list<Xapian::Internal::opt_intrusive_ptr<Xapian::ValueRangeProcessor> >::const_iterator i;
         for (i = qpi->valrangeprocs.begin(); i != qpi->valrangeprocs.end(); ++i) {
             string start = a;
             string end = b;

xapian-core/queryparser/queryparser_internal.h

@@ -1 +1 @@
 /** @file queryparser_internal.h
  * @brief The non-lemon-generated parts of the QueryParser class.
  */
-/* Copyright (C) 2005,2006,2007,2010,2011,2012 Olly Betts
+/* Copyright (C) 2005,2006,2007,2010,2011,2012,2013 Olly Betts
  * Copyright (C) 2010 Adam Sjøgren
  *
  * This program is free software; you can redistribute it and/or
@@ -82 +82 @@
     // "foobar" -> "XFOO". FIXME: it does more than this now!
     map<string, FieldInfo> field_map;
 
-    list<ValueRangeProcessor *> valrangeprocs;
+    list<Xapian::Internal::opt_intrusive_ptr<ValueRangeProcessor> > valrangeprocs;
 
     string corrected_query;
 

xapian-core/tests/api_none.cc

@@ -2 +2 @@
  * @brief tests which don't need a backend
  */
 /* Copyright (C) 2009 Richard Boulton
- * Copyright (C) 2009,2010,2011 Olly Betts
+ * Copyright (C) 2009,2010,2011,2013 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
@@ -142 +142 @@
     TEST_EQUAL(q.get_description(), "Query((beer@1 OR beer@1))");
     return true;
 }
+
+struct TestValueRangeProcessor : public Xapian::ValueRangeProcessor {
+    bool & destroyed;
+
+    TestValueRangeProcessor(bool & destroyed_) : destroyed(destroyed_) {
+        destroyed = false;
+    }
+
+    ~TestValueRangeProcessor() {
+        destroyed = true;
+    }
+
+    Xapian::valueno operator()(std::string &, std::string &) {
+        return 42;
+    }
+};
+
+/// Check reference counting of user-subclassable classes.
+DEFINE_TESTCASE(subclassablerefcount1, !backend) {
+    bool gone_auto, gone;
+    {
+        TestValueRangeProcessor vrp_auto(gone_auto);
+        TEST(!gone_auto);
+        {
+            Xapian::QueryParser qp1;
+            {
+                Xapian::QueryParser qp2;
+                Xapian::ValueRangeProcessor * vrp;
+                vrp = new TestValueRangeProcessor(gone);
+                TEST(!gone);
+                vrp->release();
+                qp1.add_valuerangeprocessor(vrp);
+                TEST(!gone);
+                qp2.add_valuerangeprocessor(vrp);
+                TEST(!gone);
+                qp2.add_valuerangeprocessor(&vrp_auto);
+                TEST(!gone);
+                TEST(!gone_auto);
+            }
+            TEST(!gone);
+        }
+        TEST(gone);
+        TEST(!gone_auto);
+    }
+    TEST(gone_auto);
+
+    return true;
+}