Changeset b5e68c8 in mainline for uspace/lib/c/include/adt/int_map.h


Ignore:
Timestamp:
2011-05-12T16:49:44Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f36787d7
Parents:
e80329d6 (diff), 750636a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/include/adt/int_map.h

    re80329d6 rb5e68c8  
    4949#define INT_MAP_ITEM_MAGIC_VALUE        0x55667788
    5050
     51/** Generic destructor function pointer. */
     52#define DTOR_T(identifier) \
     53        void (*identifier)(const void *)
     54
    5155/** Integer to generic type map declaration.
    5256 *
    … …  
    5660#define INT_MAP_DECLARE(name, type) \
    5761        typedef struct name name##_t; \
    58         typedef name##_t *name##_ref; \
    5962        typedef struct name##_item name##_item_t; \
    60         typedef name##_item_t *name##_item_ref; \
    6163        \
    6264        struct  name##_item { \
    … …  
    6971                int size; \
    7072                int next; \
    71                 name##_item_ref items; \
     73                name##_item_t *items; \
    7274                int magic; \
    7375        }; \
    7476        \
    75         int name##_add(name##_ref, int, type *); \
    76         void name##_clear(name##_ref); \
    77         int name##_count(name##_ref); \
    78         void name##_destroy(name##_ref); \
    79         void name##_exclude(name##_ref, int); \
    80         void name##_exclude_index(name##_ref, int); \
    81         type *name##_find(name##_ref, int); \
    82         int name##_update(name##_ref, int, int); \
    83         type *name##_get_index(name##_ref, int); \
    84         int name##_initialize(name##_ref); \
    85         int name##_is_valid(name##_ref); \
    86         void name##_item_destroy(name##_item_ref); \
    87         int name##_item_is_valid(name##_item_ref);
     77        int name##_add(name##_t *, int, type *); \
     78        void name##_clear(name##_t *, DTOR_T()); \
     79        int name##_count(name##_t *); \
     80        void name##_destroy(name##_t *, DTOR_T()); \
     81        void name##_exclude(name##_t *, int, DTOR_T()); \
     82        void name##_exclude_index(name##_t *, int, DTOR_T()); \
     83        type *name##_find(name##_t *, int); \
     84        int name##_update(name##_t *, int, int); \
     85        type *name##_get_index(name##_t *, int); \
     86        int name##_initialize(name##_t *); \
     87        int name##_is_valid(name##_t *); \
     88        void name##_item_destroy(name##_item_t *, DTOR_T()); \
     89        int name##_item_is_valid(name##_item_t *);
    8890
    8991/** Integer to generic type map implementation.
    … …  
    9597 */
    9698#define INT_MAP_IMPLEMENT(name, type) \
    97         int name##_add(name##_ref map, int key, type *value) \
     99        int name##_add(name##_t *map, int key, type *value) \
    98100        { \
    99101                if (name##_is_valid(map)) { \
    100102                        if (map->next == (map->size - 1)) { \
    101                                 name##_item_ref tmp; \
    102                                 tmp = (name##_item_ref) realloc(map->items, \
     103                                name##_item_t *tmp; \
     104                                tmp = (name##_item_t *) realloc(map->items, \
    103105                                    sizeof(name##_item_t) * 2 * map->size); \
    104106                                if (!tmp) \
    … …  
    117119        } \
    118120        \
    119         void name##_clear(name##_ref map) \
     121        void name##_clear(name##_t *map, DTOR_T(dtor)) \
    120122        { \
    121123                if (name##_is_valid(map)) { \
    … …  
    124126                                if (name##_item_is_valid(&map->items[index])) { \
    125127                                        name##_item_destroy( \
    126                                             &map->items[index]); \
     128                                            &map->items[index], dtor); \
    127129                                } \
    128130                        } \
    … …  
    132134        } \
    133135        \
    134         int name##_count(name##_ref map) \
     136        int name##_count(name##_t *map) \
    135137        { \
    136138                return name##_is_valid(map) ? map->next : -1; \
    137139        } \
    138140        \
    139         void name##_destroy(name##_ref map) \
     141        void name##_destroy(name##_t *map, DTOR_T(dtor)) \
    140142        { \
    141143                if (name##_is_valid(map)) { \
    … …  
    145147                                if (name##_item_is_valid(&map->items[index])) { \
    146148                                        name##_item_destroy( \
    147                                             &map->items[index]); \
     149                                            &map->items[index], dtor); \
    148150                                } \
    149151                        } \
    … …  
    152154        } \
    153155        \
    154         void name##_exclude(name##_ref map, int key) \
     156        void name##_exclude(name##_t *map, int key, DTOR_T(dtor)) \
    155157        { \
    156158                if (name##_is_valid(map)) { \
    … …  
    160162                                    (map->items[index].key == key)) { \
    161163                                        name##_item_destroy( \
    162                                             &map->items[index]); \
    163                                 } \
    164                         } \
    165                 } \
    166         } \
    167         \
    168         void name##_exclude_index(name##_ref map, int index) \
     164                                            &map->items[index], dtor); \
     165                                } \
     166                        } \
     167                } \
     168        } \
     169        \
     170        void name##_exclude_index(name##_t *map, int index, DTOR_T(dtor)) \
    169171        { \
    170172                if (name##_is_valid(map) && (index >= 0) && \
    171173                    (index < map->next) && \
    172174                    name##_item_is_valid(&map->items[index])) { \
    173                         name##_item_destroy(&map->items[index]); \
    174                 } \
    175         } \
    176         \
    177         type *name##_find(name##_ref map, int key) \
     175                        name##_item_destroy(&map->items[index], dtor); \
     176                } \
     177        } \
     178        \
     179        type *name##_find(name##_t *map, int key) \
    178180        { \
    179181                if (name##_is_valid(map)) { \
    … …  
    189191        } \
    190192        \
    191         int name##_update(name##_ref map, int key, int new_key) \
     193        int name##_update(name##_t *map, int key, int new_key) \
    192194        { \
    193195                if (name##_is_valid(map)) { \
    … …  
    208210        } \
    209211        \
    210         type *name##_get_index(name##_ref map, int index) \
     212        type *name##_get_index(name##_t *map, int index) \
    211213        { \
    212214                if (name##_is_valid(map) && (index >= 0) && \
    … …  
    218220        } \
    219221        \
    220         int name##_initialize(name##_ref map) \
     222        int name##_initialize(name##_t *map) \
    221223        { \
    222224                if (!map) \
    … …  
    224226                map->size = 2; \
    225227                map->next = 0; \
    226                 map->items = (name##_item_ref) malloc(sizeof(name##_item_t) * \
     228                map->items = (name##_item_t *) malloc(sizeof(name##_item_t) * \
    227229                    map->size); \
    228230                if (!map->items) \
    … …  
    233235        } \
    234236        \
    235         int name##_is_valid(name##_ref map) \
     237        int name##_is_valid(name##_t *map) \
    236238        { \
    237239                return map && (map->magic == INT_MAP_MAGIC_VALUE); \
    238240        } \
    239241        \
    240         void name##_item_destroy(name##_item_ref item) \
     242        void name##_item_destroy(name##_item_t *item, DTOR_T(dtor)) \
    241243        { \
    242244                if (name##_item_is_valid(item)) { \
    243245                        item->magic = 0; \
    244246                        if (item->value) { \
    245                                 free(item->value); \
     247                                if (dtor) \
     248                                        dtor(item->value); \
    246249                                item->value = NULL; \
    247250                        } \
    … …  
    249252        } \
    250253        \
    251         int name##_item_is_valid(name##_item_ref item) \
     254        int name##_item_is_valid(name##_item_t *item) \
    252255        { \
    253256                return item && (item->magic == INT_MAP_ITEM_MAGIC_VALUE); \
Note: See TracChangeset for help on using the changeset viewer.