safe_list.h

Go to the documentation of this file.

#ifndef SAFE_LIST_CLASS
#define SAFE_LIST_CLASS

/*****************************************************************************\
*                                                                             *
*  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 "node_dll.h"

#include <basis/object_base.h>

// forward.
class reader_writer_lock;

namespace nodes {

// forward.
class list;
class safe_list_read_iterator;
class safe_list_write_iterator;
class safe_node;


class NODES_CLASS_STYLE safe_list : public virtual object_base
{
public:
  safe_list();
  ~safe_list();

  IMPLEMENT_CLASS_NAME("safe_list");

  // the iterators can be created at the head or the tail of the list.  the
  // following provide notational convenience but are based on the list
  // positions from common (in basis/definitions).
  typedef common::list_positions iterator_positions;
  static const iterator_positions HEAD;  
  static const iterator_positions TAIL;  

  safe_list_read_iterator *open_reader(iterator_positions where = HEAD);

  safe_list_write_iterator *open_writer(iterator_positions where = HEAD);

  void close_reader(safe_list_read_iterator * &to_close);
  void close_writer(safe_list_write_iterator * &to_close);

  bool empty(safe_list_read_iterator &hook);

  bool empty(safe_list_write_iterator &hook);

  int elements(safe_list_read_iterator &hook);

  int elements(safe_list_write_iterator &hook);

  void zap(safe_list_write_iterator &writer);

  void insert(safe_list_write_iterator &writer, safe_node *to_insert);

  safe_node *remove(safe_list_write_iterator &writer);

private:
  friend class safe_list_read_iterator;
  friend class safe_list_write_iterator;
  list *_storage;  
  reader_writer_lock *_gate_keeper;  

  // not permitted.
  safe_list(const safe_list &);
  safe_list &operator =(const safe_list &);
};



class NODES_CLASS_STYLE safe_list_read_iterator
{
public:
  void next();  
  void previous();  

  const safe_node *observe() const;  

  bool is_head();  
  bool is_tail();  

  void jump_head();  
  void jump_tail();  

  ~safe_list_read_iterator();

protected:
  safe_list_read_iterator(const safe_list &mgr,
          safe_list::iterator_positions where);

private:
  friend class safe_list;
  const safe_list &_manager;  
  void *_hidden_iterator;  

  // disallowed functions.
  safe_list_read_iterator(const safe_list_read_iterator &to_copy);
  safe_list_read_iterator &operator =(const safe_list_read_iterator &to_copy);
};



class NODES_CLASS_STYLE safe_list_write_iterator {
public:
  void next();  
  void previous();  

  safe_node *access();  

  bool is_head();  
  bool is_tail();  

  void jump_head();  
  void jump_tail();  

  ~safe_list_write_iterator();

protected:
  safe_list_write_iterator(const safe_list &mgr,
          safe_list::iterator_positions where);

private:
  friend class safe_list;
  const safe_list &_manager;  
  void *_hidden_iterator;  

  // disallowed functions.
  safe_list_write_iterator(const safe_list_write_iterator &to_copy);
  safe_list_write_iterator &operator =(const safe_list_write_iterator &to_copy);
};

} // namespace.

#endif

---