eset.h

Go to the documentation of this file.

/* Copyright (C) 2015,2016 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, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
 * USA
 */

#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<Internal> internal;

    ESet(const ESet & o);

    ESet & operator=(const ESet & o);

#ifdef XAPIAN_MOVE_SEMANTICS
    ESet(ESet && o);

    ESet & operator=(ESet && o);
#endif

    ESet();

    ~ESet();

    Xapian::doccount 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::doccount 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::doccount max_size() const { return size(); }
    // @}
};

class XAPIAN_VISIBILITY_DEFAULT ESetIterator {
    friend class ESet;

    ESetIterator(const Xapian::ESet & eset_, Xapian::doccount 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 std::string * pointer;
    typedef std::string & 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;
};

bool
XAPIAN_NOTHROW(operator==(const ESetIterator &a, const ESetIterator &b));

inline bool
operator==(const ESetIterator &a, const ESetIterator &b) XAPIAN_NOEXCEPT
{
    return a.off_from_end == b.off_from_end;
}

inline bool
XAPIAN_NOTHROW(operator!=(const ESetIterator &a, const ESetIterator &b));

inline bool
operator!=(const ESetIterator &a, const ESetIterator &b) XAPIAN_NOEXCEPT
{
    return !(a == b);
}

bool
XAPIAN_NOTHROW(operator<(const ESetIterator &a, const ESetIterator &b));

inline bool
operator<(const ESetIterator &a, const ESetIterator &b) XAPIAN_NOEXCEPT
{
    return a.off_from_end > b.off_from_end;
}

inline bool
XAPIAN_NOTHROW(operator>(const ESetIterator &a, const ESetIterator &b));

inline bool
operator>(const ESetIterator &a, const ESetIterator &b) XAPIAN_NOEXCEPT
{
    return b < a;
}

inline bool
XAPIAN_NOTHROW(operator>=(const ESetIterator &a, const ESetIterator &b));

inline bool
operator>=(const ESetIterator &a, const ESetIterator &b) XAPIAN_NOEXCEPT
{
    return !(a < b);
}

inline bool
XAPIAN_NOTHROW(operator<=(const ESetIterator &a, const ESetIterator &b));

inline bool
operator<=(const ESetIterator &a, const ESetIterator &b) XAPIAN_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::doccount i) const {
    return ESetIterator(*this, size() - i);
}

inline ESetIterator
ESet::back() const {
    return ESetIterator(*this, 1);
}

}

#endif // XAPIAN_INCLUDED_ESET_H