#pragma once
/***
This file is part of systemd.
Copyright 2010 Lennart Poettering
Copyright 2014 Michal Schmidt
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
systemd is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include "hash-funcs.h"
#include "macro.h"
#include "util.h"
/*
* A hash table implementation. As a minor optimization a NULL hashmap object
* will be treated as empty hashmap for all read operations. That way it is not
* necessary to instantiate an object for each Hashmap use.
*
* If ENABLE_DEBUG_HASHMAP is defined (by configuring with --enable-debug=hashmap),
* the implemention will:
* - store extra data for debugging and statistics (see tools/gdb-sd_dump_hashmaps.py)
* - perform extra checks for invalid use of iterators
*/
/* The base type for all hashmap and set types. Many functions in the
* implementation take (HashmapBase*) parameters and are run-time polymorphic,
* though the API is not meant to be polymorphic (do not call functions
* internal_*() directly). */
typedef struct OrderedHashmap OrderedHashmap; /* Like Hashmap, but also remembers entry insertion order */
/* Ideally the Iterator would be an opaque struct, but it is instantiated
* by hashmap users, so the definition has to be here. Do not use its fields
* directly. */
typedef struct {
#ifdef ENABLE_DEBUG_HASHMAP
#endif
} Iterator;
/* Macros for type checking */
#define PTR_COMPATIBLE_WITH_HASHMAP_BASE(h) \
#define PTR_COMPATIBLE_WITH_PLAIN_HASHMAP(h) \
#define HASHMAP_BASE(h) \
(HashmapBase*)(h), \
(void)0)
#define PLAIN_HASHMAP(h) \
(Hashmap*)(h), \
(void)0)
#ifdef ENABLE_DEBUG_HASHMAP
#else
# define HASHMAP_DEBUG_PARAMS
# define HASHMAP_DEBUG_SRC_ARGS
# define HASHMAP_DEBUG_PASS_ARGS
#endif
return (void*)internal_hashmap_free(HASHMAP_BASE(h));
}
return (void*)internal_hashmap_free(HASHMAP_BASE(h));
}
return (void*)internal_hashmap_free_free(HASHMAP_BASE(h));
}
return (void*)internal_hashmap_free_free(HASHMAP_BASE(h));
}
return (void*)hashmap_free_free_free(PLAIN_HASHMAP(h));
}
}
}
int internal_hashmap_ensure_allocated(Hashmap **h, const struct hash_ops *hash_ops HASHMAP_DEBUG_PARAMS);
int internal_ordered_hashmap_ensure_allocated(OrderedHashmap **h, const struct hash_ops *hash_ops HASHMAP_DEBUG_PARAMS);
#define hashmap_ensure_allocated(h, ops) internal_hashmap_ensure_allocated(h, ops HASHMAP_DEBUG_SRC_ARGS)
#define ordered_hashmap_ensure_allocated(h, ops) internal_ordered_hashmap_ensure_allocated(h, ops HASHMAP_DEBUG_SRC_ARGS)
}
}
}
}
}
}
}
}
}
}
}
}
static inline int ordered_hashmap_remove_and_put(OrderedHashmap *h, const void *old_key, const void *new_key, void *value) {
}
static inline int ordered_hashmap_remove_and_replace(OrderedHashmap *h, const void *old_key, const void *new_key, void *value) {
}
/* Since merging data from a OrderedHashmap into a Hashmap or vice-versa
* should just work, allow this by having looser type-checking here. */
}
}
/* Unlike hashmap_merge, hashmap_move does not allow mixing the types. */
}
}
}
static inline int ordered_hashmap_move_one(OrderedHashmap *h, OrderedHashmap *other, const void *key) {
}
return internal_hashmap_size(HASHMAP_BASE(h));
}
return internal_hashmap_size(HASHMAP_BASE(h));
}
return hashmap_size(h) == 0;
}
return ordered_hashmap_size(h) == 0;
}
return internal_hashmap_buckets(HASHMAP_BASE(h));
}
return internal_hashmap_buckets(HASHMAP_BASE(h));
}
}
static inline bool ordered_hashmap_iterate(OrderedHashmap *h, Iterator *i, void **value, const void **key) {
}
void internal_hashmap_clear(HashmapBase *h);
}
}
void internal_hashmap_clear_free(HashmapBase *h);
}
}
void hashmap_clear_free_free(Hashmap *h);
}
/*
* Note about all *_first*() functions
*
* For plain Hashmaps and Sets the order of entries is undefined.
* The functions find whatever entry is first in the implementation
* internal order.
*
* Only for OrderedHashmaps the order is well defined and finding
* the first entry is O(1).
*/
void *internal_hashmap_steal_first(HashmapBase *h);
return internal_hashmap_steal_first(HASHMAP_BASE(h));
}
return internal_hashmap_steal_first(HASHMAP_BASE(h));
}
void *internal_hashmap_steal_first_key(HashmapBase *h);
return internal_hashmap_steal_first_key(HASHMAP_BASE(h));
}
return internal_hashmap_steal_first_key(HASHMAP_BASE(h));
}
return internal_hashmap_first_key(HASHMAP_BASE(h));
}
return internal_hashmap_first_key(HASHMAP_BASE(h));
}
return internal_hashmap_first(HASHMAP_BASE(h));
}
return internal_hashmap_first(HASHMAP_BASE(h));
}
/* no hashmap_next */
char **internal_hashmap_get_strv(HashmapBase *h);
return internal_hashmap_get_strv(HASHMAP_BASE(h));
}
return internal_hashmap_get_strv(HASHMAP_BASE(h));
}
/*
* Hashmaps are iterated in unpredictable order.
* OrderedHashmaps are an exception to this. They are iterated in the order
* the entries were inserted.
* It is safe to remove the current entry.
*/
#define HASHMAP_FOREACH(e, h, i) \
#define ORDERED_HASHMAP_FOREACH(e, h, i) \
#define HASHMAP_FOREACH_KEY(e, k, h, i) \
for ((i) = ITERATOR_FIRST; hashmap_iterate((h), &(i), (void**)&(e), (const void**) &(k)); )
#define ORDERED_HASHMAP_FOREACH_KEY(e, k, h, i) \
for ((i) = ITERATOR_FIRST; ordered_hashmap_iterate((h), &(i), (void**)&(e), (const void**) &(k)); )