amorph.cpp

Go to the documentation of this file.

#ifndef AMORPH_IMPLEMENTATION
#define AMORPH_IMPLEMENTATION

/*****************************************************************************\
*                                                                             *
*  Name   : amorph                                                            *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1989-$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 "amorph.h"

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

//#define DEBUG_AMORPH
  // uncomment to enable more testing, as well as complaints on errors.

#undef static_class_name
#define static_class_name() "amorph"
  // used in bounds_halt macro.

#undef AMO_ALERT
#ifdef DEBUG_AMORPH
  #include <basis/istring.h>
  #define AMO_ALERT(a, b, c) continuable_error(a, b, c)
  #define CHECK_FIELDS check_fields(func)
#else
  #define AMO_ALERT(a1, a2, a3) {}
  #define CHECK_FIELDS {}
#endif


template <class contents>
amorph<contents>::amorph(int elements)
: array<contents *>(elements, NIL, array<contents *>::SIMPLE_COPY
      | array<contents *>::EXPONE | array<contents *>::FLUSH_INVISIBLE),
  _fields_used(0)
{
  FUNCDEF("constructor");
  set_nil(0, elements - 1);
  CHECK_FIELDS;
}

template <class contents>
amorph<contents>::~amorph()
{
  FUNCDEF("destructor");
  CHECK_FIELDS;
  clear_all();
}

template <class contents>
void amorph<contents>::set_nil(int start, int end)
{
  for (int i = start; i <= end; i++)
    array<contents *>::put(i, (contents *)NIL);
}

template <class contents>
void amorph<contents>::check_fields(const char *where) const
{
  FUNCDEF("check_fields");
  int counter = 0;
  for (int i = 0; i < elements(); i++)
    if (array<contents *>::get(i)) counter++;
  if (_fields_used != counter)
    AMO_ALERT("amorph", isprintf("check_fields for %s", where).s(),
        "error in _fields_used count");
}

template <class contents>
void amorph<contents>::reset(int new_maximum)
{
  FUNCDEF("reset");
  CHECK_FIELDS;
  adjust(new_maximum);
  clear_all();
}

template <class contents>
void amorph<contents>::clear_all()
{
  FUNCDEF("clear_all");
  CHECK_FIELDS;
  for (int i = 0; i < elements(); i++) clear(i);
}

template <class contents>
outcome amorph<contents>::append(const contents *data)
{
  FUNCDEF("append");
  CHECK_FIELDS;
  adjust(elements() + 1);
  return put(elements() - 1, (contents *)data);
}

template <class contents>
const contents *amorph<contents>::get(int field) const
{
  FUNCDEF("get");
  CHECK_FIELDS;
  bounds_return(field, 0, elements() - 1, NIL);
  return array<contents *>::observe()[field];
}

template <class contents>
void amorph<contents>::adjust(int new_maximum)
{
  FUNCDEF("adjust");
  CHECK_FIELDS;
  if (new_maximum < 0) return;  // bad input here.
  int old_max = elements();
  if (new_maximum == old_max) return;  // nothing to do.
  if (new_maximum < old_max) {
    // removes the elements beyond the new size of the amorph.
    zap(new_maximum, old_max - 1);
    // we're done tuning it.
    return;
  }

  // we get to here if we need more space than we used to.
  int new_fields = new_maximum - old_max;

  array<contents *>::insert(old_max, new_fields);
  for (int i = old_max; i < new_maximum; i++) {
    array<contents *>::put(i, NIL);
  }
}

template <class contents>
outcome amorph<contents>::insert(int position, int lines_to_add)
{
  FUNCDEF("insert");
  CHECK_FIELDS;
  bounds_return(position, 0, elements(), common::OUT_OF_RANGE);
  outcome outcome = array<contents *>::insert(position, lines_to_add);
  if (outcome != common::OKAY) return common::OUT_OF_RANGE;
  set_nil(position, position + lines_to_add - 1);
  return common::OKAY;
}

template <class contents>
outcome amorph<contents>::zap(int start_index, int end_index)
{
  FUNCDEF("zap");
  CHECK_FIELDS;
  bounds_return(start_index, 0, elements() - 1, common::OUT_OF_RANGE);
  bounds_return(end_index, 0, elements() - 1, common::OUT_OF_RANGE);
  if (end_index < start_index) return common::OKAY;
  for (int i = start_index; i <= end_index;  i++) clear(i);
  outcome outcome = array<contents *>::zap(start_index, end_index);
  return (outcome==common::OKAY? common::OKAY : common::OUT_OF_RANGE);
}

template <class contents>
outcome amorph<contents>::put(int field, const contents *data)
{
  FUNCDEF("put");
  CHECK_FIELDS;
  bounds_return(field, 0, elements() - 1, common::OUT_OF_RANGE);
  contents *to_whack = acquire(field);
  WHACK(to_whack);
  if (data) {
    array<contents *>::access()[field] = (contents *)data;
    _fields_used++; 
  }
  return common::OKAY;
}

template <class contents>
int amorph<contents>::find_empty(outcome &outcome) const
{
  FUNCDEF("find_empty");
  CHECK_FIELDS;
  if (_fields_used == elements()) { outcome = common::IS_FULL; return 0; }
  for (int i = 0; i < elements(); i++)
    if (!array<contents *>::get(i)) { outcome = common::OKAY; return i; }
  AMO_ALERT("amorph", "empty", "_fields_used is incorrect");
  return common::IS_FULL;
}

template <class contents>
const contents *amorph<contents>::next_valid(int &field) const
{
  FUNCDEF("next_valid");
  CHECK_FIELDS;
  bounds_return(field, 0, elements() - 1, NIL);
  for (int i = field; i < elements(); i++)
    if (array<contents *>::get(i)) {
      field = i;
      return array<contents *>::get(i);
    }
  return NIL;
}

template <class contents>
outcome amorph<contents>::clear(int field)
{
  FUNCDEF("clear");
  CHECK_FIELDS;
  return this->put(field, NIL);
}

template <class contents>
contents *amorph<contents>::acquire(int field)
{
  FUNCDEF("acquire");
  CHECK_FIELDS;
  contents *to_return = borrow(field);
  if (to_return) {
    _fields_used--;
    array<contents *>::access()[field] = NIL;
  }
  return to_return;
}

template <class contents>
int amorph<contents>::find(const contents *to_locate, outcome &outcome)
{
  FUNCDEF("find");
  CHECK_FIELDS;
  if (!_fields_used) { outcome = common::NOT_FOUND; return 0; }
  for (int i = 0; i < elements(); i++) {
    if (array<contents *>::get(i) == to_locate) {
      outcome = common::OKAY;
      return i; 
    }
  }
  outcome = common::NOT_FOUND;
  return 0;
}

template <class contents>
contents *amorph<contents>::borrow(int field)
{
  FUNCDEF("borrow");
  CHECK_FIELDS;
  bounds_return(field, 0, elements() - 1, NIL);
  return array<contents *>::access()[field];
}

template <class contents>
void amorph<contents>::swap_contents(amorph<contents> &other)
{
  FUNCDEF("swap_contents");
  CHECK_FIELDS;
  int hold_fields = _fields_used;
  _fields_used = other._fields_used;
  other._fields_used = hold_fields;
  this->array<contents *>::swap_contents(other);
}

template <class contents>
void amorph_pack(byte_array &packed_form, const amorph<contents> &to_pack)
{
  basis::attach(packed_form, to_pack.elements());
  for (int i = 0; i < to_pack.elements(); i++) {
    to_pack.get(i)->pack(packed_form);
  }
}

template <class contents>
bool amorph_unpack(byte_array &packed_form, amorph<contents> &to_unpack)
{
  to_unpack.reset();
  int elem = 0;
  if (!basis::detach(packed_form, elem)) return false;
  for (int i = 0; i < elem; i++) {
    contents *to_add = new contents;
    if (!to_add->unpack(packed_form)) { delete to_add; return false; }
    to_unpack.append(to_add);
  }
  return true;
}

template <class contents>
void amorph_assign(amorph<contents> &to_assign,
    const amorph<contents> &to_copy)
{
  if (&to_assign == &to_copy) return;
  to_assign.clear_all();
  if (to_assign.elements() != to_copy.elements()) {
    to_assign.zap(0, to_assign.elements() - 1);
    to_assign.insert(0, to_copy.elements());
  }
  for (int i = 0; i < to_assign.elements(); i++) {
    if (to_copy.get(i)) to_assign.put(i, new contents(*to_copy.get(i)));
    else to_assign.put(i, (contents *)NIL);
  }
}

#undef static_class_name

#endif

---