tpl_dynLhash.H

# ifndef TPL_DYNLHASH_H
# define TPL_DYNLHASH_H

# include <tpl_lhash.H>

using namespace Aleph;

namespace Aleph {

  template <typename Key, typename Record, class Cmp = Aleph::equal_to<Key>>
class DynLhashTable : public LhashTable<Key>
{
private:

  struct DLBucket : public LhashTable<Key>::Bucket
  {
    Record record;

    DLBucket(const Key & key, const Record & _record)
      : LhashTable<Key>::Bucket(key), record(_record) { /* Empty */ }

    
    DLBucket(const Key & key, Record && _record)
      : LhashTable<Key>::Bucket(key), record(std::move(_record)) { /* Empty */ }

    DLBucket(Key && key, const Record & _record)
      : LhashTable<Key>::Bucket(std::move(key)), record(_record) { /* Empty */ }
    
    DLBucket(Key && key, Record && _record)
      : LhashTable<Key>::Bucket(std::move(key)),
        record(std::move(_record)) { /* Empty */ }
  };

  static DLBucket * record_to_bucket(Record * rec)
  {
    DLBucket * ret_val = 0;
    size_t offset = (size_t) &ret_val->record;
    return (DLBucket*) (((size_t) rec) - offset);
  }

  class DLProxy
  {
    DynLhashTable & table;
    const Key &     key;
    DLBucket *      bucket;

  public:

    DLProxy(DynLhashTable & _table, const Key& _key)
      : table(_table), key(_key)
    {
      Record * record = table.search(key);
      bucket = record not_eq NULL ? record_to_bucket(record) : NULL;
    }

    operator const Record & () const 
      throw(std::exception, std::invalid_argument)
    {
      if (bucket == NULL)
        throw std::invalid_argument("access to unexisting entry");
    
      return bucket->record;
    }

    DLProxy& operator = (const Record& record) 
      throw(std::exception, std::bad_alloc) 
    {
      if (bucket != NULL)
        {
          bucket->record = record;
          return *this;
        }

      bucket = new DLBucket (key, record);
      table.LhashTable<Key>::insert(bucket);
      return *this;
    }

    DLProxy& operator = (const DLProxy& proxy) 
      throw(std::exception, std::bad_alloc, std::invalid_argument)
    {
      if (proxy.bucket == NULL)
        throw std::invalid_argument("access to unexisting entry");

      if (bucket != NULL)
        {
          bucket->record = proxy.bucket->record;
          return *this;
        }

      bucket = new DLBucket (key, proxy.bucket->record);
      table.LhashTable<Key>::insert(bucket);
      return *this;
    }
  };

public:

  typedef typename DynLhashTable<Key, Record>::Hash_Fct Hash_Fct;

  void swap(DynLhashTable & table) 
  {
    this->LhashTable<Key>::swap(table); 
  }

  DynLhashTable(Hash_Fct hash_fct, const size_t & len = DefaultPrime) 
    throw (std::exception, std::bad_alloc) : LhashTable<Key>(hash_fct, len)
  {
    // Empty 
  }

private:

  void copy(DynLhashTable & table)
  {
    for (typename LhashTable<Key>::Iterator it(table); it.has_curr(); it.next())
      {
        DLBucket * Bucket = (DLBucket*) it.get_curr();
        insert(Bucket->get_key(), Bucket->record);
      }
  }

public:

  DynLhashTable(const DynLhashTable & table)
    : LhashTable<Key>(table.hash_fct, table.len)
  {
    copy(table);
  }

  DynLhashTable(DynLhashTable && table)
  {
    swap(table);
  }

  DynLhashTable & operator = (const DynLhashTable & table)
  {
    if (this == &table)
      return *this;

    this->empty();
    copy(table);

    return *this;
  }

  DynLhashTable & operator = (DynLhashTable && table)
  {
    swap(table);
    return *this;
  }

private:

  Record * __insert(DLBucket * bucket)
  {
    LhashTable<Key>::insert(bucket);
    return &bucket->record;
  }

public:

  Record * insert(const Key & key, const Record & record)
    throw (std::exception, std::bad_alloc)
  {
    return __insert(new DLBucket (key, record));
  }

  Record * insert(const Key & key, Record && record = Record())
    throw (std::exception, std::bad_alloc)
  {
    return __insert(new DLBucket (key, std::move(record)));
  }

  Record * insert(Key && key, const Record & record)
    throw (std::exception, std::bad_alloc)
  {
    return __insert(new DLBucket (std::move(key), record));
  }

  Record * insert(Key && key, Record && record)
    throw (std::exception, std::bad_alloc)
  {
    return __insert(new DLBucket (std::move(key), std::move(record)));
  }

  Record * search(const Key & key)
  {
    DLBucket * bucket = (DLBucket*) LhashTable<Key>::search(key);
    return bucket != NULL ? &bucket->record : NULL;
  }

  void remove(Record * record)
  {
    DLBucket* bucket = record_to_bucket(record);
    LhashTable<Key>::remove(bucket);
    delete bucket;
  }

  DLProxy operator [] (const Key& key) const
    throw(std::exception, std::invalid_argument) 
  {
    return DLProxy ( const_cast<DynLhashTable&>(*this), key);
  }

  DLProxy operator [] (const Key& key) 
    throw(std::exception, std::bad_alloc, std::invalid_argument) 
  {
    return DLProxy (*this, key);
  }
};

} // end namespace Aleph

# endif // TPL_DYNLHASH_H