source: tags/arb_5.1/ARBDB/adlocal.h

Last change on this file was 6055, checked in by westram, 16 years ago
  • flush_taxonomy_cb() does NOT remove callbacks, if inside delete callback (illegal memaccess - at least during GB_close)
  • GB_close expects that no transaction is running (assertion only)
  • changed callback type in delete-callback-list from (undefined) to GB_CB_DELETE
  • set g_b_old_main to NULL, when finished with callbacks (in gb_do_callback_list)
  • added GB_inside_callback() and GB_get_gb_main_during_cb()
  • comment about restrictions in delete-callbacks
  • added assertion to gb_remove_callback + GB_add_priority_callback (refuses to modify callbacks of already deleted element)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 18.4 KB
Line 
1#ifdef ARBDB_H
2#error Please do not include "arbdb.h" yourself when also including "adlocal.h"
3#endif
4
5#ifndef ADLOCAL_H
6#define ADLOCAL_H
7
8#ifndef _STDIO_H
9#include <stdio.h>
10#endif
11#ifndef _STDINT_H
12#include <stdint.h>
13#endif
14#ifndef ATTRIBUTES_H
15#include <attributes.h>
16#endif
17#ifndef ARBDB_BASE_H
18#include <arbdb_base.h>
19#endif
20
21/* ================ Test memory @@@===================== */
22#if defined(DEBUG)
23#define MEMORY_TEST 1
24#else
25#define MEMORY_TEST 0
26#endif
27
28#ifdef __cplusplus
29inline void ad_use(int, ...) {}
30#else
31void ad_use(int dummy, ...);
32#endif
33
34#define ADUSE(variable) ad_use(1, variable)
35
36#if (MEMORY_TEST==1)
37
38#define gbm_put_memblk(block,size)
39#define gbm_get_memblk(size)            (char*)(GB_calloc(1,size))
40#define gbm_get_mem(size,index)         (char*)(GB_calloc(1,size))
41#define gbm_free_mem(block,size,index)  do { free(block); ADUSE(index); } while(0)
42#define fread(block,size,nelem,stream) (memset(block,0,size*nelem), (fread)(block,size,nelem,stream))
43
44#endif
45
46/* ================ Assert's ======================== */
47
48#ifndef ARB_ASSERT_H
49#include <arb_assert.h>
50#endif
51#define ad_assert(bed) arb_assert(bed)
52
53/* ================================================== */
54
55#define GBTUM_MAGIC_NUMBER        0x17488400
56#define GBTUM_MAGIC_NUMBER_FILTER 0xffffff00
57
58#define GBTUM_MAGIC_REVERSED 0x00844817
59
60#define GB_MAX_PROJECTS          256
61#define GBTUM_COMPRESS_TREE_SIZE 32
62#define GB_MAX_USERS             4
63#define GB_MAX_KEYS              0x1000000 /* 24 bit see flags also */
64
65#define CROSS_BUFFER_DIFF 20
66#define SIZOFINTERN       10
67
68#define GB_SYSTEM_FOLDER   "__SYSTEM__"
69#define GB_SYSTEM_KEY_DATA "@key_data"
70
71#define GB_MAX_MAPPED_FILES 10
72
73
74/********** RELATIVE ADRESSING *************/
75
76#if (MEMORY_TEST==1)
77typedef void                          *GB_REL_ADD;
78typedef char                          *GB_REL_STRING;
79typedef struct gb_data_base_type      *GB_REL_GBDATA;
80typedef struct gb_data_base_type2     *GB_REL_CONTAINER;
81typedef struct gb_header_list_struct  *GB_REL_HLS;
82typedef struct gb_if_entries          *GB_REL_IFES;
83typedef struct gb_index_files_struct  *GB_REL_IFS;
84typedef struct gb_if_entries         **GB_REL_PIFES;
85#else
86typedef long                           GB_REL_ADD;       /* relative adress */
87typedef long                           GB_REL_STRING;    /* relative adress */
88typedef long                           GB_REL_GBDATA;    /* relative adress */
89typedef long                           GB_REL_CONTAINER; /* relative adress */
90typedef long                           GB_REL_HLS;       /* relative adress */
91typedef long                           GB_REL_IFES;      /* relative adress */
92typedef long                           GB_REL_IFS;       /* relative adress */
93typedef long                           GB_REL_PIFES;     /* relative adress */
94#endif
95
96typedef short GB_MAIN_IDX;      /* random-index */
97
98typedef struct gbs_hash_struct  GB_HASH;
99typedef struct gbs_hashi_struct GB_HASHI;
100
101struct GBS_regex;
102struct GBS_string_matcher;
103
104typedef struct GBS_regex          GBS_REGEX;
105typedef struct GBS_string_matcher GBS_MATCHER;
106
107#define GB_MAIN_ARRAY_SIZE 4096
108
109struct GBS_strstruct;
110
111/********************************************/
112
113enum {
114    GBM_CB_INDEX     = -1,
115    GBM_HASH_INDEX   = -2,
116    GBM_HEADER_INDEX = -3,
117    GBM_UNDO         = -4,
118    GBM_DICT_INDEX   = -5,
119    GBM_USER_INDEX   = -6
120};
121
122typedef long gb_bool;
123struct gb_map_header;
124
125#define _GB_UNDO_TYPE_DEFINED
126typedef enum {          /* Warning: Same typedef in arbdb.h */
127    GB_UNDO_NONE,
128    GB_UNDO_KILL,   /* no undo and delete all old undos */
129    GB_UNDO_UNDO,
130    GB_UNDO_REDO,
131    GB_UNDO_UNDO_REDO
132} GB_UNDO_TYPE;
133
134typedef enum gb_changed_types {
135    gb_not_changed       = 0,
136    gb_son_changed       = 2,
137    gb_changed           = 4,
138    gb_created           = 5,
139    gb_deleted           = 6,
140    gb_deleted_in_master = 7
141} GB_CHANGED;
142
143enum gb_open_types {
144    gb_open_all             = 0,
145    gb_open_read_only_all   = 16,
146    gb_open_read_only_small = 17
147};
148
149#ifdef __cplusplus
150extern "C" {
151#endif
152
153    typedef void (*GB_CB)(GBDATA *,int *clientdata, GB_CB_TYPE gbtype);
154
155#ifdef __cplusplus
156}
157#endif
158
159
160typedef int GBQUARK;
161
162/********************* compress ******************/
163enum GB_COMPRESSION_TYPES {
164    GB_COMPRESSION_NONE       = 0,
165    GB_COMPRESSION_RUNLENGTH  = 1,
166    GB_COMPRESSION_HUFFMANN   = 2,
167    GB_COMPRESSION_DICTIONARY = 4,
168    GB_COMPRESSION_SEQUENCE   = 8,
169    GB_COMPRESSION_SORTBYTES  = 16,
170    GB_COMPRESSION_BITS       = 32,
171    GB_COMPRESSION_LAST       = 128
172};
173typedef int GB_NINT;        /* Network byte order int */
174
175typedef struct {
176    int            words;
177    int            textlen;
178    unsigned char *text;
179    GB_NINT       *offsets;     /* in network byte order */
180    GB_NINT       *resort;      /* in network byte order */
181
182} GB_DICTIONARY;
183
184extern int gb_convert_type_2_compression_flags[];
185extern int gb_convert_type_2_sizeof[];
186extern int gb_convert_type_2_appendix_size[];
187extern int gb_verbose_mode;
188
189#define GB_UNCOMPRESSED_SIZE(gbd, type) (GB_GETSIZE(gbd) * gb_convert_type_2_sizeof[type] + gb_convert_type_2_appendix_size[type])
190
191struct gb_compress_tree {
192    char    leave;
193    struct gb_compress_tree *son[2];
194};
195
196enum gb_compress_list_commands {
197    gb_cs_ok   = 0,
198    gb_cs_sub  = 1,
199    gb_cs_id   = 2,
200    gb_cs_end  = 3,
201    gb_cd_node = 4
202};
203
204struct gb_compress_list {
205    enum gb_compress_list_commands command;
206
207    int  value;
208    int  bitcnt;
209    int  bits;
210    int  mask;
211    long count;
212
213    struct gb_compress_list *son[2];
214};
215
216/********************* main ******************/
217
218struct gb_user_struct {
219    char *username;
220    int   userid;
221    int   userbit;
222    int   nusers;               /* number of clients of this user */
223};
224
225struct gb_project_struct {
226    char *projectname;
227    int   projectid;
228
229    struct gb_export_project {
230        struct gb_export_project *next;
231        char                     *username;
232    }   *export_;
233
234    long export_2_users;        /* bits , one bit for each logged in user */
235};
236
237struct gb_data_base_type;
238struct gb_key_struct {
239    char *key;
240
241    long nref;
242    long next_free_key;
243    long nref_last_saved;
244
245    struct gb_data_base_type *gb_key; /* for fast access and dynamic loading */
246    struct gb_data_base_type *gb_master_ali; /* Pointer to the master container */
247    int                       gb_key_disabled; /* There will never be a gb_key */
248    int                       compression_mask; /* maximum compression for this type */
249    GB_DICTIONARY            *dictionary; /* optional dictionary */
250
251};
252
253struct gb_quick_save_struct {
254    char *quick_save_disabled;  /* GB_BOOL if set, than text decsribes reason*/
255    int   last_index;
256};
257
258struct gb_cache_entry_struct {
259    struct gb_data_base_type *gbd;
260
261    long  prev;
262    long  next;
263    char *data;
264    long  clock;
265    int   sizeof_data;
266};
267
268struct gb_cache_struct {
269    struct gb_cache_entry_struct *entries;
270
271    long firstfree_entry;
272    long newest_entry;
273    long oldest_entry;
274    long sum_data_size;
275    long max_data_size;
276    long max_entries;
277};
278
279
280
281// -----------------------------------------------
282//      root structure (one for each database)
283
284struct gbcmc_comm;
285struct g_b_undo_mgr_struct;
286struct gb_callback_list;
287struct gb_data_base_type2;
288struct gb_close_callback_struct;
289
290typedef struct gb_main_type {
291    int transaction;
292    int aborted_transaction;
293    int local_mode;             // GB_TRUE = server, GB_FALSE = client
294    int client_transaction_socket;
295
296    struct gbcmc_comm         *c_link;
297    void                      *server_data;
298    struct gb_data_base_type2 *dummy_father;
299    struct gb_data_base_type2 *data;
300    struct gb_data_base_type  *gb_key_data;
301    char                      *path;
302    enum gb_open_types         opentype;
303    char                      *disabled_path;
304    int                        allow_corrupt_file_recovery;
305
306    struct gb_quick_save_struct qs;
307    struct gb_cache_struct      cache;
308    int                         compression_mask;
309
310    int                   keycnt; /* first non used key */
311    long                  sizeofkeys; /* malloc size */
312    long                  first_free_key; /* index of first gap */
313    struct gb_key_struct *keys;
314    GB_HASH              *key_2_index_hash;
315    long                  key_clock; /* trans. nr. of last change */
316
317    char         *keys_new[256];
318    unsigned int  last_updated;
319    long          last_saved_time;
320    long          last_saved_transaction;
321    long          last_main_saved_transaction;
322
323    GB_UNDO_TYPE        requested_undo_type;
324    GB_UNDO_TYPE        undo_type;
325    struct g_b_undo_mgr_struct *undo;
326
327    char         *dates[256];
328    unsigned int  security_level;
329    int           old_security_level;
330    int           pushed_security_level;
331    long          clock;
332    GB_HASHI     *remote_hash;
333
334    GB_HASH *command_hash;
335    GB_HASH *resolve_link_hash;
336    GB_HASH *table_hash;
337
338    struct gb_close_callback_struct *close_callbacks;
339
340    struct gb_callback_list *cbl; /* contains change-callbacks (after change, until callbacks are done) */
341    struct gb_callback_list *cbl_last;
342
343    struct gb_callback_list *cbld; /* contains delete-callbacks (after delete, until callbacks are done) */
344    struct gb_callback_list *cbld_last;
345
346    struct gb_user_struct    *users[GB_MAX_USERS]; /* user 0 is server */
347    struct gb_project_struct *projects[GB_MAX_PROJECTS]; /* projects */
348    struct gb_user_struct    *this_user;
349    struct gb_project_struct *this_project;
350
351} GB_MAIN_TYPE;
352
353extern GB_MAIN_TYPE *gb_main_array[];
354
355
356typedef enum { ARB_COMMIT, ARB_ABORT, ARB_TRANS } ARB_TRANS_TYPE;
357typedef enum { GB_IGNORE_CASE = 0 , GB_MIND_CASE = 1, GB_CASE_UNDEFINED = 2 } GB_CASE;
358
359// ------------------------------------------------------------------
360//      global data structure that is used for all open databases
361
362struct gb_buffer {
363    char   *mem;
364    size_t  size;
365};
366
367struct gb_local_data {
368    struct gb_buffer buf1, buf2;
369    char *write_buffer;
370    char *write_ptr;
371    long  write_bufsize;
372    long  write_free;
373    int   iamclient;
374    int   search_system_folder;
375
376    struct gb_compress_tree *bituncompress;
377    struct gb_compress_list *bitcompress;
378
379    long bc_size;
380    long gb_compress_keys_count;
381    long gb_compress_keys_level;
382
383    struct gb_main_type *gb_compress_keys_main;
384    ARB_TRANS_TYPE       running_client_transaction;
385    struct {
386        struct gb_data_base_type *gb_main;
387    }   gbl;
388};
389
390extern struct gb_local_data *gb_local;
391extern const uint32_t crctab[];
392
393struct gb_header_flags {
394    unsigned int flags:GB_MAX_USERS; /* public */
395    unsigned int key_quark:24;  /* == 0 -> invalid */
396    unsigned int changed:3;
397    unsigned int ever_changed:1; /* is this element ever changed */
398} ;
399
400struct gb_header_list_struct {  /* public fast flags */
401    struct gb_header_flags flags;
402
403    GB_REL_GBDATA rel_hl_gbd;   /* Typ: (struct gb_data_base_type *) */
404    /* pointer to data
405       if 0 & !key_index -> free data
406       if 0 & key_index -> data only in server */
407};
408
409struct gb_data_list {
410
411    GB_REL_HLS rel_header;  /* Typ: (struct gb_header_list_struct *) */
412
413    int headermemsize;
414    int size;       /* number of valid items */
415    int nheader;    /* size + deleted items */
416};
417struct gb_flag_types {      /* public flags, abort possible */
418    unsigned int type:4;
419    unsigned int security_delete:3;
420    unsigned int security_write:3;
421    unsigned int security_read:3;
422    unsigned int compressed_data:1;
423    unsigned int unused:1;      /* last bit saved */
424    unsigned int user_flags:8;
425    unsigned int temporary:1;   /* ==1 -> dont save entry */
426    unsigned int saved_flags:8;
427};
428struct gb_flag_types2 {     /* private flags, abortable */
429    /* uncritic section undoable */
430    unsigned int last_updated:8;
431    unsigned int usr_ref:7;     /* for user access  */
432    /* critic section, do not update any below */
433    unsigned int folded_container:1;
434    unsigned int update_in_server:1; /* already informed */
435    unsigned int extern_data:1; /* data ref. by pntr*/
436    unsigned int header_changed:1; /* used by container*/
437    unsigned int gbm_index:8;   /* memory section*/
438    unsigned int tisa_index:1;  /* this should be indexed */
439    unsigned int is_indexed:1;  /* this db. field is indexed*/
440};
441
442struct gb_flag_types3 {     /* user and project flags (public)
443                               not abortable !!! */
444    unsigned int project:8;
445    unsigned int unused:24;
446};
447
448struct gb_if_entries
449{
450    GB_REL_IFES   rel_ie_next;  /* Typ: (struct gb_if_entries *)    */
451    GB_REL_GBDATA rel_ie_gbd;   /* Typ: (struct gb_data_base_type *)    */
452};
453
454/** hash index to speed up GB_find(x,x,down_2_level) ***/
455
456struct gb_index_files_struct {
457    GB_REL_IFS  rel_if_next;    /* Typ: (struct gb_index_files_struct *) */
458
459    GBQUARK key;
460    long    hash_table_size;
461    long    nr_of_elements;
462    GB_CASE case_sens;
463
464    GB_REL_PIFES  rel_entries;  /* Typ: (struct gb_if_entries **) */
465};
466
467struct gb_db_extended;
468
469typedef struct gb_data_base_type2 { /* public area */
470    long                   server_id;
471    GB_REL_CONTAINER       rel_father; /* Typ: (struct gb_data_base_type2 *) */
472    struct gb_db_extended *ext;
473    long                   index;
474    struct gb_flag_types   flags;
475    struct gb_flag_types2  flags2; /* privat area */
476    struct gb_flag_types3  flags3;
477    struct gb_data_list    d;
478
479    long index_of_touched_one_son;  /* index of modified son
480                                       in case of a single mod. son
481                                       -1 more than one (or one with ind = 0)
482                                       0    no son
483                                       >0   index */
484    long header_update_date;
485
486    GB_MAIN_IDX main_idx;       /* Typ: (GB_MAIN_TYPE *) */
487    GB_REL_IFS  rel_ifs;        /* Typ: (struct gb_index_files_struct *) */
488
489} GBCONTAINER;
490
491
492struct gb_extern_data2 {
493    char *data;                 /* Typ: (char *) */
494    long  memsize;
495    long  size;
496};
497
498struct GB_INTern_strings2 {
499    char          data[SIZOFINTERN];
500    unsigned char memsize;
501    unsigned char size;
502};
503
504struct GB_INTern2 {
505    char data[SIZOFINTERN];
506};
507
508union gb_data_base_type_union2 {
509    struct GB_INTern_strings2 istr;
510    struct GB_INTern2         in;
511    struct gb_extern_data2    ex;
512};
513
514struct gb_transaction_save {
515    struct gb_flag_types           flags;
516    struct gb_flag_types2          flags2;
517    union gb_data_base_type_union2 info;
518    short                          refcount; /* number of references to this object */
519};
520
521struct gb_callback
522{
523    struct gb_callback     *next;
524    GB_CB                   func;
525    enum gb_call_back_type  type;
526    int                    *clientdata;
527    short                   priority;
528    short                   running;
529};
530
531struct gb_callback_list {
532    struct gb_callback_list    *next;
533    GB_CB                       func;
534    struct gb_transaction_save *old;
535    GB_CB_TYPE                  type;
536    struct gb_data_base_type   *gbd;
537    int                        *clientdata;
538};
539
540/*#undef GBDATA*/
541
542enum gb_undo_commands {
543    _GBCMC_UNDOCOM_REQUEST_NOUNDO_KILL,
544    _GBCMC_UNDOCOM_REQUEST_NOUNDO,
545    _GBCMC_UNDOCOM_REQUEST_UNDO,
546    _GBCMC_UNDOCOM_INFO_UNDO,
547    _GBCMC_UNDOCOM_INFO_REDO,
548    _GBCMC_UNDOCOM_UNDO,
549    _GBCMC_UNDOCOM_REDO,
550
551    _GBCMC_UNDOCOM_SET_MEM = 10000      /* Minimum */
552};
553
554enum gb_scan_quicks_types {
555    GB_SCAN_NO_QUICK,
556    GB_SCAN_NEW_QUICK,
557    GB_SCAN_OLD_QUICK
558};
559
560struct gb_scandir {
561    int                       highest_quick_index;
562    int                       newest_quick_index;
563    unsigned long             date_of_quick_file;
564    enum gb_scan_quicks_types type; /* xxx.arb.quick? or xxx.a?? */
565};
566
567#define GBCM_SERVER_OK_WAIT 3
568#define GBCM_SERVER_ABORTED 2
569#define GBCM_SERVER_FAULT   1
570#define GBCM_SERVER_OK      0
571
572#ifndef ARBDB_H
573# include "arbdb.h"
574#endif
575
576#include "adtune.h"
577#include "adlmacros.h"
578
579/* command interpreter */
580
581#define GBL_MAX_ARGUMENTS 500
582
583typedef struct gbl_struct {
584    char *str;
585} GBL;
586
587typedef struct gbl_command_arguments_struct {
588    GBDATA     *gb_ref;         /* a database entry on which the command is applied (may be species, gene, experiment, group and maybe more) */
589    const char *default_tree_name; /* if we have a default tree, its name is specified here (0 otherwise) */
590    const char *command;        /* the name of the current command */
591
592    int  cinput; const GBL *vinput; /* input streams */
593    int  cparam; const GBL *vparam; /* parameter "streams" */
594    int *coutput; GBL **voutput; /* the output streams */
595
596} GBL_command_arguments;
597
598#ifdef __cplusplus
599extern "C" {
600#endif
601
602    typedef GB_ERROR (*GBL_COMMAND)(GBL_command_arguments *args);
603    /* typedef GB_ERROR (*GBL_COMMAND)(GBDATA *gb_ref, char *com, GBL_client_data *cd,
604       int argcinput, GBL *argvinput, int argcparam,GBL *argvparam, int *argcout, GBL **argvout); */
605
606#ifdef __cplusplus
607}
608#endif
609
610struct GBL_command_table {
611    const char *command_identifier;
612    GBL_COMMAND function;
613};
614
615// -------------------------------
616//      hash index calculation
617// -------------------------------
618
619#define GB_CALC_HASH_INDEX_CASE_SENSITIVE(string,index,size) do {       \
620        const char *local_ptr = (string);                               \
621        int local_i;                                                    \
622        (index) = 0xffffffffL;                                          \
623        while ((local_i=(*(local_ptr++)))) {                            \
624            (index) = crctab[((int)(index)^local_i) & 0xff] ^ ((index) >> 8); \
625        }                                                               \
626        (index) = (index) % (size);                                     \
627    } while(0)
628
629#define GB_CALC_HASH_INDEX_CASE_IGNORED(string,index,size) do {         \
630        const char *local_ptr = (string);                               \
631        int local_i;                                                    \
632        (index) = 0xffffffffL;                                          \
633        while ( (local_i = *(local_ptr++))){                            \
634            (index) = crctab[((int) (index) ^ toupper(local_i)) & 0xff] ^ ((index) >> 8); \
635        }                                                               \
636        (index) = (index) % (size);                                     \
637    } while(0)
638
639#define GB_CALC_HASH_INDEX(string, index, size, caseSens) do {          \
640        if ((caseSens) == GB_IGNORE_CASE)                               \
641            GB_CALC_HASH_INDEX_CASE_IGNORED(string, index, size);       \
642        else                                                            \
643            GB_CALC_HASH_INDEX_CASE_SENSITIVE(string, index, size);     \
644    } while(0)
645
646
647#endif
Note: See TracBrowser for help on using the repository browser.