/*****************************************************************************\
* Copyright (c) Athena Dev Teams - Licensed under GNU GPL *
* For more information, see LICENCE in the main folder *
* *
* This file is separated in two sections: *
* (1) public typedefs, enums, unions, structures and defines *
* (2) public functions *
* *
* <B>Notes on the release system:</B> *
* Whenever an entry is removed from the database both the key and the *
* data are requested to be released. *
* At least one entry is removed when replacing an entry, removing an *
* entry, clearing the database or destroying the database. *
* What is actually released is defined by the release function, the *
* functions of the database only ask for the key and/or data to be *
* released. *
* *
* TODO: *
* - create an enum for the data (with int, unsigned int and void *) *
* - create a custom database allocator *
* - see what functions need or should be added to the database interface *
* *
* HISTORY: *
* 2.1 (Athena build #???#) - Portability fix *
* - Fixed the portability of casting to union and added the functions *
* {@link DBInterface#ensure(DBInterface,DBKey,DBCreateData,...)} and *
* {@link DBInterface#clear(DBInterface,DBApply,...)}. *
* 2.0 (Athena build 4859) - Transition version *
* - Almost everything recoded with a strategy similar to objects, *
* database structure is maintained. *
* 1.0 (up to Athena build 4706) *
* - Previous database system. *
* *
* @version 2.1 (Athena build #???#) - Portability fix *
* @author (Athena build 4859) Flavio @ Amazon Project *
* @author (up to Athena build 4706) Athena Dev Teams *
* @encoding US-ASCII *
* @see common#db.c *
\*****************************************************************************/
#ifndef _DB_H_
#define _DB_H_
#include <stdarg.h>
/*****************************************************************************\
* (1) Section with public typedefs, enums, unions, structures and defines. *
* DB_MANUAL_CAST_TO_UNION - Define when the compiler doesn't allow casting *
* to unions. *
* DBRelease - Enumeration of release options. *
* DBType - Enumeration of database types. *
* DBOptions - Bitfield enumeration of database options. *
* DBKey - Union of used key types. *
* DBApply - Format of functions applyed to the databases. *
* DBMatcher - Format of matchers used in DBInterface->getall. *
* DBComparator - Format of the comparators used by the databases. *
* DBHasher - Format of the hashers used by the databases. *
* DBReleaser - Format of the releasers used by the databases. *
* DBInterface - Structure of the interface of the database. *
\*****************************************************************************/
/**
* Define this to enable the functions that cast to unions.
* Required when the compiler doesn't support casting to unions.
* NOTE: It is recommened that the conditional tests to determine if this
* should be defined be located in a makefile or a header file specific for
* of compatibility and portability issues.
* @public
* @see #db_i2key(int)
* @see #db_ui2key(unsigned int)
* @see #db_str2key(unsigned char *)
*/
//#define DB_MANUAL_CAST_TO_UNION
/**
* Bitfield with what should be released by the releaser function (if the
* function supports it).
* @public
* @see #DBReleaser
* @see #db_custom_release(DBRelease)
*/
typedef enum {
DB_RELEASE_NOTHING = 0,
DB_RELEASE_KEY = 1,
DB_RELEASE_DATA = 2,
DB_RELEASE_BOTH = 3
} DBRelease;
/**
* Supported types of database.
* See {@link #db_fix_options(DBType,DBOptions)} for restrictions of the
* types of databases.
* @param DB_INT Uses int's for keys
* @param DB_UINT Uses unsigned int's for keys
* @param DB_STRING Uses strings for keys.
* @param DB_ISTRING Uses case insensitive strings for keys.
* @public
* @see #DBOptions
* @see #DBKey
* @see #db_fix_options(DBType,DBOptions)
* @see #db_default_cmp(DBType)
* @see #db_default_hash(DBType)
* @see #db_default_release(DBType,DBOptions)
* @see #db_alloc(const char *,int,DBType,DBOptions,unsigned short)
*/
typedef enum {
DB_INT,
DB_UINT,
DB_STRING,
DB_ISTRING
} DBType;
/**
* Bitfield of options that define the behaviour of the database.
* See {@link #db_fix_options(DBType,DBOptions)} for restrictions of the
* types of databases.
* @param DB_OPT_BASE Base options: does not duplicate keys, releases nothing
* and does not allow NULL keys or NULL data.
* @param DB_OPT_DUP_KEY Duplicates the keys internally. If DB_OPT_RELEASE_KEY
* is defined, the real key is freed as soon as the entry is added.
* @param DB_OPT_RELEASE_KEY Releases the key.
* @param DB_OPT_RELEASE_DATA Releases the data whenever an entry is removed
* from the database.
* WARNING: for funtions that return the data (like DBInterface->remove),
* a dangling pointer will be returned.
* @param DB_OPT_RELEASE_BOTH Releases both key and data.
* @param DB_OPT_ALLOW_NULL_KEY Allow NULL keys in the database.
* @param DB_OPT_ALLOW_NULL_DATA Allow NULL data in the database.
* @public
* @see #db_fix_options(DBType,DBOptions)
* @see #db_default_release(DBType,DBOptions)
* @see #db_alloc(const char *,int,DBType,DBOptions,unsigned short)
*/
typedef enum {
DB_OPT_BASE = 0,
DB_OPT_DUP_KEY = 1,
DB_OPT_RELEASE_KEY = 2,
DB_OPT_RELEASE_DATA = 4,
DB_OPT_RELEASE_BOTH = 6,
DB_OPT_ALLOW_NULL_KEY = 8,
DB_OPT_ALLOW_NULL_DATA = 16,
} DBOptions;
/**
* Union of key types used by the database.
* @param i Type of key for DB_INT databases
* @param ui Type of key for DB_UINT databases
* @param str Type of key for DB_STRING and DB_ISTRING databases
* @public
* @see #DBType
* @see #DBApply(DBKey,void *,va_list)
* @see #DBMatcher(DBKey,void *,va_list)
* @see #DBComparator(DBKey,DBKey,unsigned short)
* @see #DBHasher(DBKey,unsigned short)
* @see #DBReleaser(DBKey,void *,DBRelease)
* @see DBInterface#get(DBInterface,DBKey)
* @see DBInterface#put(DBInterface,DBKey,void *)
* @see DBInterface#remove(DBInterface,DBKey)
*/
typedef union {
int i;
unsigned int ui;
unsigned char *str;
} DBKey;
/**
* Format of funtions that create the data for the key when the entry doesn't
* exist in the database yet.
* @param key Key of the database entry
* @param args Extra arguments of the funtion
* @return Data identified by the key to be put in the database
* @public
* @see #DBKey
* @see DBInterface#vensure(DBInterface,DBKey,DBCreateData,va_list)
* @see DBInterface#ensure(DBInterface,DBKey,DBCreateData,...)
*/
typedef void *(*DBCreateData)(DBKey key, va_list args);
/**
* Format of functions to be applyed to an unspecified quantity of entries of
* a database.
* Any function that applyes this function to the database will return the sum
* of values returned by this function.
* @param key Key of the database entry
* @param data Data of the database entry
* @param args Extra arguments of the funtion
* @return Value to be added up by the funtion that is applying this
* @public
* @see #DBKey
* @see DBInterface#vforeach(DBInterface,DBApply,va_list)
* @see DBInterface#foreach(DBInterface,DBApply,...)
* @see DBInterface#vdestroy(DBInterface,DBApply,va_list)
* @see DBInterface#destroy(DBInterface,DBApply,...)
*/
typedef int (*DBApply)(DBKey key, void *data, va_list args);
/**
* Format of functions that match database entries.
* The purpose of the match depends on the function that is calling the matcher.
* Returns 0 if it is a match, another number otherwise.
* @param key Key of the database entry
* @param data Data of the database entry
* @param args Extra arguments of the function
* @return 0 if a match, another number otherwise
* @public
* @see #DBKey
* @see DBInterface#getall(DBInterface,void **,unsigned int,DBMatcher,...)
*/
typedef int (*DBMatcher)(DBKey key, void *data, va_list args);
/**
* Format of the comparators used internally by the database system.
* Compares key1 to key2.
* <code>maxlen</code> is the maximum number of character used in DB_STRING and
* DB_ISTRING databases. If 0, the maximum number of maxlen is used (64K).
* Returns 0 is equal, negative if lower and positive is higher.
* @param key1 Key being compared
* @param key2 Key we are comparing to
* @param maxlen Maximum number of characters used in DB_STRING and DB_ISTRING
* databases.
* @return 0 if equal, negative if lower and positive if higher
* @public
* @see #DBKey
* @see #db_default_cmp(DBType)
*/
typedef int (*DBComparator)(DBKey key1, DBKey key2, unsigned short maxlen);
/**
* Format of the hashers used internally by the database system.
* Creates the hash of the key.
* <code>maxlen</code> is the maximum number of character used in DB_STRING and
* DB_ISTRING databases. If 0, the maximum number of maxlen is used (64K).
* @param key Key being hashed
* @param maxlen Maximum number of characters used in DB_STRING and DB_ISTRING
* databases.
* @return Hash of the key
* @public
* @see #DBKey
* @see #db_default_hash(DBType)
*/
typedef unsigned int (*DBHasher)(DBKey key, unsigned short maxlen);
/**
* Format of the releaser used by the database system.
* Releases nothing, the key, the data or both.
* All standard releasers use aFree to release.
* @param key Key of the database entry
* @param data Data of the database entry
* @param which What is being requested to be released
* @public
* @see #DBRelease
* @see #DBKey
* @see #db_default_releaser(DBType,DBOptions)
* @see #db_custom_release(DBRelease)
*/
typedef void (*DBReleaser)(DBKey key, void *data, DBRelease which);
/**
* Public interface of a database. Only contains funtions.
* All the functions take the interface as the first argument.
* @public
* @see DBInterface#get(DBInterface,DBKey)
* @see DBInterface#getall(DBInterface,void **,unsigned int,DBMatch,...)
* @see DBInterface#vgetall(DBInterface,void **,unsigned int,DBMatch,va_list)
* @see DBInterface#put(DBInterface,DBKey,void *)
* @see DBInterface#remove(DBInterface,DBKey)
* @see DBInterface#foreach(DBInterface,DBApply,...)
* @see DBInterface#vforeach(DBInterface,DBApply,va_list)
* @see DBInterface#destroy(DBInterface,DBApply,...)
* @see DBInterface#destroy(DBInterface,DBApply,va_list)
* @see DBInterface#size(DBInterface)
* @see DBInterface#type(DBInterface)
* @see DBInterface#options(DBInterface)
* @see #db_alloc(const char *,int,DBType,DBOptions,unsigned short)
*/
typedef struct dbt {
/**
* Get the data of the entry identifid by the key.
* @param dbi Interface of the database
* @param key Key that identifies the entry
* @return Data of the entry or NULL if not found
* @protected
* @see #DBKey
* @see #DBInterface
* @see common\db.c#db_get(DBInterface,DBKey)
*/
void *(*get)(struct dbt *dbi, DBKey key);
/**
* Just calls {@link DBInterface#vgetall(DBInterface,void **,unsigned int,DBMatch,va_list)}.
* Get the data of the entries matched by <code>match</code>.
* It puts a maximum of <code>max</code> entries into <code>buf</code>.
* If <code>buf</code> is NULL, it only counts the matches.
* Returns the number of entries that matched.
* NOTE: if the value returned is greater than <code>max</code>, only the
* first <code>max</code> entries found are put into the buffer.
* @param dbi Interface of the database
* @param buf Buffer to put the data of the matched entries
* @param max Maximum number of data entries to be put into buf
* @param match Function that matches the database entries
* @param ... Extra arguments for match
* @return The number of entries that matched
* @protected
* @see #DBMatcher(DBKey key, void *data, va_list args)
* @see #DBInterface
* @see DBInterface#vgetall(DBInterface,void **,unsigned int,DBMatch,va_list)
* @see common\db.c#db_getall(DBInterface,void **,unsigned int,DBMatch,...)
*/
unsigned int (*getall)(struct dbt *dbi, void **buf, unsigned int max, DBMatcher match, ...);
/**
* Get the data of the entries matched by <code>match</code>.
* It puts a maximum of <code>max</code> entries into <code>buf</code>.
* If <code>buf</code> is NULL, it only counts the matches.
* Returns the number of entries that matched.
* NOTE: if the value returned is greater than <code>max</code>, only the
* first <code>max</code> entries found are put into the buffer.
* @param dbi Interface of the database
* @param buf Buffer to put the data of the matched entries
* @param max Maximum number of data entries to be put into buf
* @param match Function that matches the database entries
* @param ... Extra arguments for match
* @return The number of entries that matched
* @protected
* @see #DBMatcher(DBKey key, void *data, va_list args)
* @see #DBInterface
* @see DBInterface#getall(DBInterface,void **,unsigned int,DBMatch,...)
* @see common\db.c#db_vgetall(DBInterface,void **,unsigned int,DBMatch,va_list)
*/
unsigned int (*vgetall)(struct dbt *dbi, void **buf, unsigned int max, DBMatcher match, va_list args);
/**
* Just calls {@link common\db.h\DBInterface#vensure(DBInterface,DBKey,DBCreateData,va_list)}.
* Get the data of the entry identified by the key.
* If the entry does not exist, an entry is added with the data returned by
* <code>create</code>.
* @param dbi Interface of the database
* @param key Key that identifies the entry
* @param create Function used to create the data if the entry doesn't exist
* @param ... Extra arguments for create
* @return Data of the entry
* @protected
* @see #DBKey
* @see #DBCreateData
* @see #DBInterface
* @see DBInterface#vensure(DBInterface,DBKey,DBCreateData,va_list)
* @see common\db.c#db_ensure(DBInterface,DBKey,DBCreateData,...)
*/
void *(*ensure)(struct dbt *dbi, DBKey key, DBCreateData create, ...);
/**
* Get the data of the entry identified by the key.
* If the entry does not exist, an entry is added with the data returned by
* <code>create</code>.
* @param dbi Interface of the database
* @param key Key that identifies the entry
* @param create Function used to create the data if the entry doesn't exist
* @param args Extra arguments for create
* @return Data of the entry
* @protected
* @see #DBKey
* @see #DBCreateData
* @see #DBInterface
* @see DBInterface#ensure(DBInterface,DBKey,DBCreateData,...)
* @see common\db.c#db_vensure(DBInterface,DBKey,DBCreateData,va_list)
*/
void *(*vensure)(struct dbt *dbi, DBKey key, DBCreateData create, va_list args);
/**
* Put the data identified by the key in the database.
* Returns the previous data if the entry exists or NULL.
* NOTE: Uses the new key, the old one is released.
* @param dbi Interface of the database
* @param key Key that identifies the data
* @param data Data to be put in the database
* @return The previous data if the entry exists or NULL
* @protected
* @see #DBKey
* @see #DBInterface
* @see common\db.c#db_put(DBInterface,DBKey,void *)
*/
void *(*put)(struct dbt *dbi, DBKey key, void *data);
/**
* Remove an entry from the database.
* Returns the data of the entry.
* NOTE: The key (of the database) is released.
* @param dbi Interface of the database
* @param key Key that identifies the entry
* @return The data of the entry or NULL if not found
* @protected
* @see #DBKey
* @see #DBInterface
* @see common\db.c#db_remove(DBInterface,DBKey)
*/
void *(*remove)(struct dbt *dbi, DBKey key);
/**
* Just calls {@link DBInterface#vforeach(DBInterface,DBApply,va_list)}.
* Apply <code>func</code> to every entry in the database.
* Returns the sum of values returned by func.
* @param dbi Interface of the database
* @param func Function to be applyed
* @param ... Extra arguments for func
* @return Sum of the values returned by func
* @protected
* @see #DBInterface
* @see #DBApply(DBKey,void *,va_list)
* @see DBInterface#vforeach(DBInterface,DBApply,va_list)
* @see common\db.c#db_foreach(DBInterface,DBApply,...)
*/
int (*foreach)(struct dbt *dbi, DBApply func, ...);
/**
* Apply <code>func</code> to every entry in the database.
* Returns the sum of values returned by func.
* @param dbi Interface of the database
* @param func Function to be applyed
* @param args Extra arguments for func
* @return Sum of the values returned by func
* @protected
* @see #DBApply(DBKey,void *,va_list)
* @see #DBInterface
* @see DBInterface#foreach(DBInterface,DBApply,...)
* @see common\db.c#db_vforeach(DBInterface,DBApply,va_list)
*/
int (*vforeach)(struct dbt *dbi, DBApply func, va_list args);
/**
* Just calls {@link DBInterface#vclear(DBInterface,DBApply,va_list)}.
* Removes all entries from the database.
* Before deleting an entry, func is applyed to it.
* Releases the key and the data.
* Returns the sum of values returned by func, if it exists.
* @param dbi Interface of the database
* @param func Function to be applyed to every entry before deleting
* @param ... Extra arguments for func
* @return Sum of values returned by func
* @protected
* @see #DBApply(DBKey,void *,va_list)
* @see #DBInterface
* @see DBInterface#vclear(DBInterface,DBApply,va_list)
* @see common\db.c#db_clear(DBInterface,DBApply,...)
*/
int (*clear)(struct dbt *dbi, DBApply func, ...);
/**
* Removes all entries from the database.
* Before deleting an entry, func is applyed to it.
* Releases the key and the data.
* Returns the sum of values returned by func, if it exists.
* @param dbi Interface of the database
* @param func Function to be applyed to every entry before deleting
* @param args Extra arguments for func
* @return Sum of values returned by func
* @protected
* @see #DBApply(DBKey,void *,va_list)
* @see #DBInterface
* @see DBInterface#clear(DBInterface,DBApply,...)
* @see common\db.c#vclear(DBInterface,DBApply,va_list)
*/
int (*vclear)(struct dbt *dbi, DBApply func, va_list args);
/**
* Just calls {@link DBInterface#vdestroy(DBInterface,DBApply,va_list)}.
* Finalize the database, feeing all the memory it uses.
* Before deleting an entry, func is applyed to it.
* Releases the key and the data.
* Returns the sum of values returned by func, if it exists.
* NOTE: This locks the database globally. Any attempt to insert or remove
* a database entry will give an error and be aborted (except for clearing).
* @param dbi Interface of the database
* @param func Function to be applyed to every entry before deleting
* @param ... Extra arguments for func
* @return Sum of values returned by func
* @protected
* @see #DBApply(DBKey,void *,va_list)
* @see #DBInterface
* @see DBInterface#vdestroy(DBInterface,DBApply,va_list)
* @see common\db.c#db_destroy(DBInterface,DBApply,...)
*/
int (*destroy)(struct dbt *dbi, DBApply func, ...);
/**
* Finalize the database, feeing all the memory it uses.
* Before deleting an entry, func is applyed to it.
* Returns the sum of values returned by func, if it exists.
* NOTE: This locks the database globally. Any attempt to insert or remove
* a database entry will give an error and be aborted (except for clearing).
* @param dbi Interface of the database
* @param func Function to be applyed to every entry before deleting
* @param args Extra arguments for func
* @return Sum of values returned by func
* @protected
* @see #DBInterface
* @see #DBApply(DBKey,void *,va_list)
* @see DBInterface#destroy(DBInterface,DBApply,...)
* @see common\db.c#db_vdestroy(DBInterface,DBApply,va_list)
*/
int (*vdestroy)(struct dbt *dbi, DBApply func, va_list args);
/**
* Return the size of the database (number of items in the database).
* @param dbi Interface of the database
* @return Size of the database
* @protected
* @see #DBInterface
* @see common\db.c#db_size(DBInterface)
*/
unsigned int (*size)(struct dbt *dbi);
/**
* Return the type of the database.
* @param dbi Interface of the database
* @return Type of the database
* @protected
* @see #DBType
* @see #DBInterface
* @see common\db.c#db_type(DBInterface)
*/
DBType (*type)(struct dbt *dbi);
/**
* Return the options of the database.
* @param dbi Interface of the database
* @return Options of the database
* @protected
* @see #DBOptions
* @see #DBInterface
* @see common\db.c#db_options(DBInterface)
*/
DBOptions (*options)(struct dbt *dbi);
} *DBInterface;
//For easy access to the common functions.
#ifdef DB_MANUAL_CAST_TO_UNION
# define i2key db_i2key
# define ui2key db_ui2key
# define str2key db_str2key
#else /* not DB_MANUAL_CAST_TO_UNION */
# define i2key(k) ((DBKey)(int)(k))
# define ui2key(k) ((DBKey)(unsigned int)(k))
# define str2key(k) ((DBKey)(unsigned char *)(k))
#endif /* DB_MANUAL_CAST_TO_UNION / not DB_MANUAL_CAST_TO_UNION */
#define db_get(db,k) (db)->get((db),(k))
#define idb_get(db,k) (db)->get((db),i2key(k))
#define uidb_get(db,k) (db)->get((db),ui2key(k))
#define strdb_get(db,k) (db)->get((db),str2key(k))
#define db_put(db,k,d) (db)->put((db),(k),(d))
#define idb_put(db,k,d) (db)->put((db),i2key(k),(d))
#define uidb_put(db,k,d) (db)->put((db),ui2key(k),(d))
#define strdb_put(db,k,d) (db)->put((db),str2key(k),(d))
#define db_remove(db,k) (db)->remove((db),(k))
#define idb_remove(db,k) (db)->remove((db),i2key(k))
#define uidb_remove(db,k) (db)->remove((db),ui2key(k))
#define strdb_remove(db,k) (db)->remove((db),str2key(k))
//These are discarding the possible vargs you could send to the function, so those
//that require vargs must not use these defines.
#define db_ensure(db,k,f) (db)->ensure((db),(k),f)
#define idb_ensure(db,k,f) (db)->ensure((db),i2key(k),f)
#define uidb_ensure(db,k,f) (db)->ensure((db),ui2key(k),f)
#define strdb_ensure(db,k,f) (db)->ensure((db),str2key(k),f)
/*****************************************************************************\
* (2) Section with public functions. *
* db_fix_options - Fix the options for a type of database. *
* db_default_cmp - Get the default comparator for a type of database. *
* db_default_hash - Get the default hasher for a type of database. *
* db_default_release - Get the default releaser for a type of database *
* with the fixed options. *
* db_custom_release - Get the releaser that behaves as specified. *
* db_alloc - Allocate a new database. *
* db_i2key - Manual cast from 'int' to 'DBKey'. *
* db_ui2key - Manual cast from 'unsigned int' to 'DBKey'. *
* db_str2key - Manual cast from 'unsigned char *' to 'DBKey'. *
* db_init - Initialise the database system. *
* db_final - Finalise the database system. *
\*****************************************************************************/
/**
* Returns the fixed options according to the database type.
* Sets required options and unsets unsupported options.
* For numeric databases DB_OPT_DUP_KEY and DB_OPT_RELEASE_KEY are unset.
* @param type Type of the database
* @param options Original options of the database
* @return Fixed options of the database
* @private
* @see #DBType
* @see #DBOptions
* @see #db_default_release(DBType,DBOptions)
* @see common\db.c#db_fix_options(DBType,DBOptions)
*/
DBOptions db_fix_options(DBType type, DBOptions options);
/**
* Returns the default comparator for the type of database.
* @param type Type of database
* @return Comparator for the type of database or NULL if unknown database
* @public
* @see #DBType
* @see #DBComparator
* @see common\db.c#db_default_cmp(DBType)
*/
DBComparator db_default_cmp(DBType type);
/**
* Returns the default hasher for the specified type of database.
* @param type Type of database
* @return Hasher of the type of database or NULL if unknown database
* @public
* @see #DBType
* @see #DBHasher
* @see common\db.c#db_default_hash(DBType)
*/
DBHasher db_default_hash(DBType type);
/**
* Returns the default releaser for the specified type of database with the
* specified options.
* NOTE: the options are fixed by {@link #db_fix_options(DBType,DBOptions)}
* before choosing the releaser
* @param type Type of database
* @param options Options of the database
* @return Default releaser for the type of database with the fixed options
* @public
* @see #DBType
* @see #DBOptions
* @see #DBReleaser
* @see #db_fix_options(DBType,DBOptions)
* @see #db_custom_release(DBRelease)
* @see common\db.c#db_default_release(DBType,DBOptions)
*/
DBReleaser db_default_release(DBType type, DBOptions options);
/**
* Returns the releaser that behaves as <code>which</code> specifies.
* @param which Defines what the releaser releases
* @return Releaser for the specified release options
* @public
* @see #DBRelease
* @see #DBReleaser
* @see #db_default_release(DBType,DBOptions)
* @see common\db.c#db_custom_release(DBRelease)
*/
DBReleaser db_custom_release(DBRelease which);
/**
* Allocate a new database of the specified type.
* It uses the default comparator, hasher and releaser of the specified
* database type and fixed options.
* NOTE: the options are fixed by {@link #db_fix_options(DBType,DBOptions)}
* before creating the database.
* @param file File where the database is being allocated
* @param line Line of the file where the database is being allocated
* @param type Type of database
* @param options Options of the database
* @param maxlen Maximum length of the string to be used as key in string
* databases
* @return The interface of the database
* @public
* @see #DBType
* @see #DBInterface
* @see #db_default_cmp(DBType)
* @see #db_default_hash(DBType)
* @see #db_default_release(DBType,DBOptions)
* @see #db_fix_options(DBType,DBOptions)
* @see common\db.c#db_alloc(const char *,int,DBType,DBOptions,unsigned short)
*/
DBInterface db_alloc(const char *file, int line, DBType type, DBOptions options, unsigned short maxlen);
#ifdef DB_MANUAL_CAST_TO_UNION
/**
* Manual cast from 'int' to the union DBKey.
* Created for compilers that don't support casting to unions.
* @param key Key to be casted
* @return The key as a DBKey union
* @public
* @see #DB_MANUAL_CAST_TO_UNION
* @see #db_ui2key(unsigned int)
* @see #db_str2key(unsigned char *)
* @see common\db.c#db_i2key(int)
*/
DBKey db_i2key(int key);
/**
* Manual cast from 'unsigned int' to the union DBKey.
* Created for compilers that don't support casting to unions.
* @param key Key to be casted
* @return The key as a DBKey union
* @public
* @see #DB_MANUAL_CAST_TO_UNION
* @see #db_i2key(int)
* @see #db_str2key(unsigned char *)
* @see common\db.c#db_ui2key(unsigned int)
*/
DBKey db_ui2key(unsigned int key);
/**
* Manual cast from 'unsigned char *' to the union DBKey.
* Created for compilers that don't support casting to unions.
* @param key Key to be casted
* @return The key as a DBKey union
* @public
* @see #DB_MANUAL_CAST_TO_UNION
* @see #db_i2key(int)
* @see #db_ui2key(unsigned int)
* @see common\db.c#db_str2key(unsigned char *)
*/
DBKey db_str2key(unsigned char *key);
#endif /* DB_MANUAL_CAST_TO_UNION */
/**
* Initialize the database system.
* @public
* @see #db_final(void)
* @see common\db.c#db_init(void)
*/
void db_init(void);
/**
* Finalize the database system.
* Frees the memory used by the block reusage system.
* @public
* @see #db_init(void)
* @see common\db.c#db_final(void)
*/
void db_final(void);
#endif
