stack.cpp

Go to the documentation of this file.

#ifndef STACK_IMPLEMENTATION
#define STACK_IMPLEMENTATION

/*****************************************************************************\
*                                                                             *
*  Name   : stack                                                             *
*  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 "stack.h"

#include <basis/array.cpp>
#include <basis/guards.h>

template <class contents>
stack<contents>::stack(int elements)
: _store(elements >= 0? elements : 0),
  _kind(_store.length()? BOUNDED : UNBOUNDED),
  _valid_fields(0)
{}

template <class contents>
stack<contents>::stack(const stack &to_copy)
: _store(0), _valid_fields(0)
{ operator = (to_copy); }

template <class contents> stack<contents>::~stack() {}

template <class contents>
int stack<contents>::size() const { return _valid_fields; }

template <class contents>
void stack<contents>::reset()
{
  while (pop() == common::OKAY) {}  // pop off elements until all are gone.
}

template <class contents>
int stack<contents>::elements() const { return _store.length(); }

template <class contents>
outcome stack<contents>::push(const contents &element)
{
  if (_kind == BOUNDED) {
    if (_valid_fields >= elements()) return common::IS_FULL;
    outcome result = _store.put(_valid_fields, element);
    if (result != common::OKAY) return common::IS_FULL;
  } else _store.concatenate(element);
  _valid_fields++;
  return common::OKAY;
}

template <class contents>
outcome stack<contents>::pop()
{
  if (_valid_fields < 1) return common::IS_EMPTY;
  if (_kind == UNBOUNDED)
    _store.zap(_store.length() - 1, _store.length() - 1);
  _valid_fields--;
  return common::OKAY;
}

template <class contents>
contents &stack<contents>::top()
{ return _store[_valid_fields - 1]; }

template <class contents>
stack<contents> &stack<contents>::operator = (const stack &to_copy)
{
  if (this == &to_copy) return *this;
  reset();
  _kind = to_copy._kind;
  _store.reset(to_copy._store.length());
  for (int i = 0; i < to_copy._store.length(); i++)
    _store.put(i, to_copy._store[i]);
  _valid_fields = to_copy._valid_fields;
  return *this;
}

template <class contents>
void stack<contents>::invert()
{
  for (int i = 0; i < _store.length() / 2; i++) {
    contents hold = _store.get(i);
    int exchange_index = _store.length() - i - 1;
    _store.put(i, _store.get(exchange_index));
    _store.put(exchange_index, hold);
  }
}

template <class contents>
contents &stack<contents>::operator [](int index)
{
  if (index >= _valid_fields) index = -1;  // force a bogus return.
  return _store[index];
}

template <class contents>
outcome stack<contents>::acquire_pop(contents &to_stuff)
{
  if (!_valid_fields) return common::IS_EMPTY;
  to_stuff = _store[_valid_fields - 1];
  if (_kind == UNBOUNDED) _store.zap(elements()-1, elements()-1);
  _valid_fields--;
  return common::OKAY;
}

#endif

---