xapian-core/include/xapian/valueiterator.h

   1 /** @file
   2  *  @brief Class for iterating over document values.
   3  */
   4 /* Copyright (C) 2008,2009,2010,2011,2012,2013,2014,2015 Olly Betts
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
  19  * USA
  20  */
  21
  22 #ifndef XAPIAN_INCLUDED_VALUEITERATOR_H
  23 #define XAPIAN_INCLUDED_VALUEITERATOR_H
  24
  25 #if !defined XAPIAN_IN_XAPIAN_H && !defined XAPIAN_LIB_BUILD
  26 # error Never use <xapian/valueiterator.h> directly; include <xapian.h> instead.
  27 #endif
  28
  29 #include <iterator>
  30 #include <string>
  31
  32 #include <xapian/attributes.h>
  33 #include <xapian/derefwrapper.h>
  34 #include <xapian/types.h>
  35 #include <xapian/visibility.h>
  36
  37 namespace Xapian {
  38
  39 /// Class for iterating over document values.
  40 class XAPIAN_VISIBILITY_DEFAULT ValueIterator {
  41     void decref();
  42
  43   public:
  44     /// Class representing the ValueIterator internals.
  45     class Internal;
  46     /// @private @internal Reference counted internals.
  47     Internal * internal;
  48
  49     /// @private @internal Construct given internals.
  50     explicit ValueIterator(Internal *internal_);
  51
  52     /// Copy constructor.
  53     ValueIterator(const ValueIterator & o);
  54
  55     /// Assignment.
  56     ValueIterator & operator=(const ValueIterator & o);
  57
  58 #ifdef XAPIAN_MOVE_SEMANTICS
  59     /// Move constructor.
  60     ValueIterator(ValueIterator && o)
  61         : internal(o.internal) {
  62         o.internal = nullptr;
  63     }
  64
  65     /// Move assignment operator.
  66     ValueIterator & operator=(ValueIterator && o) {
  67         if (this != &o) {
  68             if (internal) decref();
  69             internal = o.internal;
  70             o.internal = nullptr;
  71         }
  72         return *this;
  73     }
  74 #endif
  75
  76     /** Default constructor.
  77      *
  78      *  Creates an uninitialised iterator, which can't be used before being
  79      *  assigned to, but is sometimes syntactically convenient.
  80      */
  81     XAPIAN_NOTHROW(ValueIterator())
  82         : internal(0) { }
  83
  84     /// Destructor.
  85     ~ValueIterator() {
  86         if (internal) decref();
  87     }
  88
  89     /// Return the value at the current position.
  90     std::string operator*() const;
  91
  92     /// Advance the iterator to the next position.
  93     ValueIterator & operator++();
  94
  95     /// Advance the iterator to the next position (postfix version).
  96     DerefWrapper_<std::string> operator++(int) {
  97         const std::string & value(**this);
  98         operator++();
  99         return DerefWrapper_<std::string>(value);
 100     }
 101
 102     /** Return the docid at the current position.
 103      *
 104      *  If we're iterating over values of a document, this method will throw
 105      *  Xapian::InvalidOperationError.
 106      */
 107     Xapian::docid get_docid() const;
 108
 109     /** Return the value slot number for the current position.
 110      *
 111      *  If the iterator is over all values in a slot, this returns that slot's
 112      *  number.  If the iterator is over the values in a particular document,
 113      *  it returns the number of each slot in turn.
 114      */
 115     Xapian::valueno get_valueno() const;
 116
 117     /** Advance the iterator to document id or value slot @a docid_or_slot.
 118      *
 119      *  If this iterator is over values in a document, then this method
 120      *  advances the iterator to value slot @a docid_or_slot, or the first slot
 121      *  after it if there is no value in slot @a slot.
 122      *
 123      *  If this iterator is over values in a particular slot, then this
 124      *  method advances the iterator to document id @a docid_or_slot, or the
 125      *  first document id after it if there is no value in the slot we're
 126      *  iterating over for document @a docid_or_slot.
 127      *
 128      *  Note: The "two-faced" nature of this method is due to how C++
 129      *  overloading works.  Xapian::docid and Xapian::valueno are both typedefs
 130      *  for the same unsigned integer type, so overloading can't distinguish
 131      *  them.
 132      *
 133      *  @param docid_or_slot    The docid/slot to advance to.
 134      */
 135     void skip_to(Xapian::docid docid_or_slot);
 136
 137     /** Check if the specified docid occurs.
 138      *
 139      *  The caller is required to ensure that the specified document id
 140      *  @a did actually exists in the database.
 141      *
 142      *  This method acts like skip_to() if that can be done at little extra
 143      *  cost, in which case it then returns true.  This is how chert and
 144      *  glass databases behave because they store values in streams which allow
 145      *  for an efficient implementation of skip_to().
 146      *
 147      *  Otherwise it simply checks if a particular docid is present.  If it
 148      *  is, it returns true.  If it isn't, it returns false, and leaves the
 149      *  position unspecified (and hence the result of calling methods which
 150      *  depend on the current position, such as get_docid(), are also
 151      *  unspecified).  In this state, next() will advance to the first matching
 152      *  position after document @a did, and skip_to() will act as it would if
 153      *  the position was the first matching position after document @a did.
 154      *
 155      *  Currently the inmemory and remote backends behave in the
 156      *  latter way because they don't support streamed values and so skip_to()
 157      *  must check each document it skips over which is significantly slower.
 158      *
 159      *  @param docid    The document id to check.
 160      */
 161 #ifndef check
 162     bool check(Xapian::docid docid);
 163 #else
 164     // The AssertMacros.h header in the OS X SDK currently defines a check
 165     // macro.  Apple have deprecated check() in favour of __Check() and
 166     // plan to remove check() in a "future release", but for now prevent
 167     // expansion of check by adding parentheses in the method prototype:
 168     // https://www.opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/AssertMacros.h
 169     //
 170     // We do this conditionally, as these parentheses trip up SWIG's
 171     // parser:
 172     // https://github.com/swig/swig/issues/45
 173     bool (check)(Xapian::docid docid);
 174 #endif
 175
 176     /// Return a string describing this object.
 177     std::string get_description() const;
 178
 179     /** @private @internal ValueIterator is what the C++ STL calls an
 180      *  input_iterator.
 181      *
 182      *  The following typedefs allow std::iterator_traits<> to work so that
 183      *  this iterator can be used with the STL.
 184      *
 185      *  These are deliberately hidden from the Doxygen-generated docs, as the
 186      *  machinery here isn't interesting to API users.  They just need to know
 187      *  that Xapian iterator classes are compatible with the STL.
 188      */
 189     // @{
 190     /// @private
 191     typedef std::input_iterator_tag iterator_category;
 192     /// @private
 193     typedef std::string value_type;
 194     /// @private
 195     typedef Xapian::doccount_diff difference_type;
 196     /// @private
 197     typedef std::string * pointer;
 198     /// @private
 199     typedef std::string & reference;
 200     // @}
 201 };
 202
 203 bool
 204 XAPIAN_NOTHROW(operator==(const ValueIterator &a, const ValueIterator &b));
 205
 206 /// Equality test for ValueIterator objects.
 207 inline bool
 208 operator==(const ValueIterator &a, const ValueIterator &b) XAPIAN_NOEXCEPT
 209 {
 210     // Use a pointer comparison - this ensures both that (a == a) and correct
 211     // handling of end iterators (which we ensure have NULL internals).
 212     return a.internal == b.internal;
 213 }
 214
 215 bool
 216 XAPIAN_NOTHROW(operator!=(const ValueIterator &a, const ValueIterator &b));
 217
 218 /// Inequality test for ValueIterator objects.
 219 inline bool
 220 operator!=(const ValueIterator &a, const ValueIterator &b) XAPIAN_NOEXCEPT
 221 {
 222     return !(a == b);
 223 }
 224
 225 }
 226
 227 #endif // XAPIAN_INCLUDED_VALUEITERATOR_H