backends/flint/flint_postlist.h

Go to the documentation of this file.

/* flint_postlist.h: Postlists in flint databases
 *
 * Copyright 1999,2000,2001 BrightStation PLC
 * Copyright 2002 Ananova Ltd
 * Copyright 2002,2003,2004,2005,2007 Olly Betts
 * Copyright 2007 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_FLINT_POSTLIST_H
#define OM_HGUARD_FLINT_POSTLIST_H

#include <xapian/database.h>

#include "flint_types.h"
#include "flint_positionlist.h"
#include "leafpostlist.h"
#include "omassert.h"
#include "omdebug.h"

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

using namespace std;

class FlintCursor;
class FlintDatabase;

class PostlistChunkReader;
class PostlistChunkWriter;

class FlintPostListTable : public FlintTable {
    public:
        FlintPostListTable(string path_, bool readonly_)
            : FlintTable(path_ + "/postlist.", readonly_) { }

        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,
                PostlistChunkReader ** from, PostlistChunkWriter **to);

        static string make_key(const string & term, Xapian::docid did) {
            string key = pack_string_preserving_sort(term);
            key += pack_uint_preserving_sort(did);
            return key;
        }

        static string make_key(const string & term) {
            return pack_string_preserving_sort(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;
};

class FlintPostList : public LeafPostList {
   protected: // FlintModifiedPostList needs to access these.
        Xapian::Internal::RefCntPtr<const FlintDatabase> this_db;

        string tname;

        bool have_started;

        FlintPositionList positionlist;

    private:
        AutoPtr<FlintCursor> cursor;

        bool is_last_chunk;

        Xapian::docid first_did_in_chunk;

        Xapian::docid last_did_in_chunk;

        const char * pos;

        const char * end;

        Xapian::docid did;

        flint_doclen_t doclength;

        Xapian::termcount wdf;

        bool is_at_end;

        Xapian::doccount number_of_entries;

        FlintPostList(const FlintPostList &);

        void operator=(const FlintPostList &);

        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:
        FlintPostList(Xapian::Internal::RefCntPtr<const FlintDatabase> this_db_,
                      const string & tname);

        ~FlintPostList();

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

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

        Xapian::doclength get_doclength() const {
            DEBUGCALL(DB, Xapian::doclength, "FlintPostList::get_doclength", "");
            Assert(have_started);
            RETURN(static_cast<Xapian::doclength>(doclength));
        }

        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::termcount * number_of_entries_ptr,
                                           Xapian::termcount * collection_freq_ptr);
};

#endif /* OM_HGUARD_FLINT_POSTLIST_H */

---