AssocAr.H

/* AssocAr.H */
/* $Id: AssocAr.H,v 1.8 2004/04/19 07:37:14 vlad Exp $ */

// May be included many times

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


/*************************************************************

        Macro-expanded template of associative array.

  The first, you must declare name of target class:
  #define AssocAr            item_ar

  You must declare type of items too:
  typedef struct {
    float   key;
    int     c[2];
  }  item_t;
  #define AssocItemType      item_t

  We mean that item is a variable of type AssocItemType, that
  is item_t in this example.  Here you must specify one of
  item_t fields which is key nature.
  #define AssocKeyField      key

  Type of key value (see type of item_t::key here):
  #define AssocKeyType       float

  How to copy key value to AssocItemType?  I mean only temporal
  operation for item associative search only, not for storeage.  By
  default next code used:
  #define AssocKeyAssign     item.AssocKeyField=key
  But you may want to define for char[LEN+1] key type:
  #define AssocKeyAssign     strncpy(item.AssocKeyField,key,LEN);\
                 item.AssocKeyField[LEN]='\0'

  How to compare keys (in strcmp manner)?  We mean that there
  are two variables key1 (left) and key2 (right).  Result must
  be (-1) if key1<key2, (0) if key1==key2 or (1) if ite1>key2.
  #define AssocKeysCmp(key1,key2)     ((key1)-(key2))

  As usual you can use printing features:
  #define AssocPrintItem     item.print_self();
  or
  #define AssocFormatSpec    "key=%g c[2]={%d,%d}\n"
  #define AssocPrintList     item.key,item.c[0],item.c[1]

  *************************************************************/


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

#ifndef AssocItemType
#error "AssocItemType must be defined as type of item"
#endif /* AssocType */

#ifndef AssocKeysCmp
#error "AssocKeysCmp(key1,key2) must be defined in strcmp() manner"
#endif /* AssocCmp */

#ifndef AssocKeyField
#error "AssocKeyField must be field in AssocItemType structure"
#endif /* AssocKeyField */

#ifndef AssocKeyType
#error "AssocKeyType must be type of AssocKeyField"
#endif /* AssocKeyType */

#ifndef AssocArQuant
#define AssocArQuant    DEFAULT_QUANT
#endif /* AssocArQuant */

#ifndef AssocArVolume
#define AssocArVolume   START_VOLUME
#endif /* AssocArVolume */


class AssocAr : public SortedAr
{
protected:

  AssocItemType&    ref (unsigned i) const
    {return *(AssocItemType*)item_ptr(i);};

public:

  AssocAr (const AssocAr& pArray)
    :SortedAr(pArray) {};
  AssocAr (unsigned quant = AssocArQuant,
       unsigned volume = AssocArVolume)
    :SortedAr(sizeof(AssocItemType), quant, volume) {};

  // Base associative operations
  unsigned  key_to_index (AssocKeyType key) const
    {
      AssocItemType item;
#ifdef AssocKeyAssign
      AssocKeyAssign;
#else
      item.AssocKeyField = key;
#endif
      register int index = quick_find_ascent((const char*)&item);
      if(-1 == index)  Throw(ERROR__DA_UNKNOWN_KEY);
      return index;
    }
  AssocKeyType  index_to_key (unsigned index) const
    {return ref(index).AssocKeyField;}

  // Usual compare between two elements
  virtual Compar
    compare (const char* ptr1, const char* ptr2) const
      {
    AssocKeyType key1 = (*(AssocItemType*)ptr1).AssocKeyField;
    AssocKeyType key2 = (*(AssocItemType*)ptr2).AssocKeyField;
    return (Compar)AssocKeysCmp(key1, key2);
      }

  // Associative operations to get item by key
  AssocItemType&    assoc_fetch (AssocKeyType key)
    {return ref(key_to_index(key));};
  AssocItemType     assoc_get (AssocKeyType key) const
    {return ref(key_to_index(key));};

  // Synonymous
  AssocItemType&    operator[] (AssocKeyType key)
    {return assoc_fetch(key);};
  AssocItemType     operator() (AssocKeyType key) const
    {return assoc_get(key);};

  // Associative operation to add item (with unique key) to array
  void      add (const AssocItemType& val)
    {
      if(known_key(val.AssocKeyField)){
    Throw(ERROR__DA_KNOWN_KEY);
      }else{
    SortedAr::addh((const char*)&val);
    sort(ASCENT_ORDER);
      }
    }
  // Associative operation to add item (unique and non-unique key) to array
  void      put (const AssocItemType& val)
    {
      AssocKeyType key=val.AssocKeyField;
      if(known_key(key)){
    memcpy(item_ptr(key_to_index(key)), &val, sizeof(AssocItemType));
      }else{
    SortedAr::addh((const char*)&val);
    sort(ASCENT_ORDER);
      }
    }

  // Associative operation to add several items (with unique key) to
  // array.  Number of actually added items is returned.
  int       add (int val_n, const AssocItemType* vals)
    {
      if(NULL == vals)
    Throw(ERROR__NULL);

      int   val_i, added_n = 0;
      for(val_i = 0; val_i < val_n; ++val_i)
    if(!known_key(vals[val_i].AssocKeyField)){
      SortedAr::addh((const char*)(vals + val_i));
      ++added_n;
    }
      sort(ASCENT_ORDER);
      return added_n;
    }
  // Associative operation to add several items (unique and non-unique
  // key) to array
  void      put (int val_n, const AssocItemType* vals)
    {
      if(NULL == vals)
    Throw(ERROR__NULL);

      int   val_i;
      for(val_i = 0; val_i < val_n; ++val_i){
    AssocKeyType key = vals[val_i].AssocKeyField;
    if(known_key(key))
      memcpy(item_ptr(key_to_index(key)), vals + val_i,
         sizeof(AssocItemType));
    else
      SortedAr::addh((const char*)(vals + val_i));
      }
      sort(ASCENT_ORDER);
    }

  // Associative operation to find thether this key exist in array
  Logic     known_key (AssocKeyType key) const
    {
      AssocItemType item;
#ifdef AssocKeyAssign
      AssocKeyAssign;
#else
      item.AssocKeyField = key;
#endif
      register int index = quick_find_ascent((const char*)&item);
      return (-1 != index);
    }

  // Add usual operations to be this array accessible as AnyAr
  AssocItemType&    fetch (unsigned i)
    {return ref(i);};
  AssocItemType     get (unsigned i) const
    {return ref(i);};
  
  // Smart print
#ifdef AssocPrintItem
  virtual void  print_item (unsigned i) const
    {AssocItemType&item=ref(i);AssocPrintItem;}
#undef AssocPrintItem
#elif defined(AssocFormatSpec) && defined(AssocPrintList)
  virtual void  print_item (unsigned i) const
    {AssocItemType&item=ref(i);
     fprintf(stderr, AssocFormatSpec, AssocPrintList);}
#undef AssocFormatSpec
#undef AssocPrintList
#endif

};

#undef AssocAr
#undef AssocItemType
#undef AssocKeyField
#undef AssocKeyType
#undef AssocKeysCmp
#undef AssocKeyAssign