Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/structures/char_map.c

    raadf01e r21580dd  
    5757 *  @returns EEXIST if the key character string is already used.
    5858 */
    59 int char_map_add_item(char_map_ref map, const char * identifier, size_t length, const int value);
     59int     char_map_add_item( char_map_ref map, const char * identifier, size_t length, const int value );
    6060
    6161/** Returns the node assigned to the key from the map.
    … …  
    6666 *  @returns NULL if the key is not assigned a node.
    6767 */
    68 char_map_ref char_map_find_node(const char_map_ref map, const char * identifier, const size_t length);
     68char_map_ref    char_map_find_node( const char_map_ref map, const char * identifier, const size_t length );
    6969
    7070/** Returns the value assigned to the map.
    … …  
    7373 *  @returns CHAR_MAP_NULL if the map is not assigned a value.
    7474 */
    75 int char_map_get_value(const char_map_ref map);
     75int     char_map_get_value( const char_map_ref map );
    7676
    7777/** Checks if the map is valid.
    … …  
    8080 *  @returns FALSE otherwise.
    8181 */
    82 int char_map_is_valid(const char_map_ref map);
    83 
    84 int char_map_add(char_map_ref map, const char * identifier, size_t length, const int value){
    85         if(char_map_is_valid(map) && (identifier) && ((length) || (*identifier))){
    86                 int index;
    87 
    88                 for(index = 0; index < map->next; ++ index){
    89                         if(map->items[index]->c == * identifier){
     82int     char_map_is_valid( const char_map_ref map );
     83
     84int char_map_add( char_map_ref map, const char * identifier, size_t length, const int value ){
     85        if( char_map_is_valid( map ) && ( identifier ) && (( length ) || ( * identifier ))){
     86                int     index;
     87
     88                for( index = 0; index < map->next; ++ index ){
     89                        if( map->items[ index ]->c == * identifier ){
    9090                                ++ identifier;
    91                                 if((length > 1) || ((length == 0) && (*identifier))){
    92                                         return char_map_add(map->items[index], identifier, length ? length - 1 : 0, value);
     91                                if(( length > 1 ) || (( length == 0 ) && ( * identifier ))){
     92                                        return char_map_add( map->items[ index ], identifier, length ? length - 1 : 0, value );
    9393                                }else{
    94                                         if(map->items[index]->value != CHAR_MAP_NULL){
    95                                                 return EEXISTS;
    96                                         }
    97                                         map->items[index]->value = value;
     94                                        if( map->items[ index ]->value != CHAR_MAP_NULL ) return EEXISTS;
     95                                        map->items[ index ]->value = value;
    9896                                        return EOK;
    9997                                }
    10098                        }
    10199                }
    102                 return char_map_add_item(map, identifier, length, value);
     100                return char_map_add_item( map, identifier, length, value );
    103101        }
    104102        return EINVAL;
    105103}
    106104
    107 int char_map_add_item(char_map_ref map, const char * identifier, size_t length, const int value){
    108         if(map->next == (map->size - 1)){
    109                 char_map_ref *tmp;
    110 
    111                 tmp = (char_map_ref *) realloc(map->items, sizeof(char_map_ref) * 2 * map->size);
    112                 if(! tmp){
    113                         return ENOMEM;
    114                 }
     105int char_map_add_item( char_map_ref map, const char * identifier, size_t length, const int value ){
     106        if( map->next == ( map->size - 1 )){
     107                char_map_ref    * tmp;
     108
     109                tmp = ( char_map_ref * ) realloc( map->items, sizeof( char_map_ref ) * 2 * map->size );
     110                if( ! tmp ) return ENOMEM;
    115111                map->size *= 2;
    116112                map->items = tmp;
    117113        }
    118         map->items[map->next] = (char_map_ref) malloc(sizeof(char_map_t));
    119         if(! map->items[map->next]){
     114        map->items[ map->next ] = ( char_map_ref ) malloc( sizeof( char_map_t ));
     115        if( ! map->items[ map->next ] ) return ENOMEM;
     116        if( char_map_initialize( map->items[ map->next ] ) != EOK ){
     117                free( map->items[ map->next ] );
     118                map->items[ map->next ] = NULL;
    120119                return ENOMEM;
    121120        }
    122         if(char_map_initialize(map->items[map->next]) != EOK){
    123                 free(map->items[map->next]);
    124                 map->items[map->next] = NULL;
    125                 return ENOMEM;
    126         }
    127         map->items[map->next]->c = * identifier;
     121        map->items[ map->next ]->c = * identifier;
    128122        ++ identifier;
    129123        ++ map->next;
    130         if((length > 1) || ((length == 0) && (*identifier))){
    131                 map->items[map->next - 1]->value = CHAR_MAP_NULL;
    132                 return char_map_add_item(map->items[map->next - 1], identifier, length ? length - 1 : 0, value);
     124        if(( length > 1 ) || (( length == 0 ) && ( * identifier ))){
     125                map->items[ map->next - 1 ]->value = CHAR_MAP_NULL;
     126                return char_map_add_item( map->items[ map->next - 1 ], identifier, length ? length - 1 : 0, value );
    133127        }else{
    134                 map->items[map->next - 1]->value = value;
     128                map->items[ map->next - 1 ]->value = value;
    135129        }
    136130        return EOK;
    137131}
    138132
    139 void char_map_destroy(char_map_ref map){
    140         if(char_map_is_valid(map)){
    141                 int index;
     133void char_map_destroy( char_map_ref map ){
     134        if( char_map_is_valid( map )){
     135                int     index;
    142136
    143137                map->magic = 0;
    144                 for(index = 0; index < map->next; ++ index){
    145                         char_map_destroy(map->items[index]);
     138                for( index = 0; index < map->next; ++ index ){
     139                        char_map_destroy( map->items[ index ] );
    146140                }
    147                 free(map->items);
     141                free( map->items );
    148142                map->items = NULL;
    149143        }
    150144}
    151145
    152 int char_map_exclude(char_map_ref map, const char * identifier, size_t length){
    153         char_map_ref node;
    154 
    155         node = char_map_find_node(map, identifier, length);
    156         if(node){
    157                 int value;
     146int char_map_exclude( char_map_ref map, const char * identifier, size_t length ){
     147        char_map_ref    node;
     148
     149        node = char_map_find_node( map, identifier, length );
     150        if( node ){
     151                int     value;
    158152
    159153                value = node->value;
    … …  
    164158}
    165159
    166 int char_map_find(const char_map_ref map, const char * identifier, size_t length){
    167         char_map_ref node;
    168 
    169         node = char_map_find_node(map, identifier, length);
     160int char_map_find( const char_map_ref map, const char * identifier, size_t length ){
     161        char_map_ref    node;
     162
     163        node = char_map_find_node( map, identifier, length );
    170164        return node ? node->value : CHAR_MAP_NULL;
    171165}
    172166
    173 char_map_ref char_map_find_node(const char_map_ref map, const char * identifier, size_t length){
    174         if(! char_map_is_valid(map)){
    175                 return NULL;
    176         }
    177         if(length || (*identifier)){
    178                 int index;
    179 
    180                 for(index = 0; index < map->next; ++ index){
    181                         if(map->items[index]->c == * identifier){
     167char_map_ref char_map_find_node( const char_map_ref map, const char * identifier, size_t length ){
     168        if( ! char_map_is_valid( map )) return NULL;
     169        if( length || ( * identifier )){
     170                int     index;
     171
     172                for( index = 0; index < map->next; ++ index ){
     173                        if( map->items[ index ]->c == * identifier ){
    182174                                ++ identifier;
    183                                 if(length == 1){
    184                                         return map->items[index];
    185                                 }
    186                                 return char_map_find_node(map->items[index], identifier, length ? length - 1 : 0);
     175                                if( length == 1 ) return map->items[ index ];
     176                                return char_map_find_node( map->items[ index ], identifier, length ? length - 1 : 0 );
    187177                        }
    188178                }
    … …  
    192182}
    193183
    194 int char_map_get_value(const char_map_ref map){
    195         return char_map_is_valid(map) ? map->value : CHAR_MAP_NULL;
    196 }
    197 
    198 int char_map_initialize(char_map_ref map){
    199         if(! map){
    200                 return EINVAL;
    201         }
     184int char_map_get_value( const char_map_ref map ){
     185        return char_map_is_valid( map ) ? map->value : CHAR_MAP_NULL;
     186}
     187
     188int char_map_initialize( char_map_ref map ){
     189        if( ! map ) return EINVAL;
    202190        map->c = '\0';
    203191        map->value = CHAR_MAP_NULL;
    204192        map->size = 2;
    205193        map->next = 0;
    206         map->items = malloc(sizeof(char_map_ref) * map->size);
    207         if(! map->items){
     194        map->items = malloc( sizeof( char_map_ref ) * map->size );
     195        if( ! map->items ){
    208196                map->magic = 0;
    209197                return ENOMEM;
    210198        }
    211         map->items[map->next] = NULL;
     199        map->items[ map->next ] = NULL;
    212200        map->magic = CHAR_MAP_MAGIC_VALUE;
    213201        return EOK;
    214202}
    215203
    216 int char_map_is_valid(const char_map_ref map){
    217         return map && (map->magic == CHAR_MAP_MAGIC_VALUE);
    218 }
    219 
    220 int char_map_update(char_map_ref map, const char * identifier, const size_t length, const int value){
    221         char_map_ref node;
    222 
    223 //      if(! char_map_is_valid(map)) return EINVAL;
    224         node = char_map_find_node(map, identifier, length);
    225         if(node){
     204int char_map_is_valid( const char_map_ref map ){
     205        return map && ( map->magic == CHAR_MAP_MAGIC_VALUE );
     206}
     207
     208int char_map_update( char_map_ref map, const char * identifier, const size_t length, const int value ){
     209        char_map_ref    node;
     210
     211//      if( ! char_map_is_valid( map )) return EINVAL;
     212        node = char_map_find_node( map, identifier, length );
     213        if( node ){
    226214                node->value = value;
    227215                return EOK;
    228216        }else{
    229                 return char_map_add(map, identifier, length, value);
     217                return char_map_add( map, identifier, length, value );
    230218        }
    231219}
Note: See TracChangeset for help on using the changeset viewer.