AnyHash.H

/* AnyHash.H */
/* $Id: AnyHash.H,v 2.3 2004/01/12 08:36:30 vlad Exp $ */

// May be included many times


#include <malloc.h>
#include <stdlib.h>

#include <mix/IntAr.H>

#if !defined(AnyType) || !defined(AnyHash) || !defined(AnyKeyType) || !defined(AnyItem2Key) || !defined(AnyKey2Hash) || !defined(AnyKeyCmp)
#error "All AnyType,AnyHash,AnyKeyType,AnyItem2Key,AnyKey2Hash,AnyKeyCmp macros must be defined."
#endif


class AnyHash
{
protected:

  DynAr     **hashItems;

  unsigned  hashBase;

  Logic     find_key (AnyKeyType key,
              unsigned& hash_i, unsigned& item_i) const {
    hash_i = AnyKey2Hash(key) % hashBase;
    if(NULL == hashItems[hash_i])
      return FALSE;
    DynAr   &hash_ar = *(hashItems[hash_i]);
    for(item_i = 0; item_i < hash_ar.count(); ++item_i)
      {
    AnyType&    item = *(AnyType*)(hash_ar.item_ptr(item_i));
    if(EQUAL == AnyKeyCmp(key, AnyItem2Key(item)))
      return TRUE;
      }
    return FALSE;
  }

public:

  AnyHash (unsigned base)
    : hashBase(base), hashItems(NULL)
  {
    if(0 == hashBase)
      Throw(ERROR__ZERO_COUNT);
    hashItems = (DynAr**) calloc(hashBase, sizeof(DynAr*));
    if(NULL == hashItems)
      Throw(ERROR__ALLOC);
  }

  virtual ~AnyHash () {
    unsigned    i;
    for(i = 0; i < hashBase; ++i)
      if(NULL != hashItems[i])
    delete hashItems[i];
    free(hashItems);
  }


  Logic     known_key (AnyKeyType key_value) const {
    unsigned    hash_i, item_i;
    return find_key(key_value, hash_i, item_i);
  }

  unsigned  count () const {
    unsigned    i, total = 0;
    for(i = 0; i < hashBase; ++i)
      if(NULL != hashItems[i])
    total += hashItems[i]->count();
    return total;
  }

  void      value_list (DynAr& vals) const {
    unsigned    i;
    for(i = 0; i < hashBase; ++i)
      if(NULL != hashItems[i])
    vals.addh(*(hashItems[i]));
  }


  AnyType&  hash_fetch (AnyKeyType key) {
    unsigned    hash_i, item_i;
    if(!find_key(key, hash_i, item_i))
      Throw(ERROR__DA_UNKNOWN_KEY);
    AnyType&    item = *(AnyType*)hashItems[hash_i]->item_ptr(item_i);
    return item;
  }

  AnyType   hash_get (AnyKeyType key) const {
    unsigned    hash_i, item_i;
    if(!find_key(key, hash_i, item_i))
      Throw(ERROR__DA_UNKNOWN_KEY);
    AnyType&    item = *(AnyType*)hashItems[hash_i]->item_ptr(item_i);
    return item;
  }

  AnyType&  operator[] (AnyKeyType key) {
    return hash_fetch(key);
  }

  AnyType   operator() (AnyKeyType key) const {
    return hash_get(key);
  }



  void      add (const AnyType& val) {
    unsigned    hash_i, item_i;
    if(find_key(AnyItem2Key(val), hash_i, item_i)){
      Throw(ERROR__DA_KNOWN_KEY);
    }else{
      if(NULL == hashItems[hash_i])
    hashItems[hash_i] = new DynAr(sizeof(AnyType),
                      DEFAULT_QUANT, START_VOLUME);
      DynAr &hash_ar = *(hashItems[hash_i]);
      hash_ar.addh();
      *(AnyType*)hash_ar.item_ptr(_last_) = val;
    }
  }

  void      put (const AnyType& val) {
    unsigned    hash_i, item_i;
    if(find_key(AnyItem2Key(val), hash_i, item_i)){
      DynAr &hash_ar = *(hashItems[hash_i]);
      *(AnyType*)hash_ar.item_ptr(item_i) = val;
    }else{
      if(NULL == hashItems[hash_i])
    hashItems[hash_i] = new DynAr(sizeof(AnyType),
                      DEFAULT_QUANT, START_VOLUME);
      DynAr &hash_ar = *(hashItems[hash_i]);
      hash_ar.addh();
      *(AnyType*)hash_ar.item_ptr(_last_) = val;
    }
  }


};


#undef AnyType
#undef AnyHash
#undef AnyKeyType
#undef AnyItem2Key
#undef AnyKey2Hash
#undef AnyKeyCmp