object_catalog.cpp

Go to the documentation of this file.

#ifndef OBJECT_CATALOG_IMPLEMENTATION_FILE
#define OBJECT_CATALOG_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : object_catalog                                                    *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1997-$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 "catalogable.h"
#include "node.h"
#include "object_catalog.h"
#include "safe_list.h"
#include "safe_node.h"

#include <basis/array.cpp>
#include <basis/log_base.h>
#include <basis/mutex.h>
#include <data_struct/unique_id.h>

#undef LOG
#define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger(), s)

namespace nodes {

class objcat_internal_safe_list : public safe_list
{
public:
  objcat_internal_safe_list() : safe_list() {}
};

class objcat_internal_write_iterator
{
public:
  objcat_internal_write_iterator(safe_list_write_iterator *to_hold)
          : _writ(to_hold) {}
  safe_list_write_iterator *_writ;
};


class objcat_catalogable_node : public safe_node
{
public:
  objcat_catalogable_node(catalogable *to_hold)
      : safe_node(), _cat(to_hold) {}
  ~objcat_catalogable_node() { WHACK(_cat); }

  catalogable &cat() { return *_cat; }
    // lets us get at the held catalogable object.

  void begin_write() { if (_cat) _cat->lock(); }
  void end_write() { if (_cat) _cat->unlock(); }

  void reset() { _cat = NIL; }
    // allows the internally held catalogable to be cleared so it's not
    // deleted.  better not call the catalogable conversion after this though.

private:
  catalogable *_cat;

  // forbidden.
  objcat_catalogable_node(const objcat_catalogable_node &);
  objcat_catalogable_node &operator =(const objcat_catalogable_node &);
};


// we can't move the list off the tail if it's already gotten there.
#define UPCAST_CAT \
  objcat_catalogable_node *catnode = NIL; \
  if (!_iter->_writ->is_tail()) \
    catnode = dynamic_cast<objcat_catalogable_node *>(_iter->_writ->access())

#define LOCK_CAT { UPCAST_CAT; if (catnode) catnode->begin_write(); }
#define UNLOCK_CAT { UPCAST_CAT; if (catnode) catnode->end_write(); }

objcat_iterator::objcat_iterator()
: _disabled(false), _iter(NIL) {}

objcat_iterator::~objcat_iterator() { WHACK(_iter); }

catalogable &objcat_locket::cat() { return _held->cat(); }

bool objcat_iterator::is_head() { return _iter->_writ->is_head(); }

bool objcat_iterator::is_tail() { return _iter->_writ->is_tail(); }

void objcat_iterator::next()
{ if (_disabled) return; _iter->_writ->next(); }

void objcat_iterator::previous()
{ if (_disabled) return; _iter->_writ->previous(); }

void objcat_iterator::jump_head()
{ if (_disabled) return; _iter->_writ->jump_head(); }

void objcat_iterator::jump_tail()
{ if (_disabled) return; _iter->_writ->jump_tail(); }

const catalogable *objcat_iterator::cat()
{
  if (!_iter->_writ->access()) return NIL;
  UPCAST_CAT;
  return catnode? &catnode->cat() : NIL;
}

objcat_locket *objcat_iterator::open_locket()
{
  if (_disabled) return NIL;
  UPCAST_CAT;
  if (!catnode) return NIL;
  _disabled = true;
  LOCK_CAT;
  objcat_locket *to_return = new objcat_locket(catnode, this);
  return to_return;
}

void objcat_iterator::close_locket(objcat_locket * &to_close)
{
  if (!to_close) return;
  UNLOCK_CAT;
  _disabled = false;
  WHACK(to_close);
}


objcat_isolater::objcat_isolater(objcat_catalogable_node *to_hold)
: _held(to_hold) {} 

objcat_isolater::~objcat_isolater() {}

catalogable &objcat_isolater::cat() { return _held->cat(); }


// hangs onto nodes that are tossed but which we must postpone deleting.
class defunct_nodes_pokey : public array<objcat_catalogable_node *>
{
};


object_catalog::object_catalog()
: _base(new objcat_internal_safe_list),
  _defunct(new defunct_nodes_pokey),
  _pokey_protector(new mutex)
{}

object_catalog::~object_catalog()
{
  clear_pokey();
  WHACK(_base);
  WHACK(_defunct);
  WHACK(_pokey_protector);
}

void object_catalog::clear_pokey()
{
  FUNCDEF("clear_pokey");
  auto_synchronizer l(*_pokey_protector);
    // ensure that only one thread cleans this list at a time.
  while (_defunct->length()) {
    objcat_catalogable_node *gone = _defunct->get(0);
    if (!gone)
      non_continuable_error(static_class_name(), func, "bad entry in defunct list");
    _defunct->zap(0, 0);
    gone->begin_write();  // ensure we have access to this.
    // we know that no one else can get this lock now; the node is already
    // not in our main list, so this is safe.
    gone->end_write();  // release access.
    WHACK(gone);
  }
}

outcome object_catalog::zap(objcat_iterator &where)
{
  if (where._disabled) return BAD_ITERATOR;  // can't play with it right now.
  safe_node *node_0 = _base->remove(*where._iter->_writ);
  if (!node_0) return BAD_ITERATOR;
  // move the node to the deleted node list.
  objcat_catalogable_node *the_node
      = dynamic_cast<objcat_catalogable_node *>(node_0);
  auto_synchronizer l(*_pokey_protector);
  *_defunct += the_node;
  return OKAY;
}

outcome object_catalog::insert(objcat_iterator &where,
    catalogable *to_add)
{
  if (where._disabled) return BAD_ITERATOR;
  if (!where._iter || !where._iter->_writ) return BAD_ITERATOR;
  objcat_catalogable_node *new_node = new objcat_catalogable_node(to_add);
//hmmm: make the safe list insert return a usable outcome.
  _base->insert(*where._iter->_writ, new_node);
  return OKAY;
}

bool object_catalog::empty(objcat_iterator &where)
{ return _base->empty(*where._iter->_writ); }

catalogable *object_catalog::acquire(const unique_int &to_find)
{
  clear_pokey();
  objcat_internal_write_iterator iter(_base->open_writer());
    // we lock the safe list here and don't release it until we're
    // sure we've got the item we want.
  for ( ; !iter._writ->is_tail(); iter._writ->next()) {
    // loop through the list to find our item to remove from the list.
    objcat_catalogable_node *cat = dynamic_cast<objcat_catalogable_node *>
        (iter._writ->access());
    if (!cat) continue;
    if (cat->cat().id() == to_find) {
      // get that list entry.
      safe_node *node_0 = _base->remove(*iter._writ);
      objcat_catalogable_node *bye
          = dynamic_cast<objcat_catalogable_node *>(node_0);
      // now release the lock on the whole list.
      _base->close_writer(iter._writ);

      // pull the catalogable out of the cat_node.
      catalogable *to_return = &bye->cat();

      // lock the node now.  we need to know that no one else is messing
      // with it for the moment.
      bye->begin_write();

      // remove the lock; it's out of the list already so we don't care about
      // future lockers.  they can't get at it any more since it's not in the
      // list now.
      bye->end_write();

      // at this point, we've safely gotten the item out of the list.  anyone
      // who had separated the item will have had to release the list lock
      // after they separated.  they might still have had the item locked up
      // to the point where our write succeeded on the object.  but after that,
      // they've not got the item lock anymore.
      bye->reset();  // clear the pointer so the catalogable isn't whacked.
      WHACK(bye);
      return to_return;
    }
  }
  _base->close_writer(iter._writ);
  return NIL;
}

int object_catalog::elements(objcat_iterator &finder)
{ return _base->elements(*finder._iter->_writ); }

outcome object_catalog::add(catalogable *to_add)
{
  clear_pokey();
  objcat_iterator *finding = find(to_add->id());
  if (finding) {
    iter_unlock(finding);
    delete to_add;
    return IN_USE;
  }
  objcat_internal_write_iterator iter(_base->open_writer(safe_list::TAIL));
  objcat_catalogable_node *new_node = new objcat_catalogable_node(to_add);
  _base->insert(*iter._writ, new_node);
  _base->close_writer(iter._writ);
  return OKAY;
}

objcat_iterator *object_catalog::find_head()
{
  clear_pokey();
  objcat_iterator *to_return = new objcat_iterator;
  to_return->_iter = new objcat_internal_write_iterator(_base->open_writer());
  return to_return;
}

objcat_iterator *object_catalog::find_tail()
{
  clear_pokey();
  objcat_iterator *to_return = new objcat_iterator;
  to_return->_iter = new objcat_internal_write_iterator
      (_base->open_writer(safe_list::TAIL));
  return to_return;
}

objcat_iterator *object_catalog::find(const unique_int &id)
{
  clear_pokey();
  objcat_iterator *to_return = new objcat_iterator;
  to_return->_iter = new objcat_internal_write_iterator(_base->open_writer());
  for ( ; !to_return->_iter->_writ->is_tail();
      to_return->_iter->_writ->next()) {
    objcat_catalogable_node *cat = dynamic_cast<objcat_catalogable_node *>
        (to_return->_iter->_writ->access());
    if (cat && (cat->cat().id() == id)) {
      return to_return;
    }
  }
  _base->close_writer(to_return->_iter->_writ);
  delete to_return;
  return NIL;
}

void object_catalog::iter_unlock(objcat_iterator * &to_unlock)
{
  if (!to_unlock) return;
//if disabled, we need to shriek about it.  perhaps a logging event?

  _base->close_writer(to_unlock->_iter->_writ);
  WHACK(to_unlock);
}

outcome object_catalog::zap_id(const unique_int &id)
{
  clear_pokey();
  catalogable *found = acquire(id);
  if (!found) return NOT_FOUND;
  WHACK(found);
  return OKAY;
}

void object_catalog::apply(apply_function *to_apply, void *data_link)
{
  clear_pokey();
  objcat_internal_write_iterator iter(_base->open_writer());
  for ( ; !iter._writ->is_tail(); iter._writ->next()) {
    objcat_catalogable_node *cat = dynamic_cast<objcat_catalogable_node *>
        (iter._writ->access());
    if (cat) {
      cat->begin_write();
      bool ret = to_apply(cat->cat(), data_link);
      cat->end_write();
      if (!ret) {
        _base->close_writer(iter._writ);
        return;
      }
    }
  }
  _base->close_writer(iter._writ);
}

objcat_isolater *object_catalog::separate(objcat_iterator * &to_separate)
{
  if (!to_separate || !to_separate->_iter->_writ->access()) return NIL;
  if (to_separate->_disabled) return NIL;
  objcat_catalogable_node *cat = dynamic_cast<objcat_catalogable_node *>
      (to_separate->_iter->_writ->access());
  cat->begin_write();
  objcat_isolater *to_return = new objcat_isolater(cat);
  iter_unlock(to_separate);
  return to_return;
}

void object_catalog::rejoin(objcat_isolater * &to_unlock)
{
  if (!to_unlock) return;
  to_unlock->_held->end_write();
  WHACK(to_unlock);
}

} // namespace.


#endif //OBJECT_CATALOG_IMPLEMENTATION_FILE

---