backends/chert/chert_postlist.h

Go to the documentation of this file.

/* chert_postlist.h: Postlists in chert databases
 *
 * Copyright 1999,2000,2001 BrightStation PLC
 * Copyright 2002 Ananova Ltd
 * Copyright 2002,2003,2004,2005,2007,2008,2009,2011 Olly Betts
 * Copyright 2007,2009 Lemur Consulting Ltd
 *
 * 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 OM_HGUARD_CHERT_POSTLIST_H
#define OM_HGUARD_CHERT_POSTLIST_H

#include <xapian/database.h>

#include "chert_types.h"
#include "chert_positionlist.h"
#include "leafpostlist.h"
#include "omassert.h"

#include "autoptr.h"
#include <map>
#include <string>

using namespace std;

class ChertCursor;
class ChertDatabase;

namespace Chert {
    class PostlistChunkReader;
    class PostlistChunkWriter;
}

class ChertPostList;

class ChertPostListTable : public ChertTable {
        mutable AutoPtr<ChertPostList> doclen_pl;

    public:
        ChertPostListTable(const string & path_, bool readonly_)
            : ChertTable("postlist", path_ + "/postlist.", readonly_),
              doclen_pl()
        { }

        bool open(chert_revision_number_t revno) {
            doclen_pl.reset(0);
            return ChertTable::open(revno);
        }

        void merge_changes(
            const map<string, map<Xapian::docid, pair<char, Xapian::termcount> > > & mod_plists,
            const map<Xapian::docid, Xapian::termcount> & doclens,
            const map<string, pair<Xapian::termcount_diff, Xapian::termcount_diff> > & freq_deltas);

        Xapian::docid get_chunk(const string &tname,
                Xapian::docid did, bool adding,
                Chert::PostlistChunkReader ** from,
                Chert::PostlistChunkWriter **to);

        static string make_key(const string & term, Xapian::docid did) {
            return pack_chert_postlist_key(term, did);
        }

        static string make_key(const string & term) {
            return pack_chert_postlist_key(term);
        }

        bool term_exists(const string & term) const {
            return key_exists(make_key(term));
        }

        Xapian::doccount get_termfreq(const std::string & term) const;

        Xapian::termcount get_collection_freq(const std::string & term) const;

        Xapian::termcount get_doclength(Xapian::docid did,
                                        Xapian::Internal::RefCntPtr<const ChertDatabase> db) const;

        bool document_exists(Xapian::docid did,
                             Xapian::Internal::RefCntPtr<const ChertDatabase> db) const;
};

class ChertPostList : public LeafPostList {
    protected: // ChertModifiedPostList needs to access these.
        Xapian::Internal::RefCntPtr<const ChertDatabase> this_db;

        ChertPositionList positionlist;

        bool have_started;

    private:
        bool is_last_chunk;

        bool is_at_end;

        AutoPtr<ChertCursor> cursor;

        Xapian::docid first_did_in_chunk;

        Xapian::docid last_did_in_chunk;

        const char * pos;

        const char * end;

        Xapian::docid did;

        Xapian::termcount wdf;

        Xapian::doccount number_of_entries;

        ChertPostList(const ChertPostList &);

        void operator=(const ChertPostList &);

        bool next_in_chunk();

        void next_chunk();

        bool current_chunk_contains(Xapian::docid desired_did);

        void move_to_chunk_containing(Xapian::docid desired_did);

        bool move_forward_in_chunk_to_at_least(Xapian::docid desired_did);

    public:
        ChertPostList(Xapian::Internal::RefCntPtr<const ChertDatabase> this_db_,
                      const string & term,
                      bool keep_reference);

        ~ChertPostList();

        bool jump_to(Xapian::docid desired_did);

        Xapian::doccount get_termfreq() const { return number_of_entries; }

        Xapian::docid get_docid() const { Assert(have_started); return did; }

        Xapian::termcount get_doclength() const;

        Xapian::termcount get_wdf() const { Assert(have_started); return wdf; }

        PositionList *read_position_list();

        PositionList * open_position_list() const;

        PostList * next(Xapian::weight w_min);

        PostList * skip_to(Xapian::docid desired_did, Xapian::weight w_min);

        bool at_end() const { return is_at_end; }

        std::string get_description() const;

        static void read_number_of_entries(const char ** posptr,
                                           const char * end,
                                           Xapian::doccount * number_of_entries_ptr,
                                           Xapian::termcount * collection_freq_ptr);
};

#endif /* OM_HGUARD_CHERT_POSTLIST_H */

---