persistance.C

Go to the documentation of this file.

/* Unconditionally enable persistance here. */
#define ENABLE_PERSISTANCE

#include "persistance.h"

PersistantStore :: PersistantStore() : current_view_(0), popping_(false)
{
}

int PersistantStore::add_checkpoint()
{
  assert(viewing_current());
  assert(!popping_);
  modifications_.push_back(ModifySet());
  births_.push_back(ModifySet());
  current_view_ = modifications_.size();
  return current_view_;
}

void PersistantStore::set_view(int idx) {
  assert(idx >= 0); assert(idx <= (signed)modifications_.size());
  assert(!popping_);
  current_view_ = idx;
}

void PersistantStore::set_view_current() {
  assert(!popping_);
  current_view_ = modifications_.size();
}


void PersistantStore::undo()
{
  assert(!popping_);
  assert(viewing_current());
  assert(logging());
  popping_ = true;

  assert(died_in_pop_.empty());
  for(ModifySet::iterator it = modifications_.back().begin();
      it != modifications_.back().end(); ++it) {
    if (died_in_pop_.count(*it) == 0) {
      (*it)->undo();
    }
  }

  died_in_pop_.clear();
  modifications_.pop_back();
  births_.pop_back();
  current_view_--;
  popping_ = false;
}

void PersistantStore::commit()
{
  assert(!popping_);
  assert(viewing_current());
  assert(logging());
  popping_ = true;

  assert(died_in_pop_.empty());
  for(ModifySet::iterator it = modifications_.back().begin();
      it != modifications_.back().end(); ++it) {
    if (died_in_pop_.count(*it) == 0) {
      (*it)->commit();
    }
  }
  for(ModifySet::iterator it = births_.back().begin();
      it != births_.back().end(); ++it) {
    if (died_in_pop_.count(*it) == 0) {
      (*it)->preincarnate();
    }
  }
  if (logging_after_pop()) {
    /* Copy all the modifications back, except those that correspond
       to things just born. */
    for(ModifySet::iterator it = modifications_.back().begin();
        it != modifications_.back().end(); ++it) {
      assert(births_.back().count(*it) == 0);
      if (births_[births_.size() - 2].count(*it) == 0) {
        modifications_[modifications_.size() - 2].insert(*it);
      }
    }
    /* Copy all the births back to keep track of them. */
    births_[births_.size() - 2].insert(
        births_.back().begin(), births_.back().end());
  }

  died_in_pop_.clear();
  modifications_.pop_back();
  births_.pop_back();
  current_view_--;
  popping_ = false;
}

int PersistantStore::get_time() const {
  return current_view_;
}

bool PersistantStore::viewing_current() const {
  return get_time() == (signed)modifications_.size();
}

bool PersistantStore::logging() const {
  return modifications_.size() >= 1;
}

bool PersistantStore::logging_after_pop() const {
  return modifications_.size() - 1 >= 1;
}


void PersistantStore::notify_access(PersistantObject* data)
{
  assert(!popping_);
  assert(viewing_current());
  /* if we are logging, then remember this change; otherwise, it doesn't
     matter. */
  if(logging()) {
    assert(births_.back().count(data) == 0);
    bool didinsert;
    didinsert = modifications_.back().insert(data).second;
    assert(didinsert);
  }
}

void PersistantStore::notify_born(PersistantObject* data)
{
  assert(!popping_);
  assert(viewing_current());
  if (logging()) {
    bool didinsert;
    didinsert = births_.back().insert(data).second;
    assert(didinsert);
  }
}

void PersistantStore::notify_died(PersistantObject* data)
{
  assert(viewing_current());
  if (logging()) {
    bool found;
    found = births_.back().erase(data);
    if (!found) {
      assert(popping_);
      if (logging_after_pop()) {
        found = births_[births_.size() - 2].erase(data);
        assert(found);
      } else {
        /* we're returning to an unlogged time: we have no birth certificates
           anymore. */
      }
      /* 'data' may be deallocated, but the pointer value is still valid,
         and it's illegal to add new objects during a pop. */
      died_in_pop_.insert(data);
    }
  }
}

---