array.h

Go to the documentation of this file.

#ifndef ARRAY_CLASS
#define ARRAY_CLASS

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


template <class contents>
class array
{
public:
  enum special_flags {
    NO_SPECIAL_MODES = 0x0,  
    SIMPLE_COPY = 0x1,  
    EXPONENTIAL_GROWTH = 0x2,  
    EXPONE = EXPONENTIAL_GROWTH,  
    FLUSH_INVISIBLE = 0x4  
  };

  array(int number = 0, const contents *init = NIL,
          u_short flags = EXPONENTIAL_GROWTH | FLUSH_INVISIBLE);

  array(const array<contents> &copy_from);

  ~array();  

  void reset(int number = 0, const contents *initial_contents = NIL);
    /*< If "initial_contents" is not NIL, then it must contain an array of
    "contents" with at least "number" objects in it.  If it is NIL, then
    the size of the array is changed but the contents are not.  note that
    any pre-existing elements that were previously out of range might still
    have their prior contents; the newly available elements are not necessarily
    "blank".  thus, before using them, ensure you store appropriate elements
    in those positions. */

  array &operator = (const array<contents> &copy_from);

  inline int length() const { return _active_length; }

  inline int last() const { return _active_length - 1; }

  inline u_short flags() const { return _flags; }

  inline bool exponential() const { return _flags & EXPONENTIAL_GROWTH; }

  inline bool simple() const { return _flags & SIMPLE_COPY; }

  const contents &get(int index) const;

  contents &use(int index);

  inline const contents &operator [] (int index) const { return get(index); }
  inline contents &operator [] (int index) { return use(index); }

  outcome put(int index, const contents &to_put);

  array concatenation(const array &to_concatenate) const;
  array concatenation(const contents &to_concatenate) const;

  array &concatenate(const array &to_concatenate);
  array &concatenate(const contents &to_concatenate);
  array &concatenate(const contents *to_concatenate, int length);

  inline array operator + (const array &to_cat) const
          { return concatenation(to_cat); }
  inline array operator + (const contents &to_concatenate) const
          { return concatenation(to_concatenate); }
  inline array &operator += (const array &to_concatenate)
          { return concatenate(to_concatenate); }
  inline array &operator += (const contents &to_concatenate)
          { return concatenate(to_concatenate); }

  inline const contents *observe() const { return _offset; }

  inline contents *access() { return _offset; }

  void swap_contents(array<contents> &other);

  void snarf(array &new_contents);

  array subarray(int start, int end) const;

  outcome insert(int index, int new_indices);

  outcome overwrite(int index, const array &write_with, int count = -1);

  outcome stuff(int length, contents *to_stuff) const;

  outcome resize(int new_size, common::how_to_copy way = common::NEW_AT_END);

  outcome zap(int start, int end);

  outcome shrink();

  outcome retrain(int new_size, const contents *to_copy);

  enum shift_directions { TO_LEFT, TO_RIGHT };

  void shift_data(shift_directions where);

  // These are gritty internal information methods and should not be used
  // except by appropriately careful code.
  inline int internal_real_length() const { return _real_length; }
  inline int internal_offset() const { return int(_offset - _mem_block); }
  inline const contents *internal_block_start() const { return _mem_block; }
  inline contents *internal_block_start() { return _mem_block; }
  inline contents * const *internal_offset_mem() const { return &_offset; }

private:
  int _active_length; 
  int _real_length;  // the real number of objects that can be stored.
  contents *_mem_block;  
  contents *_offset;  
  u_short _flags;  

  outcome allocator_reset(int initial_elements, int blocking);

};

class int_array : public array<int>
{
public:
  int_array(int number = 0, const int *initial_contents = 0)
      : array<int>(number, initial_contents, SIMPLE_COPY | EXPONE) {}

};

class double_array : public array<double>
{
public:
  double_array(int len = 0, double *data = NIL)
      : array<double>(len, data, SIMPLE_COPY | EXPONE) {}
  double_array(const array<double> &to_copy) : array<double>(to_copy) {}
};

#endif

---