mset.h

Go to the documentation of this file.

 
/* Copyright (C) 2015,2016,2019,2023 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_MSET_H
#define XAPIAN_INCLUDED_MSET_H
 
#if !defined XAPIAN_IN_XAPIAN_H && !defined XAPIAN_LIB_BUILD
# error Never use <xapian/mset.h> directly; include <xapian.h> instead.
#endif
 
#include <iterator>
#include <string>
 
#include <xapian/attributes.h>
#include <xapian/document.h>
#include <xapian/intrusive_ptr.h>
#include <xapian/stem.h>
#include <xapian/types.h>
#include <xapian/visibility.h>
 
namespace Xapian {
 
class MSetIterator;
 
class XAPIAN_VISIBILITY_DEFAULT MSet {
    friend class MSetIterator;
 
    // Helper function for fetch() methods.
    void fetch_(Xapian::doccount first, Xapian::doccount last) const;
 
  public:
    class Internal;
    Xapian::Internal::intrusive_ptr<Internal> internal;
 
    MSet(const MSet & o);
 
    MSet & operator=(const MSet & o);
 
#ifdef XAPIAN_MOVE_SEMANTICS
    MSet(MSet && o);
 
    MSet & operator=(MSet && o);
#endif
 
    MSet();
 
    ~MSet();
 
    int convert_to_percent(double weight) const;
 
    int convert_to_percent(const MSetIterator & it) const;
 
    Xapian::doccount get_termfreq(const std::string & term) const;
 
    double get_termweight(const std::string & term) const;
 
    Xapian::doccount get_firstitem() const;
 
    Xapian::doccount get_matches_lower_bound() const;
    Xapian::doccount get_matches_estimated() const;
    Xapian::doccount get_matches_upper_bound() const;
 
    Xapian::doccount get_uncollapsed_matches_lower_bound() const;
    Xapian::doccount get_uncollapsed_matches_estimated() const;
    Xapian::doccount get_uncollapsed_matches_upper_bound() const;
 
    double get_max_attained() const;
    double get_max_possible() const;
 
    enum {
        SNIPPET_BACKGROUND_MODEL = 1,
        SNIPPET_EXHAUSTIVE = 2,
        SNIPPET_EMPTY_WITHOUT_MATCH = 4,
 
        SNIPPET_NGRAMS = 2048,
 
        SNIPPET_CJK_NGRAM = SNIPPET_NGRAMS
    };
 
    std::string snippet(const std::string & text,
                        size_t length = 500,
                        const Xapian::Stem & stemmer = Xapian::Stem(),
                        unsigned flags = SNIPPET_BACKGROUND_MODEL|SNIPPET_EXHAUSTIVE,
                        const std::string & hi_start = "<b>",
                        const std::string & hi_end = "</b>",
                        const std::string & omit = "...") const;
 
    void fetch(const MSetIterator &begin, const MSetIterator &end) const;
 
    void fetch(const MSetIterator &item) const;
 
    void fetch() const { fetch_(0, Xapian::doccount(-1)); }
 
    Xapian::doccount size() const;
 
    bool empty() const { return size() == 0; }
 
    void swap(MSet & o) { internal.swap(o.internal); }
 
    MSetIterator begin() const;
 
    MSetIterator end() const;
 
    MSetIterator operator[](Xapian::doccount i) const;
 
    MSetIterator back() const;
 
    std::string get_description() const;
 
    // @{
    typedef Xapian::MSetIterator value_type;
    typedef Xapian::doccount size_type;
    typedef Xapian::doccount_diff difference_type;
    typedef Xapian::MSetIterator iterator;
    typedef Xapian::MSetIterator 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 MSetIterator {
    friend class MSet;
 
    MSetIterator(const Xapian::MSet & mset_, Xapian::doccount off_from_end_)
        : mset(mset_), off_from_end(off_from_end_) { }
 
  public:
    Xapian::MSet mset;
 
    Xapian::MSet::size_type off_from_end;
 
    MSetIterator() : off_from_end(0) { }
 
    Xapian::docid operator*() const;
 
    MSetIterator & operator++() {
        --off_from_end;
        return *this;
    }
 
    MSetIterator operator++(int) {
        MSetIterator retval = *this;
        --off_from_end;
        return retval;
    }
 
    MSetIterator & operator--() {
        ++off_from_end;
        return *this;
    }
 
    MSetIterator operator--(int) {
        MSetIterator 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;
    // @}
 
    MSetIterator & operator+=(difference_type n) {
        off_from_end -= n;
        return *this;
    }
 
    MSetIterator & operator-=(difference_type n) {
        off_from_end += n;
        return *this;
    }
 
    MSetIterator operator+(difference_type n) const {
        return MSetIterator(mset, off_from_end - n);
    }
 
    MSetIterator operator-(difference_type n) const {
        return MSetIterator(mset, off_from_end + n);
    }
 
    difference_type operator-(const MSetIterator& o) const {
        return difference_type(o.off_from_end) - difference_type(off_from_end);
    }
 
    Xapian::doccount get_rank() const {
        return mset.get_firstitem() + (mset.size() - off_from_end);
    }
 
    Xapian::Document get_document() const;
 
    double get_weight() const;
 
    std::string get_collapse_key() const;
 
    Xapian::doccount get_collapse_count() const;
 
    std::string get_sort_key() const;
 
    int get_percent() const {
        return mset.convert_to_percent(get_weight());
    }
 
    std::string get_description() const;
};
 
bool
XAPIAN_NOTHROW(operator==(const MSetIterator &a, const MSetIterator &b));
 
inline bool
operator==(const MSetIterator &a, const MSetIterator &b) XAPIAN_NOEXCEPT
{
    return a.off_from_end == b.off_from_end;
}
 
inline bool
XAPIAN_NOTHROW(operator!=(const MSetIterator &a, const MSetIterator &b));
 
inline bool
operator!=(const MSetIterator &a, const MSetIterator &b) XAPIAN_NOEXCEPT
{
    return !(a == b);
}
 
bool
XAPIAN_NOTHROW(operator<(const MSetIterator &a, const MSetIterator &b));
 
inline bool
operator<(const MSetIterator &a, const MSetIterator &b) XAPIAN_NOEXCEPT
{
    return a.off_from_end > b.off_from_end;
}
 
inline bool
XAPIAN_NOTHROW(operator>(const MSetIterator &a, const MSetIterator &b));
 
inline bool
operator>(const MSetIterator &a, const MSetIterator &b) XAPIAN_NOEXCEPT
{
    return b < a;
}
 
inline bool
XAPIAN_NOTHROW(operator>=(const MSetIterator &a, const MSetIterator &b));
 
inline bool
operator>=(const MSetIterator &a, const MSetIterator &b) XAPIAN_NOEXCEPT
{
    return !(a < b);
}
 
inline bool
XAPIAN_NOTHROW(operator<=(const MSetIterator &a, const MSetIterator &b));
 
inline bool
operator<=(const MSetIterator &a, const MSetIterator &b) XAPIAN_NOEXCEPT
{
    return !(b < a);
}
 
inline MSetIterator
operator+(MSetIterator::difference_type n, const MSetIterator& it)
{
    return it + n;
}
 
// Inlined methods of MSet which need MSetIterator to have been defined:
 
inline void
MSet::fetch(const MSetIterator &begin_it, const MSetIterator &end_it) const
{
    fetch_(begin_it.off_from_end, end_it.off_from_end);
}
 
inline void
MSet::fetch(const MSetIterator &item) const
{
    fetch_(item.off_from_end, item.off_from_end);
}
 
inline MSetIterator
MSet::begin() const {
    return MSetIterator(*this, size());
}
 
inline MSetIterator
MSet::end() const {
    // Decrementing the result of end() needs to work, so we must pass in
    // *this here.
    return MSetIterator(*this, 0);
}
 
inline MSetIterator
MSet::operator[](Xapian::doccount i) const {
    return MSetIterator(*this, size() - i);
}
 
inline MSetIterator
MSet::back() const {
    return MSetIterator(*this, 1);
}
 
inline int
MSet::convert_to_percent(const MSetIterator & it) const {
    return convert_to_percent(it.get_weight());
}
 
}
 
#endif // XAPIAN_INCLUDED_MSET_H