DynAr.H

// DynAr.H      $Revision: 2.20 $   $Date: 2003/11/24 13:31:17 $ 

#if !defined __DynAr_H

#define __DynAr_H

#include <mix/Exceptions.h>

#define DEFAULT_QUANT   10
#define START_VOLUME    10

#ifndef _last_
/* A'la Perl :-) */
#define _last_      ((unsigned)(-1))
#endif /* _last_ */


/*************************************************************
 * Dynamic Array of any elements
 *************************************************************/

class DynAr
{
protected:

  char      *tar;               // sequence of items
  unsigned  tSize;              // size of unit
  unsigned  tCount, tVolume, tQuant;    // in units

  void  extend_to (unsigned new_volume);
  void  extend_by (int add_volume);
  void  copy_from (const DynAr& dynar, unsigned i1, unsigned cnt);
  void  shift_by (unsigned i1, int offset);

  virtual void  destruct_item (char* /*item*/)  {};

public:

  DynAr (const DynAr& dynar);
  DynAr (unsigned size, unsigned quant, unsigned volume);
  virtual ~DynAr ();

  char* item_ptr (unsigned i) const;
  char* start_ptr () const; // item_ptr(0) without i-check

  void  clean ();
  void  clear_up ()  {clean();}

  void  pack ();

  unsigned  count () const;

  // Reserve memory for pointed number of items
  void  reserve (unsigned n);

  // Insert zero-filled item at i-th position
  void  insert (unsigned i);

  // Insert some new zero filled items to the array
  void  insertn (unsigned i, unsigned n);

  // Insert the whole array dynar to this one at i-th position
  void  insert (unsigned i, const DynAr& dynar);

  // Insert item at i-th position
  void  insert (unsigned i, const char* item);

  // Add zero-filled item to this array
  void  addh ();
  void  addl ();

  // Add item to this array
  void  addh (const char* item);
  void  addl (const char* item);

  // Add the whole array dynar to this
  void  addh (const DynAr& dynar);
  void  addl (const DynAr& dynar);

  // Add some new zero filled items to the array
  void  addhn (unsigned n);
  void  addln (unsigned n);

  // Delete i-th item from this
  void  remove (unsigned i);

  // Delete n-items from array starting from i-item.
  void  removen (unsigned i, unsigned n);

  DynAr&    assign (const DynAr& dynar);

  // Per byte exchange
  virtual void  exchange (unsigned i1, unsigned i2);

  // Find item and return index of it or -1 if search failed.
  virtual int   slow_find (const char* item) const;

  // For debug purpose
  virtual void  print_item (unsigned i) const;
  virtual void  print_contents () const;

};


/*************************************************************
 *
 * Inlined methods:
 *
 *************************************************************/

/*************************************************************
 * Add garbage-filled element to the end of array
 *************************************************************/
inline void
DynAr::addh ()
{
  insert(tCount);
}


/*************************************************************
 * Add garbage-filled element to the begin of array
 *************************************************************/
inline void
DynAr::addl ()
{
  insert(0);
}


/*************************************************************
 * Add element to the end of array
 *************************************************************/
inline void
DynAr::addh (const char* item)
{
  insert(tCount, item);
}


/*************************************************************
 * Add element to the begin of array
 *************************************************************/
inline void
DynAr::addl (const char* item)
{
  insert(0, item);
}


/*************************************************************
 * Returns pointer at the needed element of array
 *************************************************************/
inline char*
DynAr::item_ptr (unsigned i) const
{
  if(i == _last_)  i = tCount - 1;
  if(i >= tCount)
    Throw(ERROR__DA_OUT_OF_RANGE);

  return tar + i * tSize;
}


/*************************************************************
 * Returns pointer at the first element of array
 *************************************************************/
inline char*
DynAr::start_ptr () const
{
  return tar;
}


/*************************************************************
 * Returns count of elements
 *************************************************************/
inline unsigned
DynAr::count () const
{
  return tCount;
}


/*************************************************************
 * Pack array to minimum needed size
 *************************************************************/
inline void
DynAr::pack ()
{
  extend_to(tCount);
}


#endif  // DynAr.H