runtime_history.cpp

Go to the documentation of this file.

#ifndef RUNTIME_HISTORY_IMPLEMENTATION_FILE
#define RUNTIME_HISTORY_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : runtime_history                                                   *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1990-$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 "occurrence.h"
#include "runtime_history.h"

#include <basis/mutex.h>
#include <data_struct/static_memory_gremlin.h>

#undef AUTO_LOCK
#define AUTO_LOCK \
  auto_synchronizer l(*_lock)

class occurrence_list : public array<occurrence>
{
public:
  occurrence_list() : array<occurrence>() {}
};


runtime_history::runtime_history(int maximum_length)
: _bound(maximum_length),
  _lock(new mutex),
  _occurrences(new occurrence_list)
{
  if (_bound < 0) _bound = DEFAULT_RUNTIME_HISTORY;
}

runtime_history::~runtime_history()
{
  WHACK(_occurrences);
  WHACK(_lock);
}

void runtime_history::lock() { _lock->lock(); }

void runtime_history::unlock() { _lock->unlock(); }

int runtime_history::max_items() const { AUTO_LOCK; return _bound; }

void runtime_history::set_max_items(int new_max)
{
  AUTO_LOCK;
  if (new_max < 0) _bound = DEFAULT_RUNTIME_HISTORY;
  _bound = new_max;
}

int runtime_history::elements() const
{ AUTO_LOCK; return _occurrences->length(); }

void runtime_history::pack(byte_array &packed_form) const
{ AUTO_LOCK; basis::pack(packed_form, *_occurrences); }

bool runtime_history::unpack(byte_array &packed_form)
{ AUTO_LOCK; return basis::unpack(packed_form, *_occurrences); }

void runtime_history::add_outcome(const occurrence &happening)
{
  AUTO_LOCK;
  if (!happening.valid()) return;  // to hell with recording that garbage.
  if (_occurrences->length() >= _bound)
    _occurrences->zap(0, 0);
  *_occurrences += happening;
}

SAFE_STATIC_CONST(occurrence, runtime_history::empty_junk_occurrence, )
  // a blank occurrence.

const occurrence &runtime_history::get(int index)
{
  AUTO_LOCK;
  bounds_return(index, 0, _occurrences->length() - 1, empty_junk_occurrence());
  return _occurrences->get(index);
}


#endif //RUNTIME_HISTORY_IMPLEMENTATION_FILE

---