docs/api-2.1/map_8h_source.html

 /*
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
  *
  * Copyright 2017 Mike Becker, Olaf Wintermann All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *   1. Redistributions of source code must retain the above copyright
  *      notice, this list of conditions and the following disclaimer.
  *
  *   2. Redistributions in binary form must reproduce the above copyright
  *      notice, this list of conditions and the following disclaimer in the
  *      documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */

 #ifndef UCX_MAP_H
 #define UCX_MAP_H

 #include "ucx.h"
 #include "string.h"
 #include "allocator.h"
 #include <stdio.h>

 #ifdef  __cplusplus
 extern "C" {
 #endif

 #define UCX_MAP_FOREACH(key,value,iter) \
         for(UcxKey key;ucx_map_iter_next(&iter,&key, (void**)&value);)

 typedef struct UcxMap          UcxMap;

 typedef struct UcxKey          UcxKey;

 typedef struct UcxMapElement   UcxMapElement;

 typedef struct UcxMapIterator  UcxMapIterator;

 struct UcxMap {
     UcxAllocator  *allocator;
     UcxMapElement **map;
     size_t        size;
     size_t        count;
 };

 struct UcxKey {
     const void *data;
     size_t     len;
     int        hash;
 };

 struct UcxMapKey {
     void    *data;
     size_t  len;
     int     hash;
 };

 struct UcxMapElement {
     void              *data;

     UcxMapElement     *next;

     struct UcxMapKey  key;
 };

 struct UcxMapIterator {
     UcxMap const  *map;

     UcxMapElement *cur;

     size_t        index;
 };

 UcxMap *ucx_map_new(size_t size);

 UcxMap *ucx_map_new_a(UcxAllocator *allocator, size_t size);

 void ucx_map_free(UcxMap *map);

 void ucx_map_free_content(UcxMap *map, ucx_destructor destr);

 void ucx_map_clear(UcxMap *map);


 int ucx_map_copy(UcxMap const *from, UcxMap *to, copy_func fnc, void *data);

 UcxMap *ucx_map_clone(UcxMap const *map, copy_func fnc, void *data);

 UcxMap *ucx_map_clone_a(UcxAllocator *allocator,
                         UcxMap const *map, copy_func fnc, void *data);

 int ucx_map_rehash(UcxMap *map);

 int ucx_map_put(UcxMap *map, UcxKey key, void *value);

 void* ucx_map_get(UcxMap const *map, UcxKey key);

 void* ucx_map_remove(UcxMap *map, UcxKey key);

 #define ucx_map_sstr_put(map, key, value) \
     ucx_map_put(map, ucx_key(key.ptr, key.length), (void*)value)

 #define ucx_map_cstr_put(map, key, value) \
     ucx_map_put(map, ucx_key(key, strlen(key)), (void*)value)

 #define ucx_map_int_put(map, key, value) \
     ucx_map_put(map, ucx_key(&key, sizeof(key)), (void*)value)

 #define ucx_map_sstr_get(map, key) \
     ucx_map_get(map, ucx_key(key.ptr, key.length))

 #define ucx_map_cstr_get(map, key) \
     ucx_map_get(map, ucx_key(key, strlen(key)))

 #define ucx_map_int_get(map, key) \
     ucx_map_get(map, ucx_key(&key, sizeof(int)))

 #define ucx_map_sstr_remove(map, key) \
     ucx_map_remove(map, ucx_key(key.ptr, key.length))

 #define ucx_map_cstr_remove(map, key) \
     ucx_map_remove(map, ucx_key(key, strlen(key)))

 #define ucx_map_int_remove(map, key) \
     ucx_map_remove(map, ucx_key(&key, sizeof(key)))

 UcxKey ucx_key(const void *data, size_t len);

 int ucx_hash(const char *data, size_t len);

 UcxMapIterator ucx_map_iterator(UcxMap const *map);

 int ucx_map_iter_next(UcxMapIterator *iterator, UcxKey *key, void **value);

 UcxMap* ucx_map_union(const UcxMap *first, const UcxMap *second,
                       copy_func cpfnc, void* cpdata);

 UcxMap* ucx_map_union_a(UcxAllocator *allocator,
                         const UcxMap *first, const UcxMap *second,
                         copy_func cpfnc, void* cpdata);

 UcxMap* ucx_map_intersection(const UcxMap *first, const UcxMap *second,
                              copy_func cpfnc, void* cpdata);

 UcxMap* ucx_map_intersection_a(UcxAllocator *allocator,
                                const UcxMap *first, const UcxMap *second,
                                copy_func cpfnc, void* cpdata);

 UcxMap* ucx_map_difference(const UcxMap *first, const UcxMap *second,
                            copy_func cpfnc, void* cpdata);

 UcxMap* ucx_map_difference_a(UcxAllocator *allocator,
                              const UcxMap *first, const UcxMap *second,
                              copy_func cpfnc, void* cpdata);


 #ifdef  __cplusplus
 }
 #endif

 #endif  /* UCX_MAP_H */

copy_func
void *(* copy_func)(const void *, void *)
Function pointer to a copy function.
Definition: ucx.h:106

universe@390: UcxMapIterator::index
size_t index
The current index of the element list array.
Definition: map.h:138

universe@390: UcxMapKey::len
size_t len
The length of the key data.
Definition: map.h:107

universe@390: ucx_map_difference_a
UcxMap * ucx_map_difference_a(UcxAllocator *allocator, const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
Returns the difference of two maps.
Definition: map.c:386

universe@390: string.h
Bounded string implementation.

universe@390: ucx.h
Main UCX Header providing most common definitions.

universe@390: ucx_hash
int ucx_hash(const char *data, size_t len)
Computes a murmur hash-2.
Definition: map.c:260

universe@390: UcxMapKey::hash
int hash
The hash value of the key data.
Definition: map.h:109

universe@390: ucx_map_free_content
void ucx_map_free_content(UcxMap *map, ucx_destructor destr)
Frees the contents of a hash map.
Definition: map.c:85

universe@390: ucx_map_get
void * ucx_map_get(UcxMap const *map, UcxKey key)
Retrieves a value by using a key.
Definition: map.c:243

universe@390: ucx_map_iterator
UcxMapIterator ucx_map_iterator(UcxMap const *map)
Creates an iterator for a map.
Definition: map.c:302

universe@390: ucx_map_union
UcxMap * ucx_map_union(const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
Returns the union of two maps.
Definition: map.c:343

universe@390: UcxKey::hash
int hash
A cache for the hash value of the key data.
Definition: map.h:99

universe@390: ucx_map_clear
void ucx_map_clear(UcxMap *map)
Clears a hash map.
Definition: map.c:97

universe@390: ucx_map_difference
UcxMap * ucx_map_difference(const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
Returns the difference of two maps.
Definition: map.c:380

universe@390: UcxMapElement
Structure for an element of a UcxMap.
Definition: map.h:113

universe@390: UcxKey
Structure to publicly denote a key of a UcxMap.
Definition: map.h:93

universe@390: UcxMap::count
size_t count
The count of elements currently stored in this map.
Definition: map.h:89

universe@390: UcxMapElement::next
UcxMapElement * next
A pointer to the next element in the current list.
Definition: map.h:118

universe@390: ucx_map_union_a
UcxMap * ucx_map_union_a(UcxAllocator *allocator, const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
Returns the union of two maps.
Definition: map.c:349

universe@390: UcxMapIterator::map
UcxMap const  * map
The map to iterate over.
Definition: map.h:127

universe@390: UcxMapIterator
Structure for an iterator over a UcxMap.
Definition: map.h:125

universe@390: UcxMapElement::data
void * data
The value data.
Definition: map.h:115

universe@390: ucx_map_copy
int ucx_map_copy(UcxMap const *from, UcxMap *to, copy_func fnc, void *data)
Copies contents from a map to another map using a copy function.
Definition: map.c:106

universe@390: UcxAllocator
UCX allocator data structure containing memory management functions.
Definition: allocator.h:88

universe@390: ucx_key
UcxKey ucx_key(const void *data, size_t len)
Creates a UcxKey based on the given data.
Definition: map.c:251

universe@390: ucx_map_new
UcxMap * ucx_map_new(size_t size)
Creates a new hash map with the specified size.
Definition: map.c:34

universe@390: UcxMapIterator::cur
UcxMapElement * cur
The current map element.
Definition: map.h:130

universe@390: ucx_map_new_a
UcxMap * ucx_map_new_a(UcxAllocator *allocator, size_t size)
Creates a new hash map with the specified size using a UcxAllocator.
Definition: map.c:38

universe@390: UcxMap::allocator
UcxAllocator * allocator
An allocator that is used for the map elements.
Definition: map.h:83

universe@390: UcxMapKey
Internal structure for a key of a UcxMap.
Definition: map.h:103

universe@390: ucx_map_put
int ucx_map_put(UcxMap *map, UcxKey key, void *value)
Puts a key/value-pair into the map.
Definition: map.c:158

universe@390: ucx_map_clone_a
UcxMap * ucx_map_clone_a(UcxAllocator *allocator, UcxMap const *map, copy_func fnc, void *data)
Clones the map and rehashes if necessary.
Definition: map.c:121

universe@390: UcxMap::size
size_t size
The size of the map is the length of the element list array.
Definition: map.h:87

universe@390: ucx_map_iter_next
int ucx_map_iter_next(UcxMapIterator *iterator, UcxKey *key, void **value)
Proceeds to the next element of the map (if any).
Definition: map.c:310

universe@390: UcxKey::data
const void * data
The key data.
Definition: map.h:95

universe@390: allocator.h
Allocator for custom memory management.

universe@390: UcxMap
Structure for the UCX map.
Definition: map.h:81

universe@390: ucx_map_remove
void * ucx_map_remove(UcxMap *map, UcxKey key)
Removes a key/value-pair from the map by using the key.
Definition: map.c:247

universe@390: UcxKey::len
size_t len
The length of the key data.
Definition: map.h:97

universe@390: ucx_map_intersection
UcxMap * ucx_map_intersection(const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
Returns the intersection of two maps.
Definition: map.c:357

universe@390: ucx_map_rehash
int ucx_map_rehash(UcxMap *map)
Increases size of the hash map, if necessary.
Definition: map.c:132

universe@390: ucx_map_free
void ucx_map_free(UcxMap *map)
Frees a hash map.
Definition: map.c:79

universe@390: ucx_map_clone
UcxMap * ucx_map_clone(UcxMap const *map, copy_func fnc, void *data)
Clones the map and rehashes if necessary.
Definition: map.c:117

universe@390: UcxMap::map
UcxMapElement ** map
The array of map element lists.
Definition: map.h:85

universe@390: ucx_map_intersection_a
UcxMap * ucx_map_intersection_a(UcxAllocator *allocator, const UcxMap *first, const UcxMap *second, copy_func cpfnc, void *cpdata)
Returns the intersection of two maps.
Definition: map.c:363

universe@390: UcxMapKey::data
void * data
The key data.
Definition: map.h:105

universe@390: ucx_destructor
void(* ucx_destructor)(void *)
A function pointer to a destructor function.
Definition: ucx.h:72

universe@390: