---

hash.H

Go to the documentation of this file.

/*
 * Copyright 1997, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#ifndef HASH_NODE_INCLUDED
#define HASH_NODE_INCLUDED
#include "std/dllimpexp.H"
#include "std/thread_mutex.H"
#include "std/config.H"

template <class T>
class hash_node {
    private:
    long          _key;
    T             _data;
    hash_node<T> *_next;
    public:
        hash_node(long key, T value, hash_node<T> *next)
        {_key = key; _data = value; _next = next;}
    hash_node(const hash_node<T> &old)
        {_key = old._key; _data = old._data;
         _next = old._next ? new hash_node<T>(*old._next) : 0;}
        hash_node() {_key = 0; _data = T(); _next = 0;}

        hash_node<T> *next() const          { return _next; }
        T             data() const          { return _data; }
        long          key()  const          { return _key; }

        void          next(hash_node<T> *n) { _next = n; }
        void          data(T data)          { _data = data; }
        T            &data_ptr()            { return _data; }
};

#define cHASH const HASH
template <class T>
class ARRAY;

template <class T>
class HASH {
    private:
    int            _size;
        hash_node<T> **_table;
    int            _mask;
    int            _seq_val;
    int            _lastval;
    hash_node<T>  **table()              const { return _table; }
    int             hash(const long key) const;
    long            hash(const char *)   const;
    int             next_seq(long &key, T &data, hash_node<T> *&seq_elt,
                        int &seq_val)        const; // Returns 0 if done
        ThreadMutex mutex;

    public:
        HASH(int size);
    HASH(const HASH<T> &hash_table);
    ~HASH();
    void clear();
    // Add - returns 0 if doesn't already exist, 1 if it does
    int    add(long key, T data);
    int    add(const char *key, T data) {char *tmp; return add(key, data, tmp, 0);}
    int    add(const char *key, T data, char *&loc, int create_new=1);
    int    del(long key);
    int    del(char *key);
    T      find(long key) const {T *data = find_addr(key); return data ? *data : T();}
    T      find(char *key) const {T *data = find_addr(key); return data ? *data : T();};
    T     *find_addr(long key) const;
    T     *find_addr(const char *key) const;
    int    bfind(long key, T &data) const;

        void   get_items(ARRAY<long> &keys, ARRAY<T> &data) const;
};
#ifdef GLUE_NEEDS_TEMPLATES_IN_H_FILE
#include "hash.C"
#endif
#endif

---