documentinternal.h

Go to the documentation of this file.

 
/* Copyright 2017,2018,2019,2023,2024,2026 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_DOCUMENTINTERNAL_H
#define XAPIAN_INCLUDED_DOCUMENTINTERNAL_H
 
#include <xapian/document.h>
#include <xapian/intrusive_ptr.h>
#include <xapian/types.h>
 
#include "api/terminfo.h"
#include "api/termlist.h"
#include "backends/databaseinternal.h"
#include "clamp_cast.h"
#include "overflow.h"
 
#include <functional>
#include <limits>
#include <map>
#include <memory>
#include <string>
#include <string_view>
 
class DocumentTermList;
class DocumentValueList;
class GlassValueManager;
class HoneyValueManager;
class ValueStreamDocument;
 
namespace Xapian {
 
class Document::Internal : public Xapian::Internal::intrusive_base {
    friend class ::DocumentTermList;
    friend class ::DocumentValueList;
    // For ensure_values_fetched():
    friend class ::GlassValueManager;
    friend class ::HoneyValueManager;
    friend class ::ValueStreamDocument;
 
    void operator=(const Internal &) = delete;
 
    Internal(const Internal &) = delete;
 
    std::unique_ptr<std::string> data;
 
    mutable
    std::unique_ptr<std::map<std::string, TermInfo, std::less<>>> terms;
 
    mutable Xapian::termcount termlist_size;
 
    Xapian::doccount index : 31;
 
    mutable bool positions_modified_ : 1;
 
    void ensure_terms_fetched() const;
 
    void ensure_values_fetched() const;
 
  protected:
    mutable std::unique_ptr<std::map<Xapian::valueno, std::string>> values;
 
    Xapian::Internal::intrusive_ptr<const Xapian::Database::Internal> database;
 
    Xapian::docid did;
 
    Internal(Xapian::Internal::intrusive_ptr<const Xapian::Database::Internal> database_,
             Xapian::docid did_)
        : index(), positions_modified_(false), database(database_), did(did_) {}
 
    Internal(const Xapian::Database::Internal* database_,
             Xapian::docid did_,
             std::string&& data_,
             std::map<Xapian::valueno, std::string>&& values_)
        : data(new std::string(std::move(data_))),
          index(), positions_modified_(false),
          values(new std::map<Xapian::valueno, std::string>(std::move(values_))),
          database(database_),
          did(did_) {}
 
    virtual std::string fetch_data() const;
 
    virtual void fetch_all_values(std::map<Xapian::valueno,
                                  std::string>& values_) const;
 
    virtual std::string fetch_value(Xapian::valueno slot) const;
 
  public:
    Internal() : index(), positions_modified_(false), did(0) {}
 
    virtual ~Internal();
 
    bool data_modified() const { return data != NULL; }
 
    bool terms_modified() const { return terms != NULL; }
 
    bool values_modified() const { return values != NULL; }
 
    bool modified() const {
        return data_modified() || terms_modified() || values_modified();
    }
 
    bool positions_modified() const { return positions_modified_; }
 
    Xapian::docid get_docid() const { return did; }
 
    Xapian::doccount get_index() const { return index; }
 
    void set_index(Xapian::doccount new_index) { index = new_index; }
 
    std::string get_data() const {
        if (data)
            return *data;
        return fetch_data();
    }
 
    void set_data(std::string_view data_) {
        data.reset(new std::string(data_));
    }
 
    void add_term(std::string_view term, Xapian::termcount wdf_inc) {
        ensure_terms_fetched();
 
        auto i = terms->find(term);
        if (i == terms->end()) {
            ++termlist_size;
            terms->emplace(term, TermInfo(wdf_inc));
        } else {
            if (i->second.increase_wdf(wdf_inc))
                ++termlist_size;
        }
    }
 
    bool remove_term(std::string_view term) {
        ensure_terms_fetched();
 
        auto i = terms->find(term);
        if (i == terms->end()) {
            return false;
        }
        if (i->second.has_positions()) {
            positions_modified_ = true;
        }
        if (!i->second.remove()) {
            return false;
        }
        --termlist_size;
        return true;
    }
 
    void add_posting(std::string_view term,
                     Xapian::termpos term_pos,
                     Xapian::termcount wdf_inc) {
        ensure_terms_fetched();
        positions_modified_ = true;
 
        auto i = terms->find(term);
        if (i == terms->end()) {
            ++termlist_size;
            terms->emplace(term, TermInfo(wdf_inc, term_pos));
            return;
        }
        if (i->second.add_position(wdf_inc, term_pos))
            ++termlist_size;
    }
 
    enum remove_posting_result { OK, NO_TERM, NO_POS };
 
    remove_posting_result
    remove_posting(std::string_view term,
                   Xapian::termpos term_pos,
                   Xapian::termcount wdf_dec) {
        ensure_terms_fetched();
 
        auto i = terms->find(term);
        if (i == terms->end() || i->second.is_deleted()) {
            return remove_posting_result::NO_TERM;
        }
        if (!i->second.remove_position(term_pos)) {
            return remove_posting_result::NO_POS;
        }
        if (i->second.decrease_wdf(wdf_dec))
            --termlist_size;
        positions_modified_ = true;
        return remove_posting_result::OK;
    }
 
    remove_posting_result
    remove_postings(std::string_view term,
                    Xapian::termpos term_pos_first,
                    Xapian::termpos term_pos_last,
                    Xapian::termcount wdf_dec,
                    Xapian::termpos& n_removed) {
        ensure_terms_fetched();
 
        auto i = terms->find(term);
        if (i == terms->end() || i->second.is_deleted()) {
            return remove_posting_result::NO_TERM;
        }
        n_removed = i->second.remove_positions(term_pos_first,
                                               term_pos_last);
        if (n_removed) {
            positions_modified_ = true;
            Xapian::termcount wdf_delta;
            if (mul_overflows(n_removed, wdf_dec, wdf_delta)) {
                // Decreasing by the maximum value will zero the wdf.
                wdf_delta = std::numeric_limits<Xapian::termcount>::max();
            }
            if (i->second.decrease_wdf(wdf_delta))
                --termlist_size;
        }
        return remove_posting_result::OK;
    }
 
    void clear_terms() {
        if (!terms) {
            if (!database) {
                // We didn't come from a database, so there are no unfetched
                // terms to clear.
                return;
            }
            terms.reset(new std::map<std::string, TermInfo, std::less<>>());
        } else {
            terms->clear();
        }
        termlist_size = 0;
        // Assume there was positional data if there's any in the database.
        positions_modified_ = database && database->has_positions();
    }
 
    Xapian::termcount termlist_count() const {
        if (terms)
            return termlist_size;
 
        if (!database)
            return 0;
 
        std::unique_ptr<TermList> tl(database->open_term_list(did));
        // get_approx_size() is exact for TermList from a database.
        return tl->get_approx_size();
    }
 
    TermList* open_term_list() const;
 
    std::string get_value(Xapian::valueno slot) const {
        if (values) {
            auto i = values->find(slot);
            if (i != values->end())
                return i->second;
            return std::string();
        }
 
        return fetch_value(slot);
    }
 
    void add_value(Xapian::valueno slot, std::string_view value) {
        ensure_values_fetched();
 
        if (!value.empty()) {
            (*values)[slot] = value;
        } else {
            // Empty values aren't stored, but replace any existing value by
            // removing it.
            values->erase(slot);
        }
    }
 
    void clear_values() {
        if (!values) {
            if (database) {
                values.reset(new std::map<Xapian::valueno, std::string>());
            } else {
                // We didn't come from a database, so there are no unfetched
                // values to clear.
            }
        } else {
            values->clear();
        }
    }
 
    Xapian::valueno values_count() const {
        ensure_values_fetched();
        return clamp_cast<Xapian::valueno>(values->size());
    }
 
    Xapian::ValueIterator values_begin() const;
 
    std::string get_description() const;
};
 
}
 
#endif // XAPIAN_INCLUDED_DOCUMENTINTERNAL_H