Subversion Repositories HelenOS

Rev

Rev 3846 | Rev 3912 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3666 mejdrech 1 
/*
2 
 * Copyright (c) 2008 Lukas Mejdrech
3 
 * All rights reserved.
4 
 *
5 
 * Redistribution and use in source and binary forms, with or without
6 
 * modification, are permitted provided that the following conditions
7 
 * are met:
8 
 *
9 
 * - Redistributions of source code must retain the above copyright
10 
 *   notice, this list of conditions and the following disclaimer.
11 
 * - Redistributions in binary form must reproduce the above copyright
12 
 *   notice, this list of conditions and the following disclaimer in the
13 
 *   documentation and/or other materials provided with the distribution.
14 
 * - The name of the author may not be used to endorse or promote products
15 
 *   derived from this software without specific prior written permission.
16 
 *
17 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
 */
28 
 
29 
/** @addtogroup net
3846 mejdrech 30 
 *  @{
3666 mejdrech 31 
 */
32 
 
33 
/** @file
3846 mejdrech 34 
 *  A character string to integer map implementation file.
3666 mejdrech 35 
 */
36 
 
37 
#include <errno.h>
38 
#include <malloc.h>
39 
#include <unistd.h>
40 
#include <string.h>
41 
 
42 
#include "char_map.h"
43 
 
3846 mejdrech 44 
/** An&nbsp;internal magic value for a&nbsp;consistency check.
45 
 */
3666 mejdrech 46 
#define CHAR_MAP_MAGIC_VALUE    0x12345611
47 
 
3846 mejdrech 48 
/** Adds the value with the key to the map.
49 
 *  Creates new nodes to map the key.
50 
 *  @param map The character string to integer map. Input/output parameter.
51 
 *  @param identifier The key zero ('\0') terminated character string. The key character string is processed until the first terminating zero ('\0') character after the given length is found. Input parameter.
52 
 *  @param length The key character string length. The parameter may be zero (0) which means that the string is processed until the terminating zero ('\0') character is found. Input parameter.
53 
 *  @param value The integral value to be stored for the key character string. Input parameter.
54 
 *  @returns EOK on success.
55 
 *  @returns ENOMEM if there is no memory left.
56 
 *  @returns EEXIST if the key character string is already used.
57 
 */
58 
int char_map_add_item( char_map_ref map, const char * identifier, size_t length, const int value );
3666 mejdrech 59 
 
3846 mejdrech 60 
/** Returns the node assigned to the key from the map.
61 
 *  @param map The character string to integer map. Input parameter.
62 
 *  @param identifier The key zero ('\0') terminated character string. The key character string is processed until the first terminating zero ('\0') character after the given length is found. Input parameter.
63 
 *  @param length The key character string length. The parameter may be zero (0) which means that the string is processed until the terminating zero ('\0') character is found. Input parameter.
64 
 *  @returns The node holding the integral value assigned to the key character string.
65 
 *  @returns NULL if the key is not assigned a&nbsp;node.
66 
 */
67 
char_map_ref    char_map_find_node( const char_map_ref map, const char * identifier, const size_t length );
68 
 
69 
/** Checks if the map is valid.
70 
 *  @param map The character string to integer map. Input parameter.
71 
 *  @returns TRUE if the map is valid.
72 
 *  @returns FALSE otherwise.
73 
 */
74 
int char_map_is_valid( const char_map_ref map );
75 
 
76 
int char_map_add( char_map_ref map, const char * identifier, size_t length, const int value ){
77 
    if( char_map_is_valid( map ) && ( identifier ) && (( length ) || ( * identifier ))){
3666 mejdrech 78 
        int index;
79 
 
80 
        for( index = 0; index < map->next; ++ index ){
81 
            if( map->items[ index ]->c == * identifier ){
82 
                ++ identifier;
3846 mejdrech 83 
                if( length ) -- length;
84 
                if( length || ( * identifier )){
85 
                    return char_map_add( map->items[ index ], identifier, length, value );
3666 mejdrech 86 
                }else{
87 
                    if( map->items[ index ]->value != CHAR_MAP_NULL ) return EEXISTS;
88 
                    map->items[ index ]->value = value;
89 
                    return EOK;
90 
                }
91 
            }
92 
        }
3846 mejdrech 93 
        return char_map_add_item( map, identifier, length, value );
3666 mejdrech 94 
    }
95 
    return EINVAL;
96 
}
97 
 
3846 mejdrech 98 
int char_map_add_item( char_map_ref map, const char * identifier, size_t length, const int value ){
3666 mejdrech 99 
    if( map->next == ( map->size - 1 )){
100 
        char_map_ref    * tmp;
101 
 
102 
        tmp = ( char_map_ref * ) malloc( sizeof( char_map_ref ) * 2 * map->size );
103 
        if( ! tmp ) return ENOMEM;
104 
        map->size *= 2;
105 
        memcpy( tmp, map->items, sizeof( char_map_ref ) * map->next );
106 
        free( map->items );
107 
        map->items = tmp;
108 
    }
109 
    map->items[ map->next ] = ( char_map_ref ) malloc( sizeof( char_map_t ));
110 
    if( ! map->items[ map->next ] ) return ENOMEM;
111 
    char_map_initialize( map->items[ map->next ] );
112 
    map->items[ map->next ]->c = * identifier;
113 
    ++ identifier;
3846 mejdrech 114 
    if( length ) -- length;
115 
    ++ map->next;
116 
    if( length || ( * identifier )){
117 
        map->items[ map->next - 1 ]->value = CHAR_MAP_NULL;
118 
        return char_map_add_item( map->items[ map->next - 1 ], identifier, length, value );
3666 mejdrech 119 
    }else{
3846 mejdrech 120 
        map->items[ map->next - 1 ]->value = value;
3666 mejdrech 121 
    }
122 
    return EOK;
123 
}
124 
 
125 
void char_map_destroy( char_map_ref map ){
126 
    if( char_map_is_valid( map )){
127 
        int index;
128 
 
129 
        map->magic = 0;
130 
        for( index = 0; index < map->next; ++ index ){
131 
            char_map_destroy( map->items[ index ] );
132 
        }
133 
        free( map->items );
134 
    }
135 
}
136 
 
3846 mejdrech 137 
int char_map_exclude( char_map_ref map, const char * identifier, size_t length ){
3666 mejdrech 138 
    char_map_ref    node;
139 
 
3846 mejdrech 140 
    node = char_map_find_node( map, identifier, length );
3666 mejdrech 141 
    if( node ){
142 
        int value;
143 
 
144 
        value = node->value;
145 
        node->value = CHAR_MAP_NULL;
146 
        return value;
147 
    }
148 
    return CHAR_MAP_NULL;
149 
}
150 
 
3846 mejdrech 151 
int char_map_find( const char_map_ref map, const char * identifier, size_t length ){
3666 mejdrech 152 
    char_map_ref    node;
153 
 
3846 mejdrech 154 
    node = char_map_find_node( map, identifier, length );
3666 mejdrech 155 
    return node ? node->value : CHAR_MAP_NULL;
156 
}
157 
 
3846 mejdrech 158 
char_map_ref char_map_find_node( const char_map_ref map, const char * identifier, size_t length ){
3666 mejdrech 159 
    if( ! char_map_is_valid( map )) return NULL;
3846 mejdrech 160 
    if( length ) -- length;
161 
    if( length || ( * identifier )){
3666 mejdrech 162 
        int index;
163 
 
164 
        for( index = 0; index < map->next; ++ index ){
165 
            if( map->items[ index ]->c == * identifier ){
166 
                ++ identifier;
3846 mejdrech 167 
                return char_map_find_node( map->items[ index ], identifier, length );
3666 mejdrech 168 
            }
169 
        }
170 
        return NULL;
171 
    }
172 
    return map;
173 
}
174 
 
3846 mejdrech 175 
int char_map_get_value( const char_map_ref map ){
3666 mejdrech 176 
    return char_map_is_valid( map ) ? map->value : CHAR_MAP_NULL;
177 
}
178 
 
179 
int char_map_initialize( char_map_ref map ){
180 
    if( ! map ) return EINVAL;
181 
    map->c = 0;
182 
    map->value = CHAR_MAP_NULL;
183 
    map->size = 2;
184 
    map->next = 0;
185 
    map->items = malloc( sizeof( char_map_ref ) * map->size );
186 
    if( ! map->items ) return ENOMEM;
187 
    map->items[ map->next ] = NULL;
188 
    map->magic = CHAR_MAP_MAGIC_VALUE;
189 
    return EOK;
190 
}
191 
 
3846 mejdrech 192 
int char_map_is_valid( const char_map_ref map ){
3666 mejdrech 193 
    return map && ( map->magic == CHAR_MAP_MAGIC_VALUE );
194 
}
195 
 
3846 mejdrech 196 
int char_map_update( char_map_ref map, const char * identifier, const size_t length, const int value ){
3666 mejdrech 197 
    char_map_ref    node;
198 
 
199 
//  if( ! char_map_is_valid( map )) return EINVAL;
3846 mejdrech 200 
    node = char_map_find_node( map, identifier, length );
3666 mejdrech 201 
    if( node ){
202 
        node->value = value;
203 
        return EOK;
204 
    }else{
3846 mejdrech 205 
        return char_map_add( map, identifier, length, value );
3666 mejdrech 206 
    }
207 
}
208 
 
209 
/** @}
210 
 */