summaryrefslogtreecommitdiff
path: root/src/common/db.h
blob: b17ae27f9ea4641428e00d1e75f790dadef93c93 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
/*****************************************************************************\
 *  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);

// Link DB System - From jAthena
struct linkdb_node {
	struct linkdb_node *next;
	struct linkdb_node *prev;
	void               *key;
	void               *data;
};

void  linkdb_insert ( struct linkdb_node** head, void *key, void* data); // �d�����l�����Ȃ�
void  linkdb_replace( struct linkdb_node** head, void *key, void* data); // �d�����l������
void* linkdb_search ( struct linkdb_node** head, void *key);
void* linkdb_erase  ( struct linkdb_node** head, void *key);
void  linkdb_final  ( struct linkdb_node** head );

#endif