PtrAr.H

// PtrAr.H      $Revision: 1.6 $    $Date: 2005/02/16 09:47:29 $ 

// May be included many times

#include <mix/DynAr.H>


/*************************************************************
 * Dynamic Array of AnyType object (originally for pointers).
 *
 * This is macro-based template with two macro parameters.
 *
 * Example:
 *  #define PtrType     your-type   // void* for example
 *  #define PtrAr       your-type-array // VoidPtrAr f.e.
 *  #include <mix/PtrAr.H>  // generates class your-type-array and
 *                      // defines all methods of it as inline
 *
 * Optional macros:
 *  #define PtrArQuant  your-quant-of-growing
 *  #define PtrArVolume your-startup-volume
 *  #define PtrDestroyItem(item)   free(item->pArray);
 *
 * Usage:
 *  1) For a type you want to make array you must define
 *  two macros: PtrType and PtrAr as in example.
 *  2) Include after definitions this header file.
 *
 * You can define this way in one source many array types by
 * simple replication of usage rules. Do not worry about
 * previous macro definitions: they are undefined in PtrAr.H
 *************************************************************/

#ifndef PtrArQuant
#define PtrArQuant  DEFAULT_QUANT
#endif /* PtrArQuant */

#ifndef PtrArVolume
#define PtrArVolume START_VOLUME
#endif /* PtrArVolume */


class PtrAr : public DynAr
{
public:

  PtrAr (const PtrAr& pArray)
    :DynAr(pArray) {};
  PtrAr (unsigned quant = PtrArQuant,
     unsigned volume = PtrArVolume)
    :DynAr(sizeof(PtrType), quant, volume) {};

  PtrType&  fetch (unsigned i)
    {return *(PtrType*)item_ptr(i);};
  PtrType   get (unsigned i) const
    {return *(PtrType*)item_ptr(i);};

  void  insert (unsigned i, const PtrType val)
    {DynAr::insert(i, (const char*)&val);};

  void  addh (const PtrType val)  {DynAr::addh((const char*)&val);};
  void  addl (const PtrType val)  {DynAr::addl((const char*)&val);};

  void  addh (const PtrAr& pArray)  {DynAr::addh(pArray);};
  void  addl (const PtrAr& pArray)  {DynAr::addl(pArray);};

  PtrAr&    assign (const PtrAr& pArray)
    {DynAr::assign(pArray);  return *this;};

  // Synonyms
  PtrType&  operator[] (unsigned i)
    {return fetch(i);};
  PtrType   operator() (unsigned i) const
    {return get(i);};
  PtrAr&    operator= (const PtrAr& pArray)
    {return assign(pArray);};

protected:

#ifdef PtrDestroyItem
  virtual void  destruct_item (char* item){
    PtrType p = (PtrType)item;
    PtrDestroyItem(p);
  };
#endif /* PtrDestroyItem */

};

#undef PtrType
#undef PtrAr
#undef PtrArVolume
#undef PtrArQuant
#undef PtrDestroyItem