eset.h

Go to the documentation of this file.

 
/* Copyright (C) 2015,2016,2017 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, see
 * <https://www.gnu.org/licenses/>.
 */
 
#ifndef XAPIAN_INCLUDED_ESET_H
#define XAPIAN_INCLUDED_ESET_H
 
#if !defined XAPIAN_IN_XAPIAN_H && !defined XAPIAN_LIB_BUILD
# error Never use <xapian/eset.h> directly; include <xapian.h> instead.
#endif
 
#include <iterator>
#include <string>
 
#include <xapian/attributes.h>
#include <xapian/intrusive_ptr.h>
#include <xapian/stem.h>
#include <xapian/types.h>
#include <xapian/visibility.h>
 
namespace Xapian {
 
class ESetIterator;
 
class XAPIAN_VISIBILITY_DEFAULT ESet {
    friend class ESetIterator;
 
  public:
    class Internal;
    Xapian::Internal::intrusive_ptr_nonnull<Internal> internal;
 
    ESet(const ESet & o);
 
    ESet & operator=(const ESet & o);
 
    ESet(ESet && o);
 
    ESet & operator=(ESet && o);
 
    ESet();
 
    ~ESet();
 
    Xapian::termcount size() const;
 
    bool empty() const { return size() == 0; }
 
    Xapian::termcount get_ebound() const;
 
    void swap(ESet & o) { internal.swap(o.internal); }
 
    ESetIterator begin() const;
 
    ESetIterator end() const;
 
    ESetIterator operator[](Xapian::termcount i) const;
 
    ESetIterator back() const;
 
    std::string get_description() const;
 
    // @{
    typedef Xapian::ESetIterator value_type;
    typedef Xapian::termcount size_type;
    typedef Xapian::termcount_diff difference_type;
    typedef Xapian::ESetIterator iterator;
    typedef Xapian::ESetIterator const_iterator;
    typedef value_type * pointer;
    typedef const value_type * const_pointer;
    typedef value_type reference;
    typedef const value_type const_reference;
    // @}
    //
    // @{
    // The size is fixed once created.
    Xapian::termcount max_size() const { return size(); }
    // @}
};
 
class XAPIAN_VISIBILITY_DEFAULT ESetIterator {
    friend class ESet;
 
    ESetIterator(const Xapian::ESet & eset_, Xapian::termcount off_from_end_)
        : eset(eset_), off_from_end(off_from_end_) { }
 
  public:
    Xapian::ESet eset;
 
    Xapian::ESet::size_type off_from_end;
 
    ESetIterator() : off_from_end(0) { }
 
    std::string operator*() const;
 
    ESetIterator & operator++() {
        --off_from_end;
        return *this;
    }
 
    ESetIterator operator++(int) {
        ESetIterator retval = *this;
        --off_from_end;
        return retval;
    }
 
    ESetIterator & operator--() {
        ++off_from_end;
        return *this;
    }
 
    ESetIterator operator--(int) {
        ESetIterator retval = *this;
        ++off_from_end;
        return retval;
    }
 
    // @{
    typedef std::random_access_iterator_tag iterator_category;
    typedef std::string value_type;
    typedef Xapian::termcount_diff difference_type;
    typedef value_type* pointer;
    typedef value_type reference;
    // @}
 
    ESetIterator & operator+=(difference_type n) {
        off_from_end -= n;
        return *this;
    }
 
    ESetIterator & operator-=(difference_type n) {
        off_from_end += n;
        return *this;
    }
 
    ESetIterator operator+(difference_type n) const {
        return ESetIterator(eset, off_from_end - n);
    }
 
    ESetIterator operator-(difference_type n) const {
        return ESetIterator(eset, off_from_end + n);
    }
 
    difference_type operator-(const ESetIterator& o) const {
        return difference_type(o.off_from_end) - difference_type(off_from_end);
    }
 
    double get_weight() const;
 
    std::string get_description() const;
};
 
inline bool
operator==(const ESetIterator& a, const ESetIterator& b) noexcept
{
    return a.off_from_end == b.off_from_end;
}
 
inline bool
operator!=(const ESetIterator& a, const ESetIterator& b) noexcept
{
    return !(a == b);
}
 
inline bool
operator<(const ESetIterator& a, const ESetIterator& b) noexcept
{
    return a.off_from_end > b.off_from_end;
}
 
inline bool
operator>(const ESetIterator& a, const ESetIterator& b) noexcept
{
    return b < a;
}
 
inline bool
operator>=(const ESetIterator& a, const ESetIterator& b) noexcept
{
    return !(a < b);
}
 
inline bool
operator<=(const ESetIterator& a, const ESetIterator& b) noexcept
{
    return !(b < a);
}
 
inline ESetIterator
operator+(ESetIterator::difference_type n, const ESetIterator& it)
{
    return it + n;
}
 
// Inlined methods of ESet which need ESetIterator to have been defined:
 
inline ESetIterator
ESet::begin() const {
    return ESetIterator(*this, size());
}
 
inline ESetIterator
ESet::end() const {
    // Decrementing the result of end() needs to work, so we must pass in
    // *this here.
    return ESetIterator(*this, 0);
}
 
inline ESetIterator
ESet::operator[](Xapian::termcount i) const {
    return ESetIterator(*this, size() - i);
}
 
inline ESetIterator
ESet::back() const {
    return ESetIterator(*this, 1);
}
 
}
 
#endif // XAPIAN_INCLUDED_ESET_H