glass_cursor.h

Go to the documentation of this file.

/* Copyright 1999,2000,2001 BrightStation PLC
 * Copyright 2002,2003,2004,2006,2007,2008,2009,2010,2012,2013,2014,2016 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_GLASS_CURSOR_H
#define OM_HGUARD_GLASS_CURSOR_H

#include "glass_defs.h"

#include "alignment_cast.h"
#include "omassert.h"

#include <algorithm>
#include <cstring>
#include <string>
using std::string;

#define BLK_UNUSED uint4(-1)

namespace Glass {

class Cursor {
    // Prevent copying
    Cursor(const Cursor &);
    Cursor & operator=(const Cursor &);

    char * data;

  public:
    Cursor() : data(0), c(-1), rewrite(false) { }

    ~Cursor() { destroy(); }

    uint8_t * init(unsigned block_size) {
        if (data && refs() > 1) {
            --refs();
            data = NULL;
        }
        if (!data)
            data = new char[block_size + 8];
        refs() = 1;
        set_n(BLK_UNUSED);
        rewrite = false;
        c = -1;
        return reinterpret_cast<uint8_t*>(data + 8);
    }

    const uint8_t * clone(const Cursor & o) {
        if (data != o.data) {
            destroy();
            data = o.data;
            ++refs();
        }
        return reinterpret_cast<uint8_t*>(data + 8);
    }

    void swap(Cursor & o) {
        std::swap(data, o.data);
        std::swap(c, o.c);
        std::swap(rewrite, o.rewrite);
    }

    void destroy() {
        if (data) {
            if (--refs() == 0)
                delete [] data;
            data = NULL;
            rewrite = false;
        }
    }

    uint4 & refs() const {
        Assert(data);
        return *alignment_cast<uint4*>(data);
    }

    uint4 get_n() const {
        Assert(data);
        return *alignment_cast<uint4*>(data + 4);
    }

    void set_n(uint4 n) {
        Assert(data);
        // Assert(refs() == 1);
        *alignment_cast<uint4*>(data + 4) = n;
    }

    const uint8_t * get_p() const {
        if (rare(!data)) return NULL;
        return reinterpret_cast<uint8_t*>(data + 8);
    }

    uint8_t * get_modifiable_p(unsigned block_size) {
        if (rare(!data)) return NULL;
        if (refs() > 1) {
            char * new_data = new char[block_size + 8];
            std::memcpy(new_data, data, block_size + 8);
            --refs();
            data = new_data;
            refs() = 1;
        }
        return reinterpret_cast<uint8_t*>(data + 8);
    }

    int c;

    bool rewrite;
};

}

class GlassTable;

class GlassCursor {
    GlassCursor(const GlassCursor &);

    GlassCursor & operator=(const GlassCursor &);

    void rebuild();

  protected:
    bool is_positioned;

    bool is_after_end;

  private:
    enum { UNREAD, UNREAD_ON_LAST_CHUNK, UNCOMPRESSED, COMPRESSED } tag_status;

  protected:
    const GlassTable * B;

  private:
    Glass::Cursor * C;

    unsigned long version;

    int level;

    void get_key(string * key) const;

  public:
    explicit GlassCursor(const GlassTable *B,
                         const Glass::Cursor * C_ = NULL);

    GlassCursor * clone() const {
        return new GlassCursor(B, C);
    }

    ~GlassCursor();

    string current_key;

    string current_tag;

    bool read_tag(bool keep_compressed = false);

    bool next();

    bool find_entry(const string &key);

    bool find_exact(const string &key);

    void find_entry_lt(const string &key);

    bool find_entry_ge(const string &key);

    void to_end() { is_after_end = true; }

    bool after_end() const { return is_after_end; }

    const GlassTable * get_table() const { return B; }
};

class MutableGlassCursor : public GlassCursor {
  public:
    explicit MutableGlassCursor(GlassTable *B_) : GlassCursor(B_) { }

    bool del();
};

#endif /* OM_HGUARD_GLASS_CURSOR_H */