persistance-noop.h

Go to the documentation of this file.

#ifndef PERSISTANCE_NOOP_H
#define PERSISTANCE_NOOP_H

#include <vector>
#include <list>
#include "hash_set.h"
#include "hash_map.h"
#include <cassert>

struct PersistantStore {
  static PersistantStore& hackery() {
    return *(PersistantStore*)0x31337;
  }
};

template <class Datum> class PersistantData {
  private:
    Datum d;

  public:
    PersistantData(PersistantStore& store, const Datum& initial)
      : d(initial) { }

    const Datum& operator *() const {
      return d;
    }
    Datum& access() {
      return d;
    }
};

template <class Datum, size_t N> class PersistantArray {
  private:
    Datum data_[N];

  public:
    PersistantArray(PersistantStore& store) { }
    PersistantArray(PersistantStore& store, const Datum& initial) {
      for(size_t i = 0; i < N; i++) {
    data_[i] = initial;
      }
    }

    const Datum& operator[] (size_t i) const {
      assert(i < N);
      return data_[i];
    }

    Datum& access (size_t i) {
      assert(i < N);
      return data_[i];
    }

    /* \todo Not portable! */
    typedef __gnu_cxx::__normal_iterator<Datum*, PersistantArray> iterator;
    typedef __gnu_cxx::__normal_iterator<const Datum*, PersistantArray>
      const_iterator;
    typedef Datum* pointer;

    operator iterator() { return begin(); }
    operator const_iterator() const { return begin(); }

    iterator begin() { return iterator(data_); }
    const_iterator begin() const { return const_iterator(data_); }
    iterator end() { return iterator(data_ + N); }
    const_iterator end() const { return const_iterator(data_ + N); }

    iterator operator+ (size_t i) {
      assert(i <= N);
      return iterator(data_ + i);
    }
    const_iterator operator+ (size_t i) const {
      assert(i <= N);
      return const_iterator(data_ + i);
    }
};

template <class Datum> class PersistantVector : public std::vector<Datum> {
  private:
    typedef std::vector<Datum> super;
  public:
    typedef typename super::size_type size_type;
    typedef typename super::reference reference;

    reference access(size_type i) {
      return operator[](i);
    }

    PersistantVector(PersistantStore& store) { }
    PersistantVector(PersistantStore& store, size_type n) : super(n) { }
    PersistantVector(PersistantStore& store, size_type n, const Datum& t)
      : super(n, t) { }

    template <class InputIterator>
    PersistantVector(PersistantStore& store, InputIterator begin,
                     InputIterator end) : super(begin, end) { }

    reference access_front() {
      return access(0);
    }
    reference access_back() {
      return access(super::size() - 1);
    }

    PersistantStore& get_store() const { return PersistantStore::hackery(); }

  private:
    /* illegal */
    PersistantVector(const PersistantVector&);
    PersistantVector& operator=(const PersistantVector&);
};


template <class Datum> class PersistantMemoryPool {
  public:
    PersistantMemoryPool(PersistantStore& store) { }

    virtual ~PersistantMemoryPool() {
      for(typename datumset::iterator it = allocated_.begin();
      it != allocated_.end(); ++it) {
    delete *it;
      }
      /* datumset is cleared automatically */
    }

    void mark_allocated(Datum *key) {
      allocated_.insert(key);
    }

    void mark_deleted(Datum *key) {
      bool found = allocated_.erase(key);
      assert(found);
      delete key;
    }

  private:
    struct hashfcn {
      unsigned long long operator()(Datum *d) const { return (unsigned long long)d; }
    };
    typedef hashers::hash_set<Datum*,hashfcn> datumset;

    datumset allocated_;

  private:
    /* illegal */
    PersistantMemoryPool(const PersistantMemoryPool&);
    PersistantMemoryPool& operator = (const PersistantMemoryPool&);
};

template <class Value>
class PersistantList : public std::list<Value> {
  public:
    struct iterator : public std::list<Value>::iterator {
      typedef typename std::list<Value>::iterator super;
      public:
        iterator() { }
        iterator(typename std::list<Value>::iterator it) : super(it) { }

        Value& access() const {
      return super::operator*();
        }
        const Value& operator*() const {
      return super::operator*();
        }
    };

    PersistantList(PersistantStore& store) { }

    PersistantStore& get_store() const { return PersistantStore::hackery(); }
};


template <class Key, class HashFcn = hashers::hash<Key>,
      class EqualKey = std::equal_to<Key> >
class PersistantHashSet : public hashers::hash_set<Key, HashFcn, EqualKey> {
  public:
    PersistantHashSet(PersistantStore& store) { }
    PersistantStore& get_store() const { return PersistantStore::hackery(); }

  private:
    /* illegal */
    PersistantHashSet(const PersistantHashSet&);
    PersistantHashSet& operator = (const PersistantHashSet&);
};

template <class Key, class Value, class HashFcn = hashers::hash<Key>,
      class EqualKey = std::equal_to<Key> >
class PersistantHashMap : public hashers::hash_map<Key, Value, HashFcn, EqualKey> {
  typedef hashers::hash_map<Key, Value, HashFcn, EqualKey> super;
  public:
    typedef typename super::iterator iterator;

    PersistantHashMap(PersistantStore& store) { }

    std::pair<iterator, bool> insert(const Key& k, const Value& v) {
      return super::insert(std::make_pair(k, v));
    }

    PersistantStore& get_store() const { return PersistantStore::hackery(); }

  private:
    /* illegal */
    PersistantHashMap(const PersistantHashMap&);
    PersistantHashMap& operator = (const PersistantHashMap&);
};
#endif

---