backends/quartz/btree_base.h

Go to the documentation of this file.

/* btree_base.h: Btree base file implementation
 *
 * Copyright 1999,2000,2001 BrightStation PLC
 * Copyright 2002,2004,2007 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 OM_HGUARD_BTREE_BASE_H
#define OM_HGUARD_BTREE_BASE_H

#include <xapian/visibility.h>

#include "quartz_types.h"
#include "btree_util.h"

class XAPIAN_VISIBILITY_DEFAULT Btree_base {
    public:
        Btree_base();

        Btree_base(const std::string &name_, char ch);

        Btree_base(const Btree_base &other);

        ~Btree_base();

        bool read(const std::string &name, char ch, std::string &err_msg);

        uint4 get_revision() const { return revision; }
        uint4 get_block_size() const { return block_size; }
        uint4 get_root() const { return root; }
        uint4 get_level() const { return level; }
        uint4 get_bit_map_size() const { return bit_map_size; }
        uint4 get_item_count() const { return item_count; }
        uint4 get_last_block() const { return last_block; }
        bool get_have_fakeroot() const { return have_fakeroot; }
        bool get_sequential() const { return sequential; }

        void set_revision(uint4 revision_) {
            revision = revision_;
        }
        void set_block_size(uint4 block_size_) {
            block_size = block_size_;
        }
        void set_root(uint4 root_) {
            root = root_;
        }
        void set_level(uint4 level_) {
            level = level_;
        }
        void set_item_count(uint4 item_count_) {
            item_count = item_count_;
        }
        void set_have_fakeroot(bool have_fakeroot_) {
            have_fakeroot = have_fakeroot_;
        }
        void set_sequential(bool sequential_) {
            sequential = sequential_;
        }

        void write_to_file(const std::string &filename);

        /* Methods dealing with the bitmap */
        bool block_free_at_start(uint4 n) const;

        void free_block(uint4 n);

        uint4 next_free_block();

        bool block_free_now(uint4 n);

        void calculate_last_block();

        /* Only used with fake root blocks */
        void clear_bit_map();

        void commit();

        /* Used by Btree::check() */
        bool is_empty() const;

        void swap(Btree_base &other);

    private:
        void operator=(const Btree_base &other);

        void extend_bit_map();

        bool do_unpack_uint(const char **start, const char *end,
                            uint4 *dest, std::string &err_msg,
                            const std::string &basename,
                            const char *varname);

        /* Decoded values from the base file follow */
        uint4 revision;
        uint4 block_size;
        uint4 root;
        uint4 level;
        uint4 bit_map_size;
        uint4 item_count;
        uint4 last_block;
        bool have_fakeroot;
        bool sequential;

        /* Data related to the bitmap */
        uint4 bit_map_low;

        byte *bit_map0;

        byte *bit_map;
};

#endif /* OM_HGUARD_BTREE_BASE_H */

---