mset.h

Go to the documentation of this file.

/* Copyright (C) 2015,2016,2019 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_CJK_NGRAM = 2048
    };

    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