stack.h

Go to the documentation of this file.

#ifndef STACK_CLASS
#define STACK_CLASS
 
/*****************************************************************************\
*                                                                             *
*  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 <basis/array.h>
 
namespace structures {
 
 
template <class contents>
class stack
{
public:
  enum stack_kinds { BOUNDED, UNBOUNDED };
 
  stack(int elements = 0);
 
  stack(const stack &to_copy);
 
  ~stack();
 
  void reset();
 
  stack_kinds kind() const { return _kind; }
 
  basis::outcome push(const contents &element);
 
  basis::outcome pop();
 
  contents &top();
 
  basis::outcome acquire_pop(contents &to_stuff);
 
  int size() const;
 
  stack &operator =(const stack &to_copy);
 
  contents &operator [](int index);
 
  void invert();
 
  int elements() const;
 
private:
  basis::array<contents> _store;  
  stack_kinds _kind;  
  int _valid_fields;  
};
 
 
// implementations below...
 
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() == basis::common::OKAY) {}  // pop off elements until all are gone.
}
 
template <class contents>
int stack<contents>::elements() const { return _store.length(); }
 
template <class contents>
basis::outcome stack<contents>::push(const contents &element)
{
  if (_kind == BOUNDED) {
    if (_valid_fields >= elements()) return basis::common::IS_FULL;
    basis::outcome result = _store.put(_valid_fields, element);
    if (result != basis::common::OKAY) return basis::common::IS_FULL;
  } else _store.concatenate(element);
  _valid_fields++;
  return basis::common::OKAY;
}
 
template <class contents>
basis::outcome stack<contents>::pop()
{
  if (_valid_fields < 1) return basis::common::IS_EMPTY;
  if (_kind == UNBOUNDED)
    _store.zap(_store.length() - 1, _store.length() - 1);
  _valid_fields--;
  return basis::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>
basis::outcome stack<contents>::acquire_pop(contents &to_stuff)
{
  if (!_valid_fields) return basis::common::IS_EMPTY;
  to_stuff = _store[_valid_fields - 1];
  if (_kind == UNBOUNDED) _store.zap(elements()-1, elements()-1);
  _valid_fields--;
  return basis::common::OKAY;
}
 
} //namespace.
 
#endif