Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/net/structures/int_map.h

    raadf01e rede63e4  
    5555 *  @param[in] type Inner object type.
    5656 */
    57 #define INT_MAP_DECLARE(name, type)                                                                                             \
     57#define INT_MAP_DECLARE( name, type )                                                                                   \
    5858                                                                                                                                                                \
    5959typedef struct name                     name##_t;                                                                                       \
     
    6363                                                                                                                                                                \
    6464struct  name##_item{                                                                                                                    \
    65         int key;                                                                                                                                \
    66         type * value;                                                                                                                           \
    67         int magic;                                                                                                                              \
     65        int             key;                                                                                                                            \
     66        type *  value;                                                                                                                          \
     67        int             magic;                                                                                                                          \
    6868};                                                                                                                                                              \
    6969                                                                                                                                                                \
    7070struct  name{                                                                                                                                   \
    71         int size;                                                                                                               \
    72         int next;                                                                                                               \
    73         name##_item_ref items;                                                                                                          \
    74         int magic;                                                                                                              \
     71        int                             size;                                                                                                           \
     72        int                             next;                                                                                                           \
     73        name##_item_ref items;                                                                                                          \
     74        int                             magic;                                                                                                          \
    7575};                                                                                                                                                              \
    7676                                                                                                                                                                \
    77 int name##_add(name##_ref map, int key, type * value);                                                  \
    78 void name##_clear(name##_ref map);                                                                                              \
    79 int name##_count(name##_ref map);                                                                                               \
    80 void name##_destroy(name##_ref map);                                                                                    \
    81 void name##_exclude(name##_ref map, int key);                                                                   \
    82 void name##_exclude_index(name##_ref map, int index);                                                   \
    83 type * name##_find(name##_ref map, int key);                                                                    \
    84 int name##_update(name##_ref map, int key, int new_key);                                                \
    85 type * name##_get_index(name##_ref map, int index);                                                             \
    86 int name##_initialize(name##_ref map);                                                                                  \
    87 int name##_is_valid(name##_ref map);                                                                                    \
    88 void name##_item_destroy(name##_item_ref item);                                                                 \
    89 int name##_item_is_valid(name##_item_ref item);
     77int             name##_add( name##_ref map, int key, type * value );                                    \
     78void    name##_clear( name##_ref map );                                                                                 \
     79int             name##_count( name##_ref map );                                                                                 \
     80void    name##_destroy( name##_ref map );                                                                               \
     81void    name##_exclude( name##_ref map, int key );                                                              \
     82void    name##_exclude_index( name##_ref map, int index );                                              \
     83type *  name##_find( name##_ref map, int key );                                                                 \
     84int             name##_update( name##_ref map, int key, int new_key );                                  \
     85type *  name##_get_index( name##_ref map, int index );                                                  \
     86int             name##_initialize( name##_ref map );                                                                    \
     87int             name##_is_valid( name##_ref map );                                                                              \
     88void    name##_item_destroy( name##_item_ref item );                                                    \
     89int             name##_item_is_valid( name##_item_ref item );
    9090
    9191/** Integer to generic type map implementation.
     
    9494 *  @param[in] type Inner object type.
    9595 */
    96 #define INT_MAP_IMPLEMENT(name, type)                                                                                   \
    97                                                                                                                                                                 \
    98 int name##_add(name##_ref map, int key, type * value){                                                  \
    99         if(name##_is_valid(map)){                                                                                                       \
    100                 if(map->next == (map->size - 1)){                                                                               \
    101                         name##_item_ref tmp;                                                                                            \
    102                                                                                                                                                                 \
    103                         tmp = (name##_item_ref) realloc(map->items, sizeof(name##_item_t) * 2 * map->size);     \
    104                         if(! tmp){                                                                                                                      \
    105                                 return ENOMEM;                                                                                                  \
    106                         }                                                                                                                                       \
     96#define INT_MAP_IMPLEMENT( name, type )                                                                                 \
     97                                                                                                                                                                \
     98int name##_add( name##_ref map, int key, type * value ){                                                \
     99        if( name##_is_valid( map )){                                                                                            \
     100                if( map->next == ( map->size - 1 )){                                                                    \
     101                        name##_item_ref tmp;                                                                                            \
     102                                                                                                                                                                \
     103                        tmp = ( name##_item_ref ) realloc( map->items, sizeof( name##_item_t ) * 2 * map->size );       \
     104                        if( ! tmp ) return ENOMEM;                                                                                      \
    107105                        map->size *= 2;                                                                                                         \
    108106                        map->items = tmp;                                                                                                       \
    109107                }                                                                                                                                               \
    110                 map->items[map->next].key = key;                                                                                \
    111                 map->items[map->next].value = value;                                                                    \
    112                 map->items[map->next].magic = INT_MAP_ITEM_MAGIC_VALUE;                                 \
     108                map->items[ map->next ].key = key;                                                                              \
     109                map->items[ map->next ].value = value;                                                                  \
     110                map->items[ map->next ].magic = INT_MAP_ITEM_MAGIC_VALUE;                               \
    113111                ++ map->next;                                                                                                                   \
    114                 map->items[map->next].magic = 0;                                                                                \
     112                map->items[ map->next ].magic = 0;                                                                              \
    115113                return map->next - 1;                                                                                                   \
    116114        }                                                                                                                                                       \
     
    118116}                                                                                                                                                               \
    119117                                                                                                                                                                \
    120 void name##_clear(name##_ref map){                                                                                              \
    121         if(name##_is_valid(map)){                                                                                                       \
    122                 int index;                                                                                                                              \
     118void name##_clear( name##_ref map ){                                                                                    \
     119        if( name##_is_valid( map )){                                                                                            \
     120                int     index;                                                                                                                          \
    123121                                                                                                                                                                \
    124122/*              map->magic = 0;*/                                                                                                               \
    125                 for(index = 0; index < map->next; ++ index){                                                    \
    126                         if(name##_item_is_valid(&(map->items[index]))){                                         \
    127                                 name##_item_destroy(&(map->items[index]));                                              \
     123                for( index = 0; index < map->next; ++ index ){                                                  \
     124                        if( name##_item_is_valid( &( map->items[ index ] ))){                           \
     125                                name##_item_destroy( &( map->items[ index ] ));                                 \
    128126                        }                                                                                                                                       \
    129127                }                                                                                                                                               \
    130128                map->next = 0;                                                                                                                  \
    131                 map->items[map->next].magic = 0;                                                                                \
     129                map->items[ map->next ].magic = 0;                                                                              \
    132130/*              map->magic = INT_MAP_MAGIC_VALUE;*/                                                                             \
    133131        }                                                                                                                                                       \
    134132}                                                                                                                                                               \
    135133                                                                                                                                                                \
    136 int name##_count(name##_ref map){                                                                                               \
    137         return name##_is_valid(map) ? map->next : -1;                                                           \
    138 }                                                                                                                                                               \
    139                                                                                                                                                                 \
    140 void name##_destroy(name##_ref map){                                                                                    \
    141         if(name##_is_valid(map)){                                                                                                       \
    142                 int index;                                                                                                                              \
     134int name##_count( name##_ref map ){                                                                                             \
     135        return name##_is_valid( map ) ? map->next : -1;                                                         \
     136}                                                                                                                                                               \
     137                                                                                                                                                                \
     138void name##_destroy( name##_ref map ){                                                                                  \
     139        if( name##_is_valid( map )){                                                                                            \
     140                int     index;                                                                                                                          \
    143141                                                                                                                                                                \
    144142                map->magic = 0;                                                                                                                 \
    145                 for(index = 0; index < map->next; ++ index){                                                    \
    146                         if(name##_item_is_valid(&(map->items[index]))){                                         \
    147                                 name##_item_destroy(&(map->items[index]));                                              \
    148                         }                                                                                                                                       \
    149                 }                                                                                                                                               \
    150                 free(map->items);                                                                                                               \
    151         }                                                                                                                                                       \
    152 }                                                                                                                                                               \
    153                                                                                                                                                                 \
    154 void name##_exclude(name##_ref map, int key){                                                                   \
    155         if(name##_is_valid(map)){                                                                                                       \
    156                 int index;                                                                                                                              \
    157                                                                                                                                                                 \
    158                 for(index = 0; index < map->next; ++ index){                                                    \
    159                         if(name##_item_is_valid(&(map->items[index])) && (map->items[index].key == key)){       \
    160                                 name##_item_destroy(&(map->items[index]));                                              \
    161                         }                                                                                                                                       \
    162                 }                                                                                                                                               \
    163         }                                                                                                                                                       \
    164 }                                                                                                                                                               \
    165                                                                                                                                                                 \
    166 void name##_exclude_index(name##_ref map, int index){                                                   \
    167         if(name##_is_valid(map) && (index >= 0) && (index < map->next) && name##_item_is_valid(&(map->items[index]))){  \
    168                 name##_item_destroy(&(map->items[index]));                                                              \
    169         }                                                                                                                                                       \
    170 }                                                                                                                                                               \
    171                                                                                                                                                                 \
    172 type * name##_find(name##_ref map, int key){                                                                    \
    173         if(name##_is_valid(map)){                                                                                                       \
    174                 int index;                                                                                                                              \
    175                                                                                                                                                                 \
    176                 for(index = 0; index < map->next; ++ index){                                                    \
    177                         if(name##_item_is_valid(&(map->items[index])) && (map->items[index].key == key)){       \
    178                                 return map->items[index].value;                                                                 \
     143                for( index = 0; index < map->next; ++ index ){                                                  \
     144                        if( name##_item_is_valid( &( map->items[ index ] ))){                           \
     145                                name##_item_destroy( &( map->items[ index ] ));                                 \
     146                        }                                                                                                                                       \
     147                }                                                                                                                                               \
     148                free( map->items );                                                                                                             \
     149        }                                                                                                                                                       \
     150}                                                                                                                                                               \
     151                                                                                                                                                                \
     152void name##_exclude( name##_ref map, int key ){                                                                 \
     153        if( name##_is_valid( map )){                                                                                            \
     154                int     index;                                                                                                                          \
     155                                                                                                                                                                \
     156                for( index = 0; index < map->next; ++ index ){                                                  \
     157                        if( name##_item_is_valid( &( map->items[ index ] )) && ( map->items[ index ].key == key )){     \
     158                                name##_item_destroy( &( map->items[ index ] ));                                 \
     159                        }                                                                                                                                       \
     160                }                                                                                                                                               \
     161        }                                                                                                                                                       \
     162}                                                                                                                                                               \
     163                                                                                                                                                                \
     164void name##_exclude_index( name##_ref map, int index ){                                                 \
     165        if( name##_is_valid( map ) && ( index >= 0 ) && ( index < map->next ) && name##_item_is_valid( &( map->items[ index ] ))){      \
     166                name##_item_destroy( &( map->items[ index ] ));                                                 \
     167        }                                                                                                                                                       \
     168}                                                                                                                                                               \
     169                                                                                                                                                                \
     170type * name##_find( name##_ref map, int key ){                                                                  \
     171        if( name##_is_valid( map )){                                                                                            \
     172                int     index;                                                                                                                          \
     173                                                                                                                                                                \
     174                for( index = 0; index < map->next; ++ index ){                                                  \
     175                        if( name##_item_is_valid( &( map->items[ index ] )) && ( map->items[ index ].key == key )){     \
     176                                return map->items[ index ].value;                                                               \
    179177                        }                                                                                                                                       \
    180178                }                                                                                                                                               \
     
    183181}                                                                                                                                                               \
    184182                                                                                                                                                                \
    185 int name##_update(name##_ref map, int key, int new_key){                                                \
    186         if(name##_is_valid(map)){                                                                                                       \
    187                 int index;                                                                                                                              \
    188                                                                                                                                                                 \
    189                 for(index = 0; index < map->next; ++ index){                                                    \
    190                         if(name##_item_is_valid(&(map->items[index]))){                                         \
    191                                 if(map->items[index].key == new_key){                                                   \
     183int name##_update( name##_ref map, int key, int new_key ){                                              \
     184        if( name##_is_valid( map )){                                                                                            \
     185                int     index;                                                                                                                          \
     186                                                                                                                                                                \
     187                for( index = 0; index < map->next; ++ index ){                                                  \
     188                        if( name##_item_is_valid( &( map->items[ index ] ))){                           \
     189                                if( map->items[ index ].key == new_key ){                                               \
    192190                                        return EEXIST;                                                                                          \
    193                                 }else if(map->items[index].key == key){                                                 \
    194                                         map->items[index].key = new_key;                                                        \
     191                                }else if( map->items[ index ].key == key ){                                             \
     192                                        map->items[ index ].key = new_key;                                                      \
    195193                                        return EOK;                                                                                                     \
    196194                                }                                                                                                                               \
     
    201199}                                                                                                                                                               \
    202200                                                                                                                                                                \
    203 type * name##_get_index(name##_ref map, int index){                                                             \
    204         if(name##_is_valid(map) && (index >= 0) && (index < map->next) && name##_item_is_valid(&(map->items[index]))){  \
    205                 return map->items[index].value;                                                                                 \
     201type * name##_get_index( name##_ref map, int index ){                                                   \
     202        if( name##_is_valid( map ) && ( index >= 0 ) && ( index < map->next ) && name##_item_is_valid( &( map->items[ index ] ))){      \
     203                return map->items[ index ].value;                                                                               \
    206204        }                                                                                                                                                       \
    207205        return NULL;                                                                                                                            \
    208206}                                                                                                                                                               \
    209207                                                                                                                                                                \
    210 int name##_initialize(name##_ref map){                                                                                  \
    211         if(! map){                                                                                                                                      \
    212                 return EINVAL;                                                                                                                  \
    213         }                                                                                                                                                       \
     208int name##_initialize( name##_ref map ){                                                                                \
     209        if( ! map ) return EINVAL;                                                                                                      \
    214210        map->size = 2;                                                                                                                          \
    215211        map->next = 0;                                                                                                                          \
    216         map->items = (name##_item_ref) malloc(sizeof(name##_item_t) * map->size);       \
    217         if(! map->items){                                                                                                                       \
    218                 return ENOMEM;                                                                                                                  \
    219         }                                                                                                                                                       \
    220         map->items[map->next].magic = 0;                                                                                        \
     212        map->items = ( name##_item_ref ) malloc( sizeof( name##_item_t ) * map->size ); \
     213        if( ! map->items ) return ENOMEM;                                                                                       \
     214        map->items[ map->next ].magic = 0;                                                                                      \
    221215        map->magic = INT_MAP_MAGIC_VALUE;                                                                                       \
    222216        return EOK;                                                                                                                                     \
    223217}                                                                                                                                                               \
    224218                                                                                                                                                                \
    225 int name##_is_valid(name##_ref map){                                                                                    \
    226         return map && (map->magic == INT_MAP_MAGIC_VALUE);                                                      \
    227 }                                                                                                                                                               \
    228                                                                                                                                                                 \
    229 void name##_item_destroy(name##_item_ref item){                                                                 \
    230         if(name##_item_is_valid(item)){                                                                                         \
     219int name##_is_valid( name##_ref map ){                                                                                  \
     220        return map && ( map->magic == INT_MAP_MAGIC_VALUE );                                            \
     221}                                                                                                                                                               \
     222                                                                                                                                                                \
     223void name##_item_destroy( name##_item_ref item ){                                                               \
     224        if( name##_item_is_valid( item )){                                                                                      \
    231225                item->magic = 0;                                                                                                                \
    232                 if(item->value){                                                                                                                \
    233                         free(item->value);                                                                                                      \
     226                if( item->value ){                                                                                                              \
     227                        free( item->value );                                                                                            \
    234228                        item->value = NULL;                                                                                                     \
    235229                }                                                                                                                                               \
     
    237231}                                                                                                                                                               \
    238232                                                                                                                                                                \
    239 int name##_item_is_valid(name##_item_ref item){                                                                 \
    240         return item && (item->magic == INT_MAP_ITEM_MAGIC_VALUE);                                       \
     233int name##_item_is_valid( name##_item_ref item ){                                                               \
     234        return item && ( item->magic == INT_MAP_ITEM_MAGIC_VALUE );                                     \
    241235}
    242236
Note: See TracChangeset for help on using the changeset viewer.