amorph.h

Go to the documentation of this file.

#ifndef AMORPH_CLASS
#define AMORPH_CLASS

/*****************************************************************************\
*                                                                             *
*  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 "object_packers.h"

#include <basis/astring.h>
#include <basis/functions.h>
#include <basis/contracts.h>
#include <basis/guards.h>


namespace structures {

template <class contents>
class amorph : private basis::array<contents *>
{
public:
  amorph(int elements = 0);

  ~amorph();

  int elements() const { return this->length(); }

  int valid_fields() const { return _fields_used; }

  void adjust(int new_max);

  void reset(int new_maximum = 0);

  basis::outcome put(int field, const contents *data);

  basis::outcome append(const contents *data);

  basis::outcome operator += (const contents *data) { return append(data); }


  const contents *get(int field) const;

  contents *borrow(int field);

  const contents *operator [] (int field) const { return get(field); }
  contents *operator [] (int field) { return borrow(field); }

  contents *acquire(int field);

  basis::outcome clear(int field);

  void clear_all();

  basis::outcome zap(int start, int end);

  basis::outcome insert(int position, int lines_to_add);

  int find_empty(basis::outcome &o) const;

  const contents *next_valid(int &field) const;

  int find(const contents *to_locate, basis::outcome &o);

  void swap_contents(amorph<contents> &other);

private:
  int _fields_used;  

  void check_fields(const char *where) const;

  void set_nil(int start, int end);
    // Puts NIL in the indices between start and end.
  // not to be used: amorphs should not be copied because it is intended that
  // they support storing heavyweight objects that either have no copy
  // constructors or have high-cost copy constructors.
  amorph(const amorph &to_copy) {}  
  amorph &operator = (const amorph &to_copy) { return *this; }
};


// these extensions are phrased as macros to avoid including the headers
// necessary for compiling them.  to use them, just put the macro name in
// the file where the template is needed.



template <class contents>
void amorph_assign(amorph<contents> &to_assign,
    const amorph<contents> &to_copy);



template <class contents>
void amorph_pack(basis::byte_array &packed_form, const amorph<contents> &to_pack);

template <class contents>
bool amorph_unpack(basis::byte_array &packed_form, amorph<contents> &to_unpack);

template <class contents>
int amorph_packed_size(const amorph<contents> &to_pack);

// implementation for longer methods...

//#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/astring.h>
  #define AMO_ALERT(a, b, c) basis::throw_error(basis::astring(a), basis::astring(func), basis::astring(b) + " -- " + c)
  #define CHECK_FIELDS check_fields(func)
#else
  #define AMO_ALERT(a1, a2, a3) {}
  #define CHECK_FIELDS { if (!func) {} }
#endif


template <class contents>
amorph<contents>::amorph(int elements)
: basis::array<contents *>(elements, NIL, basis::array<contents *>::SIMPLE_COPY
      | basis::array<contents *>::EXPONE | basis::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++)
    basis::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 (basis::array<contents *>::get(i)) counter++;
  if (_fields_used != counter) {
    AMO_ALERT("amorph", basis::a_sprintf("check_fields for %s", where),
        "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>
basis::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 basis::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;

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

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

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

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

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

template <class contents>
basis::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--;
    basis::array<contents *>::access()[field] = NIL;
  }
  return to_return;
}

template <class contents>
int amorph<contents>::find(const contents *to_locate, basis::outcome &o)
{
  FUNCDEF("find");
  CHECK_FIELDS;
  if (!_fields_used) { o = basis::common::NOT_FOUND; return 0; }
  for (int i = 0; i < elements(); i++) {
    if (basis::array<contents *>::get(i) == to_locate) {
      o = basis::common::OKAY;
      return i; 
    }
  }
  o = basis::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 basis::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->basis::array<contents *>::swap_contents(other);
}

template <class contents>
int amorph_packed_size(const amorph<contents> &to_pack)
{
  int parts_size = 0;
  for (int i = 0; i < to_pack.elements(); i++) {
    const contents *current = to_pack.get(i);
    if (current) parts_size += current->packed_size();
  }
  return PACKED_SIZE_INT32 + parts_size;
}

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

template <class contents>
bool amorph_unpack(basis::byte_array &packed_form, amorph<contents> &to_unpack)
{
  to_unpack.reset();
  int elem = 0;
  if (!structures::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

} //namespace.

#endif