common/symtab.h

Go to the documentation of this file.

//
//      aegis - project change supervisor
//      Copyright (C) 1994, 2002-2008 Peter Miller.
//
//      This program is free software; you can redistribute it and/or modify
//      it under the terms of the GNU General Public License as published by
//      the Free Software Foundation; either version 3 of the License, or
//      (at your option) any later version.
//
//      This program is distributed in the hope that it will be useful,
//      but WITHOUT ANY WARRANTY; without even the implied warranty of
//      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//      GNU General Public License for more details.
//
//      You should have received a copy of the GNU General Public License
//      along with this program. If not, see
//      <http://www.gnu.org/licenses/>.
//

#ifndef COMMON_SYMTAB_H
#define COMMON_SYMTAB_H

#include <common/mem.h>
#include <common/nstring.h>

class string_list_ty; // forward
class nstring_list; // forward

class symtab_ty
{
public:
    ~symtab_ty();

    symtab_ty(int suggested_size = 5);

    size_t size() const { return hash_load; }

    bool empty() const { return (hash_load == 0); }

    void clear(void);

    void *query(string_ty *key) const;

    void *query(const nstring &key) const;

    void *query(const nstring_list &keys) const;

    string_ty *query_fuzzy(string_ty *key) const;

    nstring query_fuzzy(const nstring &key) const;

    void assign(string_ty *key, void *value);

    void assign(const nstring &key, void *value);

    void assign_push(string_ty *key, void *value);

    void assign_push(const nstring &key, void *value);

    void remove(string_ty *key);

    void remove(const nstring &key);

    void dump(const char *caption) const;

    void keys(string_list_ty *result) const;

    void keys(nstring_list &result) const;

    typedef void (*callback_t)(const symtab_ty *stp, const nstring &key,
        void *data, void *arg);

    void walk(callback_t func, void *arg) const;

    typedef void (*reaper_t)(void *);

    void set_reap(reaper_t func) { reap = func; }

    bool valid() const;

private:
    void split(void);

    reaper_t reap;

    struct row_t
    {
        row_t() : data(0), overflow(0) { }
        nstring key;
        void *data;
        row_t *overflow;
    };

    row_t **hash_table;

    str_hash_ty hash_modulus;

    str_hash_ty hash_mask;

    str_hash_ty hash_load;

    symtab_ty(const symtab_ty &);

    symtab_ty &operator=(const symtab_ty &);

    friend class symtab_iterator;
};

inline symtab_ty *
symtab_alloc(int n)
{
    // 37 files still use this function
    return new symtab_ty(n);
}

inline void
symtab_free(symtab_ty *stp)
{
    // 21 files still use this function
    delete stp;
}

inline void *
symtab_query(const symtab_ty *stp, string_ty *key)
{
    // 36 files still use this function
    return stp->query(key);
}

inline string_ty *
symtab_query_fuzzy(const symtab_ty *stp, string_ty *key)
{
    // 7 files still use this function
    return stp->query_fuzzy(key);
}

inline void
symtab_assign(symtab_ty *stp, string_ty *key, void *value)
{
    // 39 files still use this function
    stp->assign(key, value);
}

inline DEPRECATED void
symtab_assign_push(symtab_ty *stp, string_ty *key, void *value)
{
    stp->assign_push(key, value);
}

inline void
symtab_delete(symtab_ty *stp, string_ty *key)
{
    // 2 files still use this function
    stp->remove(key);
}

inline DEPRECATED void
symtab_dump(const symtab_ty *stp, const char *caption)
{
    stp->dump(caption);
}

inline DEPRECATED void
symtab_walk(const symtab_ty *stp, symtab_ty::callback_t func, void *arg)
{
    stp->walk(func, arg);
}

inline DEPRECATED void
symtab_keys(const symtab_ty *stp, string_list_ty *result)
{
    stp->keys(result);
}

#endif // COMMON_SYMTAB_H

---