通讯编程

开发平台：
Visual C++

Hash.3：源码内容
							'"
'" Copyright (c) 1989-1993 The Regents of the University of California.
'" Copyright (c) 1994-1996 Sun Microsystems, Inc.
'"
'" See the file "license.terms" for information on usage and redistribution
'" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
'" 
'" RCS: @(#) $Id: Hash.3,v 1.10.2.1 2003/07/18 16:56:24 dgp Exp $
'" 
.so man.macros
.TH Tcl_Hash 3 "" Tcl "Tcl Library Procedures"
.BS
.SH NAME
Tcl_InitHashTable, Tcl_InitCustomHashTable, Tcl_InitObjHashTable, Tcl_DeleteHashTable, Tcl_CreateHashEntry, Tcl_DeleteHashEntry, Tcl_FindHashEntry, Tcl_GetHashValue, Tcl_SetHashValue, Tcl_GetHashKey, Tcl_FirstHashEntry, Tcl_NextHashEntry, Tcl_HashStats - procedures to manage hash tables
.SH SYNOPSIS
.nf
fB#include <tcl.h>fR
.sp
fBTcl_InitHashTablefR(fItablePtr, keyTypefR)
.sp
fBTcl_InitCustomHashTablefR(fItablePtr, keyType, typePtrfR)
.sp
fBTcl_InitObjHashTablefR(fItablePtrfR)
.sp
fBTcl_DeleteHashTablefR(fItablePtrfR)
.sp
Tcl_HashEntry *
fBTcl_CreateHashEntryfR(fItablePtr, key, newPtrfR)
.sp
fBTcl_DeleteHashEntryfR(fIentryPtrfR)
.sp
Tcl_HashEntry *
fBTcl_FindHashEntryfR(fItablePtr, keyfR)
.sp
ClientData
fBTcl_GetHashValuefR(fIentryPtrfR)
.sp
fBTcl_SetHashValuefR(fIentryPtr, valuefR)
.sp
char *
fBTcl_GetHashKeyfR(fItablePtr, entryPtrfR)
.sp
Tcl_HashEntry *
fBTcl_FirstHashEntryfR(fItablePtr, searchPtrfR)
.sp
Tcl_HashEntry *
fBTcl_NextHashEntryfR(fIsearchPtrfR)
.sp
CONST char *
fBTcl_HashStatsfR(fItablePtrfR)
.SH ARGUMENTS
.AS Tcl_HashSearch *searchPtr
.AP Tcl_HashTable *tablePtr in
Address of hash table structure (for all procedures but
fBTcl_InitHashTablefR, this must have been initialized by
previous call to fBTcl_InitHashTablefR).
.AP int keyType in
Kind of keys to use for new hash table.  Must be either
TCL_STRING_KEYS, TCL_ONE_WORD_KEYS, TCL_CUSTOM_TYPE_KEYS,
TCL_CUSTOM_PTR_KEYS, or an integer value greater than 1.
.AP Tcl_HashKeyType *typePtr in
Address of structure which defines the behaviour of the hash table.
.AP "CONST char" *key in
Key to use for probe into table.  Exact form depends on
fIkeyTypefR used to create table.
.AP int *newPtr out
The word at fI*newPtrfR is set to 1 if a new entry was created
and 0 if there was already an entry for fIkeyfR.
.AP Tcl_HashEntry *entryPtr in
Pointer to hash table entry.
.AP ClientData value in
New value to assign to hash table entry.  Need not have type
ClientData, but must fit in same space as ClientData.
.AP Tcl_HashSearch *searchPtr in
Pointer to record to use to keep track of progress in enumerating
all the entries in a hash table.
.BE
.SH DESCRIPTION
.PP
A hash table consists of zero or more entries, each consisting of a
key and a value.  Given the key for an entry, the hashing routines can
very quickly locate the entry, and hence its value. There may be at
most one entry in a hash table with a particular key, but many entries
may have the same value.  Keys can take one of four forms: strings,
one-word values, integer arrays, or custom keys defined by a
Tcl_HashKeyType structure (See section fBTHE TCL_HASHKEYTYPE
STRUCTUREfR below). All of the keys in a given table have the same
form, which is specified when the table is initialized.
.PP
The value of a hash table entry can be anything that fits in the same
space as a ``char *'' pointer.  Values for hash table entries are
managed entirely by clients, not by the hash module itself.  Typically
each entry's value is a pointer to a data structure managed by client
code.
.PP
Hash tables grow gracefully as the number of entries increases, so
that there are always less than three entries per hash bucket, on
average. This allows for fast lookups regardless of the number of
entries in a table.
.PP
The core provides three functions for the initialization of hash
tables, Tcl_InitHashTable, Tcl_InitObjHashTable and
Tcl_InitCustomHashTable.
.PP
fBTcl_InitHashTablefR initializes a structure that describes a new
hash table.  The space for the structure is provided by the caller,
not by the hash module.  The value of fIkeyTypefR indicates what
kinds of keys will be used for all entries in the table. All of the
key types described later are allowed, with the exception of
fBTCL_CUSTOM_TYPE_KEYSfR and fBTCL_CUSTOM_PTR_KEYSfR.
.PP
fBTcl_InitObjHashTablefR is a wrapper around
fBTcl_InitCustomHashTablefR and initializes a hash table whose keys
are Tcl_Obj *.
.PP
fBTcl_InitCustomHashTablefR initializes a structure that describes a
new hash table. The space for the structure is provided by the
caller, not by the hash module.  The value of fIkeyTypefR indicates
what kinds of keys will be used for all entries in the table.
fIKeyTypefR must have one of the following values:
.IP fBTCL_STRING_KEYSfR 25
Keys are null-terminated strings.
They are passed to hashing routines using the address of the
first character of the string.
.IP fBTCL_ONE_WORD_KEYSfR 25
Keys are single-word values;  they are passed to hashing routines
and stored in hash table entries as ``char *'' values.
The pointer value is the key;  it need not (and usually doesn't)
actually point to a string.
.IP fBTCL_CUSTOM_TYPE_KEYSfR 25
Keys are of arbitrary type, and are stored in the entry. Hashing
and comparison is determined by fItypePtrfR. The Tcl_HashKeyType 
structure is described in the section 
fBTHE TCL_HASHKEYTYPE STRUCTUREfR below.
.IP fBTCL_CUSTOM_PTR_KEYSfR 25
Keys are pointers to an arbitrary type, and are stored in the entry. Hashing
and comparison is determined by fItypePtrfR. The Tcl_HashKeyType 
structure is described in the section 
fBTHE TCL_HASHKEYTYPE STRUCTUREfR below.
.IP fIotherfR 25
If fIkeyTypefR is not one of the above,
then it must be an integer value greater than 1.
In this case the keys will be arrays of ``int'' values, where
fIkeyTypefR gives the number of ints in each key.
This allows structures to be used as keys.
All keys must have the same size.
Array keys are passed into hashing functions using the address
of the first int in the array.
.PP
fBTcl_DeleteHashTablefR deletes all of the entries in a hash
table and frees up the memory associated with the table's
bucket array and entries.
It does not free the actual table structure (pointed to
by fItablePtrfR), since that memory is assumed to be managed
by the client.
fBTcl_DeleteHashTablefR also does not free or otherwise
manipulate the values of the hash table entries.
If the entry values point to dynamically-allocated memory, then
it is the client's responsibility to free these structures
before deleting the table.
.PP
fBTcl_CreateHashEntryfR locates the entry corresponding to a
particular key, creating a new entry in the table if there
wasn't already one with the given key.
If an entry already existed with the given key then fI*newPtrfR
is set to zero.
If a new entry was created, then fI*newPtrfR is set to a non-zero
value and the value of the new entry will be set to zero.
The return value from fBTcl_CreateHashEntryfR is a pointer to
the entry, which may be used to retrieve and modify the entry's
value or to delete the entry from the table.
.PP
fBTcl_DeleteHashEntryfR will remove an existing entry from a
table.
The memory associated with the entry itself will be freed, but
the client is responsible for any cleanup associated with the
entry's value, such as freeing a structure that it points to.
.PP
fBTcl_FindHashEntryfR is similar to fBTcl_CreateHashEntryfR
except that it doesn't create a new entry if the key doesn't exist;
instead, it returns NULL as result.
.PP
fBTcl_GetHashValuefR and fBTcl_SetHashValuefR are used to
read and write an entry's value, respectively.
Values are stored and retrieved as type ``ClientData'', which is
large enough to hold a pointer value.  On almost all machines this is
large enough to hold an integer value too.
.PP
fBTcl_GetHashKeyfR returns the key for a given hash table entry,
either as a pointer to a string, a one-word (``char *'') key, or
as a pointer to the first word of an array of integers, depending
on the fIkeyTypefR used to create a hash table.
In all cases fBTcl_GetHashKeyfR returns a result with type
``char *''.
When the key is a string or array, the result of fBTcl_GetHashKeyfR
points to information in the table entry;  this information will
remain valid until the entry is deleted or its table is deleted.
.PP
fBTcl_FirstHashEntryfR and fBTcl_NextHashEntryfR may be used
to scan all of the entries in a hash table.
A structure of type ``Tcl_HashSearch'', provided by the client,
is used to keep track of progress through the table.
fBTcl_FirstHashEntryfR initializes the search record and
returns the first entry in the table (or NULL if the table is
empty).
Each subsequent call to fBTcl_NextHashEntryfR returns the
next entry in the table or
NULL if the end of the table has been reached.
A call to fBTcl_FirstHashEntryfR followed by calls to
fBTcl_NextHashEntryfR will return each of the entries in
the table exactly once, in an arbitrary order.
It is unadvisable to modify the structure of the table, e.g.
by creating or deleting entries, while the search is in
progress.
.PP
fBTcl_HashStatsfR returns a dynamically-allocated string with
overall information about a hash table, such as the number of
entries it contains, the number of buckets in its hash array,
and the utilization of the buckets.
It is the caller's responsibility to free the result string
by passing it to fBckfreefR.
.PP
The header file fBtcl.hfR defines the actual data structures
used to implement hash tables.
This is necessary so that clients can allocate Tcl_HashTable
structures and so that macros can be used to read and write
the values of entries.
However, users of the hashing routines should never refer directly
to any of the fields of any of the hash-related data structures;
use the procedures and macros defined here.
.SH "THE TCL_HASHKEYTYPE STRUCTURE"
.PP
Extension writers can define new hash key types by defining four
procedures, initializing a Tcl_HashKeyType structure to describe
the type, and calling fBTcl_InitCustomHashTablefR.
The fBTcl_HashKeyTypefR structure is defined as follows:
.CS
typedef struct Tcl_HashKeyType {
    int fIversionfR;
    int fIflagsfR;
    Tcl_HashKeyProc *fIhashKeyProcfR;
    Tcl_CompareHashKeysProc *fIcompareKeysProcfR;
    Tcl_AllocHashEntryProc *fIallocEntryProcfR;
    Tcl_FreeHashEntryProc *fIfreeEntryProcfR;
} Tcl_HashKeyType;
.CE
.PP
The fIversionfR member is the version of the table. If this
structure is extended in future then the version can be used
to distinguish between different structures. It should be set
to fBTCL_HASH_KEY_TYPE_VERSIONfR.
.PP
The fIflagsfR member is one or more of the following values OR'ed together:
.IP fBTCL_HASH_KEY_RANDOMIZE_HASHfR 25
There are some things, pointers for example which don't hash well 
because they do not use the lower bits. If this flag is set then the
hash table will attempt to rectify this by randomising the bits and 
then using the upper N bits as the index into the table.
.PP
The fIhashKeyProcfR member contains the address of a function 
called to calculate a hash value for the key.
.CS
typedef unsigned int (Tcl_HashKeyProc) (
    Tcl_HashTable *fItablePtrfR,
    VOID *fIkeyPtrfR);
.CE
If this is NULL then fIkeyPtrfR is used and 
fBTCL_HASH_KEY_RANDOMIZE_HASHfR is assumed.
.PP
The fIcompareKeysProcfR member contains the address of a function 
called to compare two keys.
.CS
typedef int (Tcl_CompareHashKeysProc) (VOID *fIkeyPtrfR,
    Tcl_HashEntry *fIhPtrfR);
.CE
If this is NULL then the fIkeyPtrfR pointers are compared.
If the keys don't match then the function returns 0, otherwise
it returns 1.
.PP
The fIallocEntryProcfR member contains the address of a function 
called to allocate space for an entry and initialise the key.
.CS
typedef Tcl_HashEntry *(Tcl_AllocHashEntryProc) (
    Tcl_HashTable *fItablePtrfR, VOID *fIkeyPtrfR);
.CE
If this is NULL then Tcl_Alloc is used to allocate enough space for a
Tcl_HashEntry and the key pointer is assigned to key.oneWordValue.
String keys and array keys use this function to allocate enough 
space for the entry and the key in one block, rather than doing
it in two blocks. This saves space for a pointer to the key from
the entry and another memory allocation. Tcl_Obj * keys use this 
function to allocate enough space for an entry and increment the 
reference count on the object.
If 
.PP
The fIfreeEntryProcfR member contains the address of a function 
called to free space for an entry.
.CS
typedef void (Tcl_FreeHashEntryProc) (Tcl_HashEntry *fIhPtrfR);
.CE
If this is NULL then Tcl_Free is used to free the space for the 
entry. Tcl_Obj * keys use this function to decrement the
reference count on the object.
.SH KEYWORDS
hash table, key, lookup, search, value

						