AnyAr.H

// AnyAr.H      $Revision: 1.12 $   $Date: 2002/10/16 17:37:47 $ 

// May be included many times

#include <stdio.h>
#include <mix/SortedAr.H>


/*************************************************************
 * Dynamic Sorted Array of AnyType object.
 *
 * This is macro-based template with two mandatory macro
 * parameters and an optional macro method.
 *
 * Format:
 *  // Existant your-type for example: dirent
 *  // Example:
 *  // struct Node {
 *  //   Node  *list;
 *  //   int   key;
 *  //   char  label[10];
 *  // };
 *  // #define AnyType Node
 *  #define AnyType       your-type
 *
 *  // Created your-type-array for example: Dirent
 *  // #define AnyAr   NodeAr
 *  #define AnyAr         your-type-array
 *
 *  // Optional macros:
 *
 *  // Macro method of comparation items x and y of AnyType.
 *  // Must return GREATER if x > y; EQUAL if x == y and LESS
 *  // if x > y.
 *  // #define AnyCmp(x,y)  COMPAR0(x.key - y.key)
 *  #define AnyCmp(x,y)   your-expression
 *
 *  // If you define the next two macros AnyAr::print_item(int i)
 *  // will be generated with needed printing specification.
 *  // #define AnyFormatSpec "\n%d: list=0x%x, key=%d, label=%s"
 *  // #define AnyPrintList  i, item.list, item.key, item.label
 *  #define AnyFormatSpec format-string-for-printf
 *  #define AnyPrintList  list-of-variables-for-printf
 *
 *  // If you don't want to use fprintf(stderr, FormatSpec, PrintSpec),
 *  // you can define any other messaging procedure:
 *  // #define AnyPrintf  printf(
 *  #define AnyPrintf   your-printf-like-proc
 *
 *  // If you define AnyPrintItem, AnyAr::print_item(int i) will
 *  // be generated with pointed expression.
 *  // #define AnyPrintItem item->print_contents()
 *  #define AnyPrintItem  expression
 *
 *  // quant and volume are measured by sizeof(AnyType)
 *  #define AnyArQuant  your-quant-of-growing
 *  #define AnyArVolume your-startup-volume
 *
 *  // Must be included after defining previous macros.
 *  #include <mix/AnyAr.H>  // generates class your-type-array
 *                  // and defines all methods of it as inline
 *
 * Usage:
 *  1) For a type you want to make array you must define
 *  two mandatory macros: AnyType and AnyAr as in example.
 *  2) You may also define AnyCmp(x,y) macro, so AnyAr::sort()
 *  method will order the array as you wish.  If you don't
 *  need sorting feature, AnyCmp will be created as dummy
 *  expression that always returns EQUAL.
 *  3) If you did not define AnyFormatSpec or AnyPrintList
 *  AnyAr::print_item(int i) will not be generated and will be 
 *  used DynAr::print_item(int i)
 *  4) If you defined AnyPrintItem, AnyFormatSpec and
 *  AnyPrintList are not used at all.
 *  5) 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 AnyAr.H
 *************************************************************/

#ifndef AnyCmp
/* Dummy comparation */
#define AnyCmp(x,y) (EQUAL)
#endif /* AnyCmp */

#ifndef AnyType
#error "AnyType must be defined as type of array's item"
#endif /* AnyType */

#ifndef AnyAr
#error "AnyAr must be defined as name of generated class of array"
#endif /* AnyAr */

#ifndef AnyArQuant
#define AnyArQuant  DEFAULT_QUANT
#endif /* AnyArQuant */

#ifndef AnyArVolume
#define AnyArVolume START_VOLUME
#endif /* AnyArVolume */

#ifndef AnyPrintf
#define AnyPrintf   fprintf(stderr,
#endif /* AnyPrintf */

class AnyAr : public SortedAr
{
public:

  AnyAr (const AnyAr& pArray)
    :SortedAr(pArray) {};
  AnyAr (unsigned quant = AnyArQuant,
     unsigned volume = AnyArVolume)
    :SortedAr(sizeof(AnyType), quant, volume) {};

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

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

  void  addh (const AnyType& val)  {SortedAr::addh((const char*)&val);};
  void  addl (const AnyType& val)  {SortedAr::addl((const char*)&val);};

  void  addh (const AnyAr& pArray)  {SortedAr::addh(pArray);};
  void  addl (const AnyAr& pArray)  {SortedAr::addl(pArray);};

  AnyAr&    assign (const AnyAr& pArray)
    {SortedAr::assign(pArray);  return *this;};

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

  // Compare between two elements
  virtual Compar    compare (const char* item1, const char* item2) const
    {return AnyCmp((*(AnyType*)item1), (*(AnyType*)item2));};

  // Return index of item or -1
  int       find_ascent (AnyType& item) const
    {return quick_find_ascent((const char*)&item);}
  int       find_descent (AnyType& item) const
    {return quick_find_descent((const char*)&item);}
  int       find (AnyType& item) const
    {return slow_find((const char*)&item);}

  // Return LESS or GREATER in case of out of range and EQUAL means
  // the L..R is found (L<=R)
  Compar    find_range_ascent (AnyType& value,
                   unsigned& L, unsigned& R) const { 
    return SortedAr::find_range_ascent((const char*)&value, L, R);
  }
  Compar    find_range_descent (AnyType& value,
                    unsigned& L, unsigned& R) const {
    return SortedAr::find_range_descent((const char*)&value, L, R);
  }

  // Smart print
#ifdef AnyPrintItem
  virtual void  print_item (unsigned i) const
    {AnyType&item=*(AnyType*)item_ptr(i);AnyPrintItem;}
#undef AnyPrintItem
#elif defined(AnyFormatSpec) && defined(AnyPrintList)
  virtual void  print_item (unsigned i) const
    {AnyType&item=*(AnyType*)item_ptr(i);
     AnyPrintf AnyFormatSpec, AnyPrintList);}
#undef AnyFormatSpec
#undef AnyPrintList
#endif

};

#undef AnyType
#undef AnyAr
#undef AnyCmp
#undef AnyArQuant
#undef AnyArVolume
#undef AnyPrintf