mux/src/htab.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"

Include dependency graph for htab.cpp:

Go to the source code of this file.

Functions
void	hashreset (CHashTable *htab)
	Reset hash table statistics.
void *	hashfindLEN (const void *pKey, size_t nKey, CHashTable *htab)
	Look for a previously-added (Key, Data) pair in a hash table, and return its data pointer.
int	hashaddLEN (const void *pKey, size_t nKey, void *pData, CHashTable *htab)
	Add a new (Key, Data) pair to a hash table.
void	hashdeleteLEN (const void *pKey, size_t nKey, CHashTable *htab)
	Removes a (Key, Data) pair from a hash table.
void	hashflush (CHashTable *htab)
	Removes all (Key, Data) entries in a hash table.
bool	hashreplLEN (const void *str, size_t nStr, void *pData, CHashTable *htab)
void	hashreplall (const void *old, void *new0, CHashTable *htab)
void *	hash_firstentry (CHashTable *htab)
void *	hash_nextentry (CHashTable *htab)
void *	hash_firstkey (CHashTable *htab, int *nKeyLength, char **pKey)
void *	hash_nextkey (CHashTable *htab, int *nKeyLength, char **pKey)
bool	search_nametab (dbref player, NAMETAB *ntab, char *flagname, int *pflag)
NAMETAB *	find_nametab_ent (dbref player, NAMETAB *ntab, char *flagname)
void	display_nametab (dbref player, NAMETAB *ntab, char *prefix, bool list_if_none)
void	interp_nametab (dbref player, NAMETAB *ntab, int flagword, const char *prefix, const char *true_text, const char *false_text)
void	listset_nametab (dbref player, NAMETAB *ntab, int flagword, char *prefix, bool list_if_none)
	CF_HAND (cf_ntab_access)
Variables
struct {
void *   pData
char   aKey [LBUF_SIZE+125]
}	htab_rec
	Staging area for reads and writes into CHashTable.

---

Detailed Description

Table hashing routines.

Id

htab.cpp,v 1.30 2006/01/07 07:21:55 sdennis Exp

The functions here outsource most of their work to CHashTable. There are several reasons to use the functions here instead of using CHashTable directly: 1) they are briefer to use, 2) this interface predates CHashTable, 3) there are many references to these functions throughout the code, and 4) MUSH hardcoders are generally more familiar with this interface than with the CHashTable interface.

To replace them all would require rexamining the assumptions near every reference.

CHashTable is not aware of Keys -- only hashes of Keys. In fact, CHashTable could not tell you anything about the Keys kept within its records. It will give you all the records stored under a specific hash, but it leaves to its callers the small chore of looking in each record for a desired Key.

Definition in file htab.cpp.

---

Function Documentation

CF_HAND

(

cf_ntab_access

)

Definition at line 458 of file htab.cpp.

References cf_modify_bits(), name_table::minlen, minmatch(), mux_isspace, name_table::name, and name_table::perm.

{
    NAMETAB *np;
    char *ap;

    for (ap = str; *ap && !mux_isspace(*ap); ap++)
    {
        ; // Nothing.
    }
    if (*ap)
    {
        *ap++ = '\0';
    }

    while (mux_isspace(*ap))
    {
        ap++;
    }

    for (np = (NAMETAB *) vp; np->name; np++)
    {
        if (minmatch(str, np->name, np->minlen))
        {
            return cf_modify_bits(&(np->perm), ap, pExtra, nExtra, player, cmd);
        }
    }
    cf_log_notfound(player, cmd, "Entry", str);
    return -1;
}

void display_nametab	(	dbref	player,
		NAMETAB *	ntab,
		char *	prefix,
		bool	list_if_none
	)

Definition at line 353 of file htab.cpp.

References alloc_lbuf, check_access(), God, name_table::name, name_table::perm, safe_chr, and safe_str.

Referenced by do_list(), do_list_file(), and list_cmdswitches().

{
    NAMETAB *nt;
    bool got_one = false;
    char *buf = alloc_lbuf("display_nametab");
    char *bp = buf;

    safe_str(prefix, buf, &bp);
    for (nt = ntab; nt->name; nt++)
    {
        if (  God(player)
           || check_access(player, nt->perm))
        {
            safe_chr(' ', buf, &bp);
            safe_str(nt->name, buf, &bp);
            got_one = true;
        }
    }
    *bp = '\0';
    if (  got_one
       || list_if_none)
    {
        notify(player, buf);
    }
    free_lbuf(buf);
}

NAMETAB* find_nametab_ent	(	dbref	player,
		NAMETAB *	ntab,
		char *	flagname
	)

Definition at line 331 of file htab.cpp.

References check_access(), name_table::minlen, minmatch(), name_table::name, and name_table::perm.

Referenced by CF_HAND().

{
    NAMETAB *nt;

    for (nt = ntab; nt->name; nt++)
    {
        if (minmatch(flagname, nt->name, nt->minlen))
        {
            if (check_access(player, nt->perm))
            {
                return nt;
            }
        }
    }
    return NULL;
}

void* hash_firstentry

(

CHashTable *

htab

)

Definition at line 246 of file htab.cpp.

References CHashTable::FindFirst(), HF_FIND_END, and htab_rec.

Referenced by dbclean_CheckANHtoAT(), do_chanlist(), do_channelnuke(), do_listchannels(), FUNCTION(), helpindex_clean(), ReportMatchedTopics(), and save_comsystem().

{
    HP_HEAPLENGTH nRecord;
    HP_DIRINDEX iDir = htab->FindFirst(&nRecord, &htab_rec);
    if (iDir != HF_FIND_END)
    {
        return htab_rec.pData;
    }
    return NULL;
}

void* hash_firstkey	(	CHashTable *	htab,
		int *	nKeyLength,
		char **	pKey
	)

Definition at line 268 of file htab.cpp.

References CHashTable::FindFirst(), HF_FIND_END, and htab_rec.

Referenced by dbclean_RenumberAttributes(), and do_listcommands().

{
    HP_HEAPLENGTH nRecord;
    HP_DIRINDEX iDir = htab->FindFirst(&nRecord, &htab_rec);
    if (iDir != HF_FIND_END)
    {
        *nKeyLength = nRecord-sizeof(int *);
        *pKey = htab_rec.aKey;
        return htab_rec.pData;
    }
    *nKeyLength = 0;
    *pKey = NULL;
    return NULL;
}

void* hash_nextentry

(

CHashTable *

htab

)

Definition at line 257 of file htab.cpp.

References CHashTable::FindNext(), HF_FIND_END, and htab_rec.

Referenced by dbclean_CheckANHtoAT(), do_chanlist(), do_channelnuke(), do_listchannels(), FUNCTION(), helpindex_clean(), ReportMatchedTopics(), and save_comsystem().

{
    HP_HEAPLENGTH nRecord;
    HP_DIRINDEX iDir = htab->FindNext(&nRecord, &htab_rec);
    if (iDir != HF_FIND_END)
    {
        return htab_rec.pData;
    }
    return NULL;
}

void* hash_nextkey	(	CHashTable *	htab,
		int *	nKeyLength,
		char **	pKey
	)

Definition at line 283 of file htab.cpp.

References CHashTable::FindNext(), HF_FIND_END, and htab_rec.

Referenced by dbclean_RenumberAttributes(), and do_listcommands().

{
    HP_HEAPLENGTH nRecord;
    HP_DIRINDEX iDir = htab->FindNext(&nRecord, &htab_rec);
    if (iDir != HF_FIND_END)
    {
        *nKeyLength = nRecord-sizeof(int *);
        *pKey = htab_rec.aKey;
        return htab_rec.pData;
    }
    *nKeyLength = 0;
    *pKey = NULL;
    return NULL;
}

int hashaddLEN	(	const void *	pKey,
		size_t	nKey,
		void *	pData,
		CHashTable *	htab
	)

Add a new (Key, Data) pair to a hash table.

hashaddLEN() associates a variable-sized key with a pointer using a hash table. The pointer, pData, given to hashaddLEN() may be obtained again later by presenting the the same key to hashfindLEN(). The data given in (pKey, nKey) is saved, so the caller is free to reuse the Key buffer. While the value of pData is also saved, the data that pData points to is not.

This function requires that the Key does not already exist in the hash table. It may be necessary to use hashfindLEN() to insure this.

Parameters:

	pKey	Pointer to Key of (Key, Data) pair to add.
	nKey	Size (in bytes) of the above Key.
	pData	Pointer to Data part of (Key, Data) pair.
	htab	Hash Table.

Returns:

-1 for failure. 0 for success.

Definition at line 123 of file htab.cpp.

References HASH_ProcessBuffer(), htab_rec, and CHashTable::Insert().

Referenced by add_helpfile(), add_player_name(), MailList::AppendItem(), atr_match1(), cache_get(), cache_put(), CF_HAND(), commands_no_arg_add(), commands_one_arg_add(), commands_one_arg_cmdarg_add(), commands_two_arg_add(), commands_two_arg_argv_add(), commands_two_arg_argv_cmdarg_add(), commands_two_arg_cmdarg_add(), desc_addhash(), do_addcommand(), do_createchannel(), do_delcommand(), do_function(), find_wild_attrs(), flag_rename(), function_add(), functions_add(), fwdlist_set(), helpindex_read(), init_attrtab(), init_cmdtab(), init_flagtab(), init_logout_cmdtab(), init_powertab(), load_comsystem(), look_atrs1(), and pcache_find().

{
    if (  pKey == NULL
       || nKey <= 0)
    {
        return -1;
    }

    UINT32 nHash = HASH_ProcessBuffer(0, pKey, nKey);

    htab_rec.pData = pData;
    memcpy(htab_rec.aKey, pKey, nKey);
    size_t nRecord = nKey + sizeof(void *);
    htab->Insert((HP_HEAPLENGTH)nRecord, nHash, &htab_rec);
    return 0;
}

void hashdeleteLEN	(	const void *	pKey,
		size_t	nKey,
		CHashTable *	htab
	)

Removes a (Key, Data) pair from a hash table.

hashdeleteLEN() disassociates a variable-sized Key from its Data pointer by removing the (Key, Data) pair from the hash table and freeing any related storage. However, it is the caller's responsibility to free any memory that Data points to.

Parameters:

	pKey	The Key to remove.
	nKey	Size (in bytes) of the above Key.
	htab	Hash Table.

Returns:

None.

Definition at line 153 of file htab.cpp.

References CHashTable::Copy(), CHashTable::FindFirstKey(), CHashTable::FindNextKey(), HASH_ProcessBuffer(), HF_FIND_END, htab_rec, and CHashTable::Remove().

Referenced by add_helpfile(), cache_del(), cache_put(), delete_player_name(), desc_delhash(), do_addcommand(), do_channelnuke(), do_delcommand(), do_destroychannel(), do_flag(), fwdlist_clr(), pcache_trim(), MailList::RemoveAll(), MailList::RemoveItem(), and TrimCache().

{
    if (  pKey == NULL
       || nKey <= 0)
    {
        return;
    }

    UINT32 nHash = HASH_ProcessBuffer(0, pKey, nKey);

    HP_DIRINDEX iDir = htab->FindFirstKey(nHash);
    while (iDir != HF_FIND_END)
    {
        HP_HEAPLENGTH nRecord;
        htab->Copy(iDir, &nRecord, &htab_rec);
        size_t nTarget = nRecord - sizeof(int *);

        if (  nTarget == nKey
           && memcmp(pKey, htab_rec.aKey, nKey) == 0)
        {
            htab->Remove(iDir);
        }
        iDir = htab->FindNextKey(iDir, nHash);
    }
}

void* hashfindLEN	(	const void *	pKey,
		size_t	nKey,
		CHashTable *	htab
	)

Look for a previously-added (Key, Data) pair in a hash table, and return its data pointer.

Given a variable-sized Key, hashfindLEN() uses the associations previously created with hashaddLEN() to find and return the corresponding 'Data' part of a (Key, Data) pair, if it exists.

NULL is returned if the request is not valid or if the (Key, Data) pair is not found.

Parameters:

	pKey	Pointer to Key to find.
	nKey	Size (in bytes) of the above Key.
	htab	Hash Table.

Returns:

pData or NULL.

Definition at line 76 of file htab.cpp.

References CHashTable::Copy(), CHashTable::FindFirstKey(), CHashTable::FindNextKey(), HASH_ProcessBuffer(), HF_FIND_END, HF_FIND_FIRST, and htab_rec.

Referenced by add_player_name(), MailList::AppendItem(), atr_match1(), atr_str(), cache_del(), cache_get(), cache_put(), CF_HAND(), check_command(), commands_no_arg_add(), commands_one_arg_add(), commands_one_arg_cmdarg_add(), commands_two_arg_add(), commands_two_arg_argv_add(), commands_two_arg_argv_cmdarg_add(), commands_two_arg_cmdarg_add(), dbclean_CheckATtoANH(), decode_power(), delete_player_name(), desc_addhash(), desc_delhash(), do_addcommand(), do_command(), do_delcommand(), do_destroychannel(), do_flag(), do_function(), do_hook(), do_icmd(), do_listcommands(), do_quitprog(), find_flag(), find_power(), find_wild_attrs(), MailList::FirstItem(), flag_rename(), FUNCTION(), fwdlist_get(), handle_prog(), help_helper(), help_write(), helpindex_read(), init_flagtab(), init_powertab(), look_atrs1(), lookup_player(), mux_exec(), pcache_find(), process_command(), MailList::RemoveAll(), and select_channel().

{
    if (  pKey == NULL
       || nKey <= 0)
    {
        return NULL;
    }

    UINT32 nHash = HASH_ProcessBuffer(0, pKey, nKey);

    HP_DIRINDEX iDir = HF_FIND_FIRST;
    iDir = htab->FindFirstKey(nHash);
    while (iDir != HF_FIND_END)
    {
        HP_HEAPLENGTH nRecord;
        htab->Copy(iDir, &nRecord, &htab_rec);
        size_t nTarget = nRecord - sizeof(int *);

        if (  nTarget == nKey
           && memcmp(pKey, htab_rec.aKey, nKey) == 0)
        {
            return htab_rec.pData;
        }
        iDir = htab->FindNextKey(iDir, nHash);
    }
    return NULL;
}

void hashflush

(

CHashTable *

htab

)

Removes all (Key, Data) entries in a hash table.

The Hash Table is re-initialized from scratch and all storage is reclaimed. The resulting Hash Table is empty.

Parameters:

htab

Hash Table.

Returns:

None.

Definition at line 188 of file htab.cpp.

References CHashTable::Reset().

Referenced by atr_match(), look_atrs(), and parse_attrib_wild().

{
    htab->Reset();
}

void hashreplall	(	const void *	old,
		void *	new0,
		CHashTable *	htab
	)

Definition at line 227 of file htab.cpp.

References CHashTable::FindFirst(), CHashTable::FindNext(), HF_FIND_END, htab_rec, and CHashTable::Update().

Referenced by do_addcommand(), and do_delcommand().

{
    HP_HEAPLENGTH nRecord;
    for (  HP_DIRINDEX iDir = htab->FindFirst(&nRecord, &htab_rec);
           iDir != HF_FIND_END;
           iDir = htab->FindNext(&nRecord, &htab_rec))
    {
        if (htab_rec.pData == old)
        {
            htab_rec.pData = new0;
            htab->Update(iDir, nRecord, &htab_rec);
        }
    }
}

bool hashreplLEN	(	const void *	str,
		size_t	nStr,
		void *	pData,
		CHashTable *	htab
	)

Definition at line 198 of file htab.cpp.

References CHashTable::Copy(), CHashTable::FindFirstKey(), CHashTable::FindNextKey(), HASH_ProcessBuffer(), HF_FIND_END, htab_rec, and CHashTable::Update().

Referenced by add_player_name(), desc_addhash(), desc_delhash(), fwdlist_set(), and MailList::RemoveItem().

{
    if (  str == NULL
       || nStr <= 0)
    {
        return false;
    }

    UINT32 nHash = HASH_ProcessBuffer(0, str, nStr);

    HP_DIRINDEX iDir = htab->FindFirstKey(nHash);
    while (iDir != HF_FIND_END)
    {
        HP_HEAPLENGTH nRecord;
        htab->Copy(iDir, &nRecord, &htab_rec);
        size_t nTarget = nRecord - sizeof(int *);

        if (  nTarget == nStr
           && memcmp(str, htab_rec.aKey, nStr) == 0)
        {
            htab_rec.pData = pData;
            htab->Update(iDir, nRecord, &htab_rec);
            return true;
        }
        iDir = htab->FindNextKey(iDir, nHash);
    }
    return false;
}

void hashreset

(

CHashTable *

htab

)

Reset hash table statistics.

Each Hash Table maintains certain statistics regarding the type and number of requests they receive as well as the hash table's performance in responding to those requests. The hashreset() function allows callers to reset these statistics. Typically, this is done when the caller knows future access patterns are of more interest than past access paterns.

Parameters:

htab

Hash Table.

Returns:

None.

Definition at line 39 of file htab.cpp.

References CHashTable::ResetStats().

Referenced by helpindex_read(), and main().

{
    htab->ResetStats();
}

void interp_nametab	(	dbref	player,
		NAMETAB *	ntab,
		int	flagword,
		const char *	prefix,
		const char *	true_text,
		const char *	false_text
	)

Definition at line 384 of file htab.cpp.

References alloc_lbuf, check_access(), God, name_table::name, safe_chr, and safe_str.

Referenced by do_list().

{
    bool bFirst = true;
    char *buf = alloc_lbuf("interp_nametab");
    char *bp = buf;

    safe_str(prefix, buf, &bp);
    for (NAMETAB *nt = ntab; nt->name; nt++)
    {
        if (  God(player)
           || check_access(player, nt->perm))
        {
            if (!bFirst)
            {
                safe_chr(';', buf, &bp);
                bFirst = false;
            }
            safe_chr(' ', buf, &bp);
            safe_str(nt->name, buf, &bp);
            safe_str("...", buf, &bp);
            if ((flagword & nt->flag) != 0)
            {
                safe_str(true_text, buf, &bp);
            }
            else
            {
                safe_str(false_text, buf, &bp);
            }
        }
    }
    *bp = '\0';
    notify(player, buf);
    free_lbuf(buf);
}

void listset_nametab	(	dbref	player,
		NAMETAB *	ntab,
		int	flagword,
		char *	prefix,
		bool	list_if_none
	)

Definition at line 424 of file htab.cpp.

References alloc_lbuf, check_access(), name_table::flag, free_lbuf, God, name_table::name, notify, name_table::perm, safe_chr, and safe_str.

Referenced by list_attraccess(), list_cf_access(), list_cmdaccess(), and list_vattrs().

{
    char *buf = alloc_lbuf("listset_nametab");
    char *bp = buf;

    safe_str(prefix, buf, &bp);

    NAMETAB *nt = ntab;
    bool got_one = false;
    while (nt->name)
    {
        if (  ((flagword & nt->flag) != 0)
           && (  God(player)
              || check_access(player, nt->perm)))
        {
            safe_chr(' ', buf, &bp);
            safe_str(nt->name, buf, &bp);
            got_one = true;
        }
        nt++;
    }
    *bp = '\0';
    if (  got_one
       || list_if_none)
    {
        notify(player, buf);
    }
    free_lbuf(buf);
}

bool search_nametab	(	dbref	player,
		NAMETAB *	ntab,
		char *	flagname,
		int *	pflag
	)

Definition at line 303 of file htab.cpp.

References check_access(), name_table::flag, name_table::minlen, minmatch(), name_table::name, and name_table::perm.

Referenced by CF_HAND(), do_attribute(), do_global(), do_list(), do_list_file(), do_set(), FUNCTION(), get_obj_and_lock(), process_cmdent(), and process_command().

{
    NAMETAB *nt;
    for (nt = ntab; nt->name; nt++)
    {
        if (minmatch(flagname, nt->name, nt->minlen))
        {
            if (check_access(player, nt->perm))
            {
                *pflag = nt->flag;
                return true;
            }
            else
            {
                *pflag = -2;
                return false;
            }
        }
    }
    *pflag = -1;
    return false;
}

---

Variable Documentation

char aKey[LBUF_SIZE+125]

Definition at line 56 of file htab.cpp.

struct { ... } htab_rec [static]

Staging area for reads and writes into CHashTable.

The htab_rec structure is a fixed size, but only part of htab_rec is used. Since requests use variable-sized Keys, the portion of htab_rec used on any particular request is also variable-sized. pData is always present, but aKey may occupy as little as a single byte.

Referenced by hash_firstentry(), hash_firstkey(), hash_nextentry(), hash_nextkey(), hashaddLEN(), hashdeleteLEN(), hashfindLEN(), hashreplall(), and hashreplLEN().

void* pData

Definition at line 55 of file htab.cpp.

---