<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-1">
<TITLE> Disk Based HashTables </TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.0 (Linux)">
<META NAME="CREATED" CONTENT="20020604;17532000">
<META NAME="CHANGED" CONTENT="20020624;13503400">
<STYLE>
<!--
TD P { color: #000000 }
H1 { color: #000000 }
P { color: #000000 }
H2 { color: #000000 }
PRE { color: #000000 }
H3 { color: #000000 }
TH P { color: #000000 }
A:visited { color: #840084 }
A:link { color: #0000ff }
-->
</STYLE>
</HEAD>
<BODY LANG="en-US" TEXT="#000000" LINK="#0000ff" VLINK="#840084" BGCOLOR="#ffffff">
<TABLE WIDTH=100% BORDER=0 CELLPADDING=2 CELLSPACING=0 BGCOLOR="#000000" STYLE="page-break-before: always">
<TR>
<TH COLSPAN=4>
<P ALIGN=CENTER><FONT COLOR="#ffffff"><FONT SIZE=5>Dbh Reference
Manual</FONT></FONT></P>
</TH>
</TR>
</TABLE>
<H1><A NAME="DB-HASH-TABLES"></A>Disk Based HashTables (1.0.10)</H1>
<H2><A NAME="AEN26827"></A>Name</H2>
<P>Disk Based HashTables -- associations between keys and
values so that given a key the value can be found quickly, being disk
based allows for large and persistent hashes.</P>
<H2><A NAME="AEN26830"></A>Synopsis</H2>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>#include <dbh.h>
struct <A HREF="#DBHASHTABLE">DBHashTable</A>;
void (<A HREF="#DBHASHFUNC">*DBHashFunc</A>) (<A HREF="#DBHASHTABLE">struct DBHashTable *</A> hash);
<A HREF="#DBHASHTABLE">DBHashTable</A>* <A HREF="#DB-HASH-TABLE-CREATE">DBH_create</A> (char * path,
unsigned char key_length);
<A HREF="#DBHASHTABLE">DBHashTable</A>* <A HREF="#DB-HASH-TABLE-OPEN">DBH_open</A> (char * path);
<A HREF="#DBHASHTABLE">DBHashTable</A>* <A HREF="#DB-HASH-TABLE-OPENR">DBH_openR</A> (char * path);
int <A HREF="#DB-HASH-TABLE-CLOSE">DBH_close</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
<A HREF="#DBHASHTABLE">DBHashTable</A>* <A HREF="#DB-HASH-TABLE-DESTROY">DBH_destroy</A> (<A HREF="#DBHASHTABLE">DBHashTable</A>* hash_table);
<A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-UPDATE">DBH_update</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
<A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-LOAD">DBH_load</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
<A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-LOAD_ADDRESS">DBH_load_address</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
<A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-LOAD_PARENT">DBH_load_parent</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
<A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-LOAD_CHILD">DBH_load_child </A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table, unsigned char key_index);
<A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-FIND">DBH_find</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
int ignored_digits);
int <A HREF="#DB-HASH-TABLE-ERASE">DBH_erase</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
int <A HREF="#DB-HASH-TABLE-UNERASE">DBH_unerase</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
int <A HREF="#DB-HASH-TABLE-PRUNE">DBH_prune</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
unsigned char *key,
int subtree_length);
int <A HREF="#DB-HASH-TABLE-UNPRUNE">DBH_unprune</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
unsigned char *key,
int subtree_length);
int <A HREF="#DB-HASH-TABLE-FOREACH_SWEEP">DBH_foreach_sweep</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
<A HREF="#DBHASHFUNC">*DBHashFunc</A>) func);
int <A HREF="#DB-HASH-TABLE-FOREACH_FANOUT">DBH_foreach_fanout</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
<A HREF="#DBHASHFUNC">*DBHashFunc</A>) func);
int <A HREF="#DB-HASH-TABLE-SWEEP">DBH_sweep</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
<A HREF="#DBHASHFUNC">*DBHashFunc</A>) func,
unsigned char key1,
unsigned char key2,
unsigned char ignore_portion);
int <A HREF="#DB-HASH-TABLE-FANOUT">DBH__fanout</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
<A HREF="#DBHASHFUNC">*DBHashFunc</A>) func,
unsigned char key1,
unsigned char key2,
unsigned char ignore_portion);
void <A HREF="#DB-HASH-TABLE-ORDERKEY">DBH_orderkey</A> (unsigned char *key,
unsigned char length,
unsigned int n,
unsigned char base);
void <A HREF="#DB-HASH-TABLE-GENKEY">DBH_genkey</A> (unsigned char *key,
unsigned char length,
unsigned int n);
void <A HREF="#DB-HASH-TABLE-GENKEY2">DBH_genkey2</A> (unsigned char *key,
unsigned char length,
unsigned int n);
<A HREF="#DBHASHTABLE">DBHashTable</A>* <A HREF="#DB-HASH-TABLE-REGEN">DBH_regen</A> (<A HREF="#DBHASHTABLE">DBHashTable</A>* hash_table);
int <A HREF="#DB-HASH-TABLE-SIZE">DBH_Size</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
int new_max_size);
int <A HREF="#DB-HASH-TABLE-WRITEHEADER">DBH_writeheader</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
void <A HREF="#DB-HASH-TABLE-EXITSWEEP">DBH_exitsweep</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
void <A HREF="#DB-HASH-TABLE-SET_RECORDSIZE">DBH_set_recordsize</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
int recordsize);
void <A HREF="#DB-HASH-TABLE-SET_KEY">DBH_set_key</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
char *key);
void <A HREF="#DB-HASH-TABLE-SET_DATA">DBH_set_data</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
void * data,
int size);
unsigned char <A HREF="#DB-HASH-TABLE-KEYLENGTH">DBH_KEYLENGTH</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
int <A HREF="#DB-HASH-TABLE-RECORDSIZE">DBH_RECORD_SIZE</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
void * <A HREF="#DB-HASH-TABLE-PATH">DBH_PATH</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
void * <A HREF="#DB-HASH-TABLE-DATA">DBH_DATA</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
unsigned char * <A HREF="#DB-HASH-TABLE-KEY">DBH_KEY</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
<A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-ERASED_SPACE">DBH_ERASED_SPACE</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
<A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-DATA_SPACE">DBH_DATA_SPACE</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
<A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-TOTAL_SPACE">DBH_TOTAL_SPACE</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
<A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-FORMAT_SPACE">DBH_FORMAT_SPACE</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
<A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-RECORDS">DBH_RECORDS</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);
<A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-MAXRECORD_SIZE">DBH_MAXIMUM_RECORD_SIZE</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<H2><A NAME="AEN26928"></A>Description</H2>
<P>A <A HREF="#DBHASHTABLE">DBHashTable</A> provides associations
between keys and values which is optimized so that given a key, the
associated value can be found very quickly.</P>
<P>Note that only one hash record is loaded from disk to memory at
any given moment for a DBHashTable. Both keys and values should be
copied into the <A HREF="#DBHASHTABLE">DBHashTable</A> record, so
they need not exist for the lifetime of the <A HREF="#DBHASHTABLE">DBHashTable</A>.
This means that the use of static strings and temporary strings (i.e.
those created in buffers and those returned by GTK+ widgets) should
be copied with <A HREF="#DB-HASH-TABLE-SET_KEY">DBH_set_key</A> and
<A HREF="#DB-HASH-TABLE-SET_DATA">DBH_set_data</A> ()into the
DBHashTable record before being inserted.</P>
<P>You must be careful to ensure that copied key length matches the
defined key length of the <A HREF="#DBHASHTABLE">DBHashTable</A>, and
also that the copied data does not exceed the maximum length of the
DBHashTable record (1024 bytes by default, and expandable by
<A HREF="#DB-HASH-TABLE-SIZE">DBH_Size</A>). If the <A HREF="#DBHASHTABLE">DBHashTable</A>
record length is to be variable, be sure to set the appropriate
length before each <A HREF="#DB-HASH-TABLE-UPDATE">DBH_update()</A>,
with <A HREF="#DB-HASH-TABLE-SET_RECORDSIZE">DBH_set_recordsize()</A>,
otherwise the record length need only be set before the first
<A HREF="#DBINSERT">DBH_update()</A>.
</P>
<P>To create a <A HREF="#DBHASHTABLE">DBHashTable</A>, use
<A HREF="#DB-HASH-TABLE-CREATE">DBH_create</A>().</P>
<P>To insert a key and value into a <A HREF="#DBHASHTABLE">DBHashTable</A>,
use <A HREF="#DB-HASH-TABLE-UPDATE">DBH_update</A>(). The DBHashTable
will not be modified until this command is given. All changes to the
current DBHashTable record only reside in memory. DBH_update is
necesary to commit the changes to the DBHashTable.</P>
<P>To lookup a value corresponding to a given key, use <A HREF="#DB-HASH-TABLE-LOOKUP">DBH_load</A>().</P>
<P>To erase and unerase a key and value, use <A HREF="#DB-HASH-TABLE-ERASE">DBH_erase</A>()
and <A HREF="#DB-HASH-TABLE-UNERASE">DBH_unerase</A>().</P>
<P>To call a function for each key and value pair (using a sweep
route) use <A HREF="#DB-HASH-TABLE-FOREACH_SWEEP">DBH_foreach_sweep</A>()
and <A HREF="#DB-HASH-TABLE-SWEEP">DBH_sweep</A>().</P>
<P>To call a function for each key and value pair (using a fanout
route) use <A HREF="#DB-HASH-TABLE-FOREACH_FANOUT">DBH_foreach_fanout</A>()
and <A HREF="#DB-HASH-TABLE-FANOUT">DBH_foreach_fanout</A>().</P>
<P>To destroy a <A HREF="#DBHASHTABLE">DBHashTable</A> use
<A HREF="#DB-HASH-TABLE-DESTROY">DBH_destroy</A>().</P>
<HR>
<H2>Details</H2>
<H3><A NAME="FILEPOINTER"></A>typedef FILEPOINTER</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>typedef FILEPOINTER</PRE>
</TD>
<TD>
<P>Either a 32 bit or 64 bit integer.</P>
</TD>
</TR>
</TABLE>
<H3><A NAME="DBHASHTABLE"></A>struct DBHashTable</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>struct DBHashTable;</PRE>
</TD>
</TR>
</TABLE>
<P>The DBHashTable struct is an opaque data structure to represent a
<A HREF="">Disk Based Hash Table</A>. It should only be accessed via
the following functions.</P>
<HR>
<H3><A NAME="DB-HASH-TABLE-CREATE"></A>DBH_create ()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#DBHASHTABLE">DBHashTable</A>* <A HREF="#DB-HASH-TABLE-CREATE">DBH_create</A> (char * path,
unsigned char key_length);</PRE>
</TD>
</TR>
</TABLE>
<P>Creates a new <A HREF="#DBHASHTABLE">DBHashTable</A>.</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>path</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>path on disk where DBHashTable will reside.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>key_length</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The length of the key to access the DBHashTable.
This is fixed length. If you want variable length, use a
g_hash_table to associate cuantified keys generated by genkey(),
and create an extra DBHashTable to save the g_hash. Cuantified
keys assure that large DBHashes are spread out evenly.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to the newly created and opened
DBHashTable, or NULL if it fails.</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-OPEN"></A>DBH_open()</H3>
<P><BR><BR>
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#DBHASHTABLE">DBHashTable</A>* <A HREF="#DB-HASH-TABLE-OPEN">DBH_open</A> (char * path);</PRE>
</TD>
</TR>
</TABLE>
<P>Open a existing DBHashTable for read/write operations.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>path</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>path to file containing DBHashTable
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>pointer to DBHashTable or NULL if it fails.</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-OPENR"></A>DBH_openR()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#DBHASHTABLE">DBHashTable</A>* <A HREF="#DB-HASH-TABLE-OPENR">DBH_openR</A> (char * path);</PRE>
</TD>
</TR>
</TABLE>
<P>Open a existing DBHashTable for read-only operations.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>path</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>path to file containing DBHashTable
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>pointer to DBHashTable or NULL if it fails.</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-CLOSE"></A>DBH_close()</H3>
<P><BR><BR>
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>int <A HREF="#DB-HASH-TABLE-CLOSE">DBH_close</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>Close a previously opened DBHashTable</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>TRUE if successful, FALSE if fails.</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-DESTROY"></A>DBH_destroy()</H3>
<P><BR><BR>
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#DBHASHTABLE">DBHashTable</A>* <A HREF="#DB-HASH-TABLE-DESTROY">DBH_destroy</A> (<A HREF="#DBHASHTABLE">DBHashTable</A>* hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>Close an open DBHashTable and erase file from disk.</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>NULL (fixme: should be a TRUE/FALSE routine)</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-UPDATE"></A>DBH_update()</H3>
<P><BR><BR>
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-UPDATE">DBH_update</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>Insert or replace the current hash record into the DBHashTable.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>Current hash record FILEPOINTER or FALSE if it fails</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-LOAD"></A>DBH_load()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-LOAD">DBH_load</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>Load the record with the key that matches the one in the current
hash record.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>Current hash record FILEPOINTER or FALSE if it fails</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-LOAD_ADDRESS"></A>DBH_load_address()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-LOAD_ADDRESS">DBH_load_address</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>Load the record directly by means of the FILEPOINTER into the
current hash record.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>Current hash record number of branches or FALSE if
it fails</P>
</TD>
</TR>
</TABLE>
<H3><A NAME="DB-HASH-TABLE-LOAD_PARENT"></A>DBH_load_parent()
(1.0.10)</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=0 BGCOLOR="#e8e8ff">
<COL WIDTH=256*>
<TR>
<TD WIDTH=100%>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-LOAD_PARENT">DBH_load_parent</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>Load the record which is the parent of the in the current hash
record.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<COL WIDTH=51*>
<COL WIDTH=205*>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>Current hash record number of branches or FALSE if
it fails</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-LOAD_CHILD"></A>DBH_load_child() (1.0.10)</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=0 BGCOLOR="#e8e8ff">
<COL WIDTH=256*>
<TR>
<TD WIDTH=100%>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-LOAD_CHILD">DBH_load_child</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table, unsigned char key_index);</PRE>
</TD>
</TR>
</TABLE>
<P>Load the record which is the child on the key_index branch of the
current hash record.
</P>
<P>This is a convenience function. If you are doing a repetitive
operation on a set of linked records it is much faster and better to
use <A HREF="#DB-HASH-TABLE-SWEEP">DBH_sweep().</A></P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<COL WIDTH=51*>
<COL WIDTH=205*>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>Current hash record number of branches or FALSE if
it fails</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><BR><BR>
</H3>
<H3><A NAME="DB-HASH-TABLE-FIND"></A>DBH_find()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-FIND">DBH_find</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
int n_digits);</PRE>
</TD>
</TR>
</TABLE>
<P>Find the top level subtree node for the key in the current hash
record, but ignoring the last n_digits.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>n_digits</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>number of trailing bytes to ignore on the key of the
current hash record</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>FILEPOINTER for top level node of subtree</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-UNERASE"></A>DBH_unerase()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-UNERASE">DBH_unerase</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>Mark the current DBHashTable record as *not* erased
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>TRUE if successfull. FALSE otherwise.</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-ERASE"></A>DBH_erase()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-ERASE">DBH_erase</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>Mark the current DBHashTable record as erased
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>TRUE if successfull. FALSE otherwise.</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-PRUNE"></A>DBH_prune()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-PRUNE">DBH_prune</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
unsigned char *key,
int subtree_length);</PRE>
</TD>
</TR>
</TABLE>
<P>Mark the entire subtree defined by key and subtree_length as
erased
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>key</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>key to top of subtree</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>subtree_length</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>number of trailing bytes to ignore on the key to
define the subtree</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>TRUE if successfull, FALSE otherwise.</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-UNPRUNE"></A>DBH_unprune()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-UNPRUNE">DBH_unprune</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
unsigned char *key,
int subtree_length);</PRE>
</TD>
</TR>
</TABLE>
<P>Mark the entire subtree defined by key and subtree_length as *not*
erased
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>key</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>key to top of subtree</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>subtree_length</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>number of trailing bytes to ignore on the key to
define the subtree</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>TRUE if successfull, FALSE otherwise.</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-FOREACH_SWEEP"></A>DBH_foreach_sweep()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>int <A HREF="#DB-HASH-TABLE-FOREACH_SWEEP">DBH_foreach_sweep</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
<A HREF="#DBHASHFUNC">*DBHashFunc</A>) func);</PRE>
</TD>
</TR>
</TABLE>
<P>Apply a function to each member of the hash, following a sweep
trajectory (vertically through branches).
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>func</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The function to apply to each selected member of the
hash.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>TRUE on success, FALSE if it fails</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-FOREACH_FANOUT"></A>DBH_foreach_fanout()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>int <A HREF="#DB-HASH-TABLE-FOREACH_FANOUT">DBH_foreach_fanout</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
<A HREF="#DBHASHFUNC">*DBHashFunc</A>) func);</PRE>
</TD>
</TR>
</TABLE>
<P>Apply a function to each member of the hash, following a fanout
trajectory (horizontally through leafs).
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>func</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The function to apply to each selected member of the
hash.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>TRUE on success, FALSE if it fails</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-SWEEP"></A>DBH_sweep()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>int <A HREF="#DB-HASH-TABLE-SWEEP">DBH_sweep</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
<A HREF="#DBHASHFUNC">*DBHashFunc</A>) func,
unsigned char key1,
unsigned char key2,
unsigned char ignore_portion);</PRE>
</TD>
</TR>
</TABLE>
<P>Apply a function to subtree members of the hash, following a sweep
trajectory (vertically through branches).
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>func</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The function to apply to each selected member of the
hash.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>key1</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The key from which to start the sweep. (Make sure it
is a top level node of a subtree. This is done by using DBH_find()
previously), or NULL if don't care.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>key2</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The key which will trigger an exit condition from
the sweep, or NULL if don't care.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>ignore_portion</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The ignored trailing bytes of key1 which will define
the magnitud of the subtree to be sweeped, or zero if don't care.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>TRUE on success, FALSE if it fails</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-FANOUT"></A>DBH_fanout()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>int <A HREF="#DB-HASH-TABLE-FANOUT">DBH__fanout</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
<A HREF="#DBHASHFUNC">*DBHashFunc</A>) func,
unsigned char key1,
unsigned char key2,
unsigned char ignore_portion);</PRE>
</TD>
</TR>
</TABLE>
<P>Apply a function to subtree members of the hash, following a
fanout trajectory (horizontally through leafs). s
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>func</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The function to apply to each selected member of the
hash.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>key1</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The key from which to start the sweep. (Make sure it
is a top level node of a subtree. This is done by using DBH_find()
previously), or NULL if don't care.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>key2</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The key which will trigger an exit condition from
the sweep, or NULL if don't care.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>ignore_portion</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The ignored trailing bytes of key1 which will define
the magnitud of the subtree to be sweeped, or zero if don't care.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>TRUE on success, FALSE if it fails</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-ORDERKEY"></A>DBH_orderkey()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>void <A HREF="#DB-HASH-TABLE-ORDERKEY">DBH_orderkey</A> (unsigned char *key,
unsigned char length,
unsigned int n,
unsigned char base);</PRE>
</TD>
</TR>
</TABLE>
<P>Obtain a key from a secuential series of natural numbers (positive
integers without zero) which conserves the order of the natural
numbers.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>key</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The address where to put the generated key.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>length</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The key length</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>n</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The natural number from which to generate the key</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>base</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The number system base to use. This will equal the
maximum number of nodes per branch. This ---along with the
keylength--- will also define a maximum number of records for the
DBHashTable</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>an unsigned caracter array based on 'A'</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-GENKEY"></A>DBH_genkey()</H3>
<HR>
<P><BR><BR>
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>void <A HREF="#DB-HASH-TABLE-GENKEY">DBH_genkey</A> (unsigned char *key,
unsigned char length,
unsigned int n);</PRE>
</TD>
</TR>
</TABLE>
<P>Obtain a key from a secuential series of natural numbers (positive
integers without zero) which does not conserve the order of the
natural numbers, but which are optimized for construction of a
balanced hash tree. These keys are expressed in <I>cuantified numbers
</I>based on the 0 digit.</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>key</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The address where to put the generated key.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>length</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The key length</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>n</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The natural number from which to generate the key</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>an unsigned caracter array based on '0'</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-GENKEY2"></A>DBH_genkey2()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>void <A HREF="#DB-HASH-TABLE-GENKEY2">DBH_genkey2</A> (unsigned char *key,
unsigned char length,
unsigned int n);</PRE>
</TD>
</TR>
</TABLE>
<P>Obtain a key from a secuential series of natural numbers (positive
integers without zero) which does not conserve the order of the
natural numbers, but which are optimized for construction of a
balanced hash tree. These keys are expressed in <I>cuantified numbers
</I>based on the A symbol<I>.</I></P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>key</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The address where to put the generated key.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>length</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The key length</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>n</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The natural number from which to generate the key</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>an unsigned caracter array based on 'A'
</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-REGEN"></A>DBH_regen()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#DBHASHTABLE">DBHashTable</A>* <A HREF="#DB-HASH-TABLE-REGEN">DBH_regen</A> (<A HREF="#DBHASHTABLE">DBHashTable</A>* hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>Regenerate the DBHashTable, eliminating erased records and
optimizing disk access and speed.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The new pointer to the DBHashTable.</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-SIZE"></A>DBH_Size()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>int <A HREF="#DB-HASH-TABLE-SIZE">DBH_Size</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
int new_max_size);</PRE>
</TD>
</TR>
</TABLE>
<P>Define the maximum amount of memory to be allocated to the current
DBHashTable data record. The default is 1024 bytes.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>new_max_size</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The new maximum memory allocation for the data of
the DBHashTable record.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>TRUE if success, FALSE if fails (I guess)</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-WRITEHEADER"></A>DBH_writeheader()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>int <A HREF="#DB-HASH-TABLE-WRITEHEADER">DBH_writeheader</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>Write out the DBHashTable header information. It is advisable to
call this function inmediately after creation of a new DBHashTable to
force a buffer flush.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>TRUE if success, FALSE if fails</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-EXITSWEEP"></A>DBH_exitsweep()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>void <A HREF="#DB-HASH-TABLE-EXITSWEEP">DBH_exitsweep</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>Calling this function from within a DBHashFunc will cause an exit
of the sweep.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>void</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-SET_RECORDSIZE"></A>DBH_set_recordsize()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>void <A HREF="#DB-HASH-TABLE-SET_RECORDSIZE">DBH_set_recordsize</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
int recordsize);</PRE>
</TD>
</TR>
</TABLE>
<P>This sets the recordsize of the the data in the current
DBHashTable record. It is called implicitly by calling
DBH_set_data().
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>new_max_recordsize</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The amount of valid bytes in the current DBHashTable
record.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>void</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-SET_KEY"></A>DBH_set_key()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>void <A HREF="#DB-HASH-TABLE-SET_KEY">DBH_set_key</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
char *key);</PRE>
</TD>
</TR>
</TABLE>
<P>This function sets the key of the current DBHashTable record.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>key</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The key to set as the current DBHashTable record
key.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>void</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-SET_DATA"></A>DBH_set_data()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>void <A HREF="#DB-HASH-TABLE-SET_DATA">DBH_set_data</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table,
void * data,
int size);</PRE>
</TD>
</TR>
</TABLE>
<P>This function copies the user data into the current DBHashTable
record and along with DBH_set_key, makes the current DBHashTable
record ready for the DBH_update function to commit the record to the
actual DBHashTable on disk.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>data</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>Pointer to the data to copy to the current
DBHashTable record.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>size</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>The amount of bytes to copy to the current
DBHashTable record.</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>void (FIXME: should return TRUE or FALSE)</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-KEYLENGTH"></A>DBH_KEYLENGTH()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>unsigned char <A HREF="#DB-HASH-TABLE-KEYLENGTH">DBH_KEYLENGTH</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>This macro returns the DBHashTable's defined keylength.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>the DBHashTable's defined keylength</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-RECORDSIZE"></A>DBH_RECORD_SIZE()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>int <A HREF="#DB-HASH-TABLE-RECORDSIZE">DBH_RECORD_SIZE</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>This macro returns the current DBHashTable's data size.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>the current DBHashTable's data size</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-PATH"></A>DBH_PATH()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>void * <A HREF="#DB-HASH-TABLE-PATH">DBH_PATH</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>This macro returns a pointer to a string containing the path to
the current DBHashTable.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>a pointer to a string with the DBHashTable path.
</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-DATA"></A>DBH_DATA()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>void * <A HREF="#DB-HASH-TABLE-DATA">DBH_DATA</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>This macro returns a pointer to the current DBHashTable data area.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>a pointer to the current DBHashTable data
</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-KEY"></A>DBH_KEY()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE>void * <A HREF="#DB-HASH-TABLE-KEY">DBH_KEY</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>This macro returns a pointer to the current DBHashTable key area.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>a pointer to the current DBHashTable key
</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-ERASED_SPACE"></A>DBH_ERASED_SPACE()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-ERASED_SPACE">DBH_ERASED_SPACE</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>This macro returns an approximation of the amount of bytes taken
up by erased data in the DBHashTable.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>the amount of bytes taken up by erased data</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-DATA_SPACE"></A>DBH_DATA_SPACE()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-DATA_SPACE">DBH_DATA_SPACE</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>This macro returns an approximation of the amount of bytes taken
up by valid data in the DBHashTable.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>the amount of bytes taken up by valid data</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-TOTAL_SPACE"></A>DBH_TOTAL_SPACE()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-TOTAL_SPACE">DBH_TOTAL_SPACE</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>This macro returns an approximation of the total amount of bytes
taken up by the DBHashTable.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>the total amount of bytes taken up by the
DBHashTable
</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-FORMAT_SPACE"></A>DBH_FORMAT_SPACE()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-FORMAT_SPACE">DBH_FORMAT_SPACE</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>This macro returns an approximation of the total amount of bytes
taken up by the format of the DBHashTable.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>the total amount of bytes taken up by the format of
the DBHashTable</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-RECORDS"></A>DBH_RECORDS()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-RECORDS">DBH_RECORDS</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>This macro returns the number of records in the DBHashTable.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>the number of records in the DBHashTable</P>
</TD>
</TR>
</TABLE>
<HR>
<H3><A NAME="DB-HASH-TABLE-MAXRECORD_SIZE"></A>DBH_MAXIMUM_RECORD_SIZE()</H3>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=6 CELLSPACING=2 BGCOLOR="#e8e8ff">
<TR>
<TD>
<PRE><A HREF="#FILEPOINTER">FILEPOINTER</A> <A HREF="#DB-HASH-TABLE-MAXRECORD_SIZE">DBH_MAXIMUM_RECORD_SIZE</A> (<A HREF="#DBHASHTABLE">DBHashTable</A> *hash_table);</PRE>
</TD>
</TR>
</TABLE>
<P>This macro returns the maximum allocated space for data in the
current DBHashTable record.
</P>
<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0 BGCOLOR="#f0f0d0">
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><TT><I>hash_table</I></TT> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>A pointer to a open DBHashTable.
</P>
</TD>
</TR>
<TR VALIGN=TOP>
<TD WIDTH=20%>
<P ALIGN=RIGHT><I>Returns</I> :</P>
</TD>
<TD WIDTH=80%>
<P ALIGN=LEFT>the maximum allocated space for data in the current
DBHashTable record</P>
</TD>
</TR>
</TABLE>
<P><BR><BR>
</P>
</BODY>
</HTML>
