safe_list.cpp

Go to the documentation of this file.

#ifndef SAFE_LIST_IMPLEMENTATION_FILE
#define SAFE_LIST_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : safe_list                                                         *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1998-$now By Author.  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 is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "list.h"
#include "node.h"
#include "safe_list.h"
#include "safe_node.h"

#include <basis/function.h>
#include <basis/mutex.h>
#include <mechanisms/rw_lock.h>

namespace nodes {

// initialize our class constants to the proper values.
const safe_list::iterator_positions safe_list::HEAD = common::HEAD;
const safe_list::iterator_positions safe_list::TAIL = common::TAIL;

// the real_safe_node hangs onto a safe_node from our user and allows us to
// treat it like a real node by storing it in lists.

class real_safe_node : public node
{
public:
  safe_node *_snode;  // holds what our users give us.

  real_safe_node(safe_node *to_hold) : _snode(to_hold) {}
  ~real_safe_node() { WHACK(_snode); }
};


// gives us our real iterator object to work with instead of the ugly hidden
// thing.
#define CAST_BACK \
  list::iterator &iter = *(list::iterator *)_hidden_iterator

// turns the current iterator position into the real_safe_node it represents.
// note that this might be NIL.
#define UPCAST_NODE \
  real_safe_node *rsn = dynamic_cast<real_safe_node *>(iter.access())


safe_list_read_iterator::safe_list_read_iterator(const safe_list &mgr,
    safe_list::iterator_positions where)
: _manager(mgr), _hidden_iterator(NIL)
{
  _hidden_iterator = new list::iterator(_manager._storage, NIL);
  CAST_BACK;
  if (where == safe_list::HEAD)
    iter = _manager._storage->head();
  else
    iter = _manager._storage->tail();
}

safe_list_read_iterator::~safe_list_read_iterator()
{
  CAST_BACK;
  delete &iter;
  _hidden_iterator = NIL;
}

void safe_list_read_iterator::jump_head()
{
  CAST_BACK;
  iter.jump_head();
}

void safe_list_read_iterator::jump_tail()
{
  CAST_BACK;
  iter.jump_tail();
}

void safe_list_read_iterator::next()
{
  CAST_BACK;
  iter++;
}

void safe_list_read_iterator::previous()
{
  CAST_BACK;
  iter--;
}

const safe_node *safe_list_read_iterator::observe() const
{
  CAST_BACK;
  UPCAST_NODE;
  return rsn? rsn->_snode : NIL;
}

bool safe_list_read_iterator::is_head()
{
  CAST_BACK;
  return iter.is_head();
}

bool safe_list_read_iterator::is_tail()
{
  CAST_BACK;
  return iter.is_tail();
}


safe_list_write_iterator::safe_list_write_iterator(const safe_list &mgr,
    safe_list::iterator_positions where)
: _manager(mgr), _hidden_iterator(NIL)
{
  _hidden_iterator = new list::iterator(_manager._storage, NIL);
  CAST_BACK;
  if (where == safe_list::HEAD)
    iter = _manager._storage->head();
  else
    iter = _manager._storage->tail();
}

safe_list_write_iterator::~safe_list_write_iterator()
{
  CAST_BACK;
  delete &iter;
  _hidden_iterator = NIL;
}

void safe_list_write_iterator::jump_head()
{
  CAST_BACK;
  iter.jump_head();
}

void safe_list_write_iterator::jump_tail()
{
  CAST_BACK;
  iter.jump_tail();
}

void safe_list_write_iterator::next()
{
  CAST_BACK;
  iter++;
}

void safe_list_write_iterator::previous()
{
  CAST_BACK;
  iter--;
}

safe_node *safe_list_write_iterator::access()
{
  CAST_BACK;
  UPCAST_NODE;
  return rsn? rsn->_snode : NIL;
}

bool safe_list_write_iterator::is_head()
{
  CAST_BACK;
  return iter.is_head();
}

bool safe_list_write_iterator::is_tail()
{
  CAST_BACK;
  return iter.is_tail();
}


safe_list::safe_list()
: _storage(new list),
  _gate_keeper(new reader_writer_lock)
{}

safe_list::~safe_list()
{
  WHACK(_storage);
  WHACK(_gate_keeper);
}

bool safe_list::empty(safe_list_read_iterator &formal(it))
{ return _storage->empty(); }

bool safe_list::empty(safe_list_write_iterator &formal(it))
{ return _storage->empty(); }

int safe_list::elements(safe_list_read_iterator &formal(it))
{ return _storage->elements(); }

int safe_list::elements(safe_list_write_iterator &formal(it))
{ return _storage->elements(); }

safe_list_read_iterator *safe_list::open_reader(iterator_positions where)
{
  _gate_keeper->begin_read();
  return new safe_list_read_iterator(*this, where);
}

safe_list_write_iterator *safe_list::open_writer(iterator_positions where)
{
  _gate_keeper->begin_write();
  return new safe_list_write_iterator(*this, where);
}

void safe_list::close_reader(safe_list_read_iterator * &to_close)
{
  WHACK(to_close);
  _gate_keeper->end_read();
}

void safe_list::close_writer(safe_list_write_iterator * &to_close)
{
  WHACK(to_close);
  _gate_keeper->end_write();
}

#define CAST_WRITER \
  list::iterator &iter = *(list::iterator *)writer._hidden_iterator

safe_node *safe_list::remove(safe_list_write_iterator &writer)
{
  CAST_WRITER;
  real_safe_node *ogre = dynamic_cast<real_safe_node *>(_storage->remove(iter));
  if (!ogre) return NIL;
  safe_node *to_return = ogre->_snode;
  ogre->_snode = NIL;
  delete ogre;
  return to_return;
}

void safe_list::zap(safe_list_write_iterator &writer)
{
  CAST_WRITER;
  _storage->zap(iter);
}

void safe_list::insert(safe_list_write_iterator &writer, safe_node *to_insert)
{
  CAST_WRITER;
  real_safe_node *to_add = new real_safe_node(to_insert);
  _storage->insert(iter, to_add);
}

} // namespace

#endif //SAFE_LIST_IMPLEMENTATION_FILE

---