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 */