Skip to content

G
git2
Commit c2b67043 by Russell Belfer
Options

Rename git_khash_str to git_strmap, etc. 

This renamed `git_khash_str` to `git_strmap`, `git_hash_oid` to
`git_oidmap`, and deletes `git_hashtable` from the tree, plus
adds unit tests for `git_strmap`.
parent 01fed0a8
Showing with 237 additions and 758 deletions
src/attr.c
......@@ -3,7 +3,7 @@
#include "config.h"
#include <ctype.h>
GIT_KHASH_STR__IMPLEMENTATION;
GIT__USE_STRMAP;
static int collect_attr_files(
git_repository *repo, const char *path, git_vector *files);
......@@ -126,14 +126,14 @@ int git_attr_foreach(
git_attr_file *file;
git_attr_rule *rule;
git_attr_assignment *assign;
git_khash_str *seen = NULL;
git_strmap *seen = NULL;
if ((error = git_attr_path__init(
&path, pathname, git_repository_workdir(repo))) < 0 ||
(error = collect_attr_files(repo, pathname, &files)) < 0)
return error;
seen = git_khash_str_alloc();
seen = git_strmap_alloc();
GITERR_CHECK_ALLOC(seen);
git_vector_foreach(&files, i, file) {
......@@ -142,10 +142,10 @@ int git_attr_foreach(
git_vector_foreach(&rule->assigns, k, assign) {
/* skip if higher priority assignment was already seen */
if (git_khash_str_exists(seen, assign->name))
if (git_strmap_exists(seen, assign->name))
continue;
git_khash_str_insert(seen, assign->name, assign, error);
git_strmap_insert(seen, assign->name, assign, error);
if (error >= 0)
error = callback(assign->name, assign->value, payload);
......@@ -156,7 +156,7 @@ int git_attr_foreach(
}
cleanup:
git_khash_str_free(seen);
git_strmap_free(seen);
git_vector_free(&files);
return error;
......@@ -200,12 +200,12 @@ int git_attr_add_macro(
bool git_attr_cache__is_cached(git_repository *repo, const char *path)
{
const char *cache_key = path;
git_khash_str *files = git_repository_attr_cache(repo)->files;
git_strmap *files = git_repository_attr_cache(repo)->files;
if (repo && git__prefixcmp(cache_key, git_repository_workdir(repo)) == 0)
cache_key += strlen(git_repository_workdir(repo));
return git_khash_str_exists(files, cache_key);
return git_strmap_exists(files, cache_key);
}
int git_attr_cache__lookup_or_create_file(
......@@ -220,9 +220,9 @@ int git_attr_cache__lookup_or_create_file(
git_attr_file *file = NULL;
khiter_t pos;
pos = git_khash_str_lookup_index(cache->files, key);
if (git_khash_str_valid_index(cache->files, pos)) {
*file_ptr = git_khash_str_value_at(cache->files, pos);
pos = git_strmap_lookup_index(cache->files, key);
if (git_strmap_valid_index(cache->files, pos)) {
*file_ptr = git_strmap_value_at(cache->files, pos);
return 0;
}
......@@ -240,7 +240,7 @@ int git_attr_cache__lookup_or_create_file(
error = git_attr_file__set_path(repo, key, file);
if (!error) {
git_khash_str_insert(cache->files, file->path, file, error);
git_strmap_insert(cache->files, file->path, file, error);
if (error > 0)
error = 0;
}
......@@ -383,13 +383,13 @@ int git_attr_cache__init(git_repository *repo)
/* allocate hashtable for attribute and ignore file contents */
if (cache->files == NULL) {
cache->files = git_khash_str_alloc();
cache->files = git_strmap_alloc();
GITERR_CHECK_ALLOC(cache->files);
}
/* allocate hashtable for attribute macros */
if (cache->macros == NULL) {
cache->macros = git_khash_str_alloc();
cache->macros = git_strmap_alloc();
GITERR_CHECK_ALLOC(cache->macros);
}
......@@ -416,21 +416,21 @@ void git_attr_cache_flush(
if (cache->files != NULL) {
git_attr_file *file;
git_khash_str_foreach_value(cache->files, file, {
git_strmap_foreach_value(cache->files, file, {
git_attr_file__free(file);
});
git_khash_str_free(cache->files);
git_strmap_free(cache->files);
}
if (cache->macros != NULL) {
git_attr_rule *rule;
git_khash_str_foreach_value(cache->macros, rule, {
git_strmap_foreach_value(cache->macros, rule, {
git_attr_rule__free(rule);
});
git_khash_str_free(cache->macros);
git_strmap_free(cache->macros);
}
git_pool_clear(&cache->pool);
......@@ -440,28 +440,28 @@ void git_attr_cache_flush(
int git_attr_cache__insert_macro(git_repository *repo, git_attr_rule *macro)
{
git_khash_str *macros = git_repository_attr_cache(repo)->macros;
git_strmap *macros = git_repository_attr_cache(repo)->macros;
int error;
/* TODO: generate warning log if (macro->assigns.length == 0) */
if (macro->assigns.length == 0)
return 0;
git_khash_str_insert(macros, macro->match.pattern, macro, error);
git_strmap_insert(macros, macro->match.pattern, macro, error);
return (error < 0) ? -1 : 0;
}
git_attr_rule *git_attr_cache__lookup_macro(
git_repository *repo, const char *name)
{
git_khash_str *macros = git_repository_attr_cache(repo)->macros;
git_strmap *macros = git_repository_attr_cache(repo)->macros;
khiter_t pos;
pos = git_khash_str_lookup_index(macros, name);
pos = git_strmap_lookup_index(macros, name);
if (!git_khash_str_valid_index(macros, pos))
if (!git_strmap_valid_index(macros, pos))
return NULL;
return (git_attr_rule *)git_khash_str_value_at(macros, pos);
return (git_attr_rule *)git_strmap_value_at(macros, pos);
}
src/attr.h
......@@ -8,7 +8,7 @@
#define INCLUDE_attr_h__
#include "attr_file.h"
#include "khash_str.h"
#include "strmap.h"
#define GIT_ATTR_CONFIG "core.attributesfile"
#define GIT_IGNORE_CONFIG "core.excludesfile"
......@@ -16,8 +16,8 @@
typedef struct {
int initialized;
git_pool pool;
git_khash_str *files; /* hash path to git_attr_file of rules */
git_khash_str *macros; /* hash name to vector<git_attr_assignment> */
git_strmap *files; /* hash path to git_attr_file of rules */
git_strmap *macros; /* hash name to vector<git_attr_assignment> */
const char *cfg_attr_file; /* cached value of core.attributesfile */
const char *cfg_excl_file; /* cached value of core.excludesfile */
} git_attr_cache;
......
src/attr_file.h
......@@ -9,7 +9,6 @@
#include "git2/attr.h"
#include "vector.h"
#include "hashtable.h"
#include "pool.h"
#define GIT_ATTR_FILE ".gitattributes"
......
src/config_cache.c
......@@ -7,7 +7,6 @@
#include "common.h"
#include "fileops.h"
#include "hashtable.h"
#include "config.h"
#include "git2/config.h"
#include "vector.h"
......
src/config_file.c
......@@ -12,13 +12,13 @@
#include "buffer.h"
#include "git2/config.h"
#include "git2/types.h"
#include "khash_str.h"
#include "strmap.h"
#include <ctype.h>
#include <sys/types.h>
#include <regex.h>
GIT_KHASH_STR__IMPLEMENTATION;
GIT__USE_STRMAP;
typedef struct cvar_t {
struct cvar_t *next;
......@@ -72,7 +72,7 @@ typedef struct {
typedef struct {
git_config_file parent;
git_khash_str *values;
git_strmap *values;
struct {
git_buf buffer;
......@@ -132,21 +132,21 @@ static int normalize_name(const char *in, char **out)
return 0;
}
static void free_vars(git_khash_str *values)
static void free_vars(git_strmap *values)
{
cvar_t *var = NULL;
if (values == NULL)
return;
git_khash_str_foreach_value(values, var,
git_strmap_foreach_value(values, var,
while (var != NULL) {
cvar_t *next = CVAR_LIST_NEXT(var);
cvar_free(var);
var = next;
});
git_khash_str_free(values);
git_strmap_free(values);
}
static int config_open(git_config_file *cfg)
......@@ -154,7 +154,7 @@ static int config_open(git_config_file *cfg)
int res;
diskfile_backend *b = (diskfile_backend *)cfg;
b->values = git_khash_str_alloc();
b->values = git_strmap_alloc();
GITERR_CHECK_ALLOC(b->values);
git_buf_init(&b->reader.buffer, 0);
......@@ -196,7 +196,7 @@ static int file_foreach(git_config_file *backend, int (*fn)(const char *, const
if (!b->values)
return 0;
git_khash_str_foreach(b->values, key, var,
git_strmap_foreach(b->values, key, var,
do {
if (fn(key, var->value, data) < 0)
break;
......@@ -223,9 +223,9 @@ static int config_set(git_config_file *cfg, const char *name, const char *value)
* Try to find it in the existing values and update it if it
* only has one value.
*/
pos = git_khash_str_lookup_index(b->values, key);
if (git_khash_str_valid_index(b->values, pos)) {
cvar_t *existing = git_khash_str_value_at(b->values, pos);
pos = git_strmap_lookup_index(b->values, key);
if (git_strmap_valid_index(b->values, pos)) {
cvar_t *existing = git_strmap_value_at(b->values, pos);
char *tmp = NULL;
git__free(key);
......@@ -258,7 +258,7 @@ static int config_set(git_config_file *cfg, const char *name, const char *value)
GITERR_CHECK_ALLOC(var->value);
}
git_khash_str_insert2(b->values, key, var, old_var, rval);
git_strmap_insert2(b->values, key, var, old_var, rval);
if (rval < 0)
return -1;
if (old_var != NULL)
......@@ -284,14 +284,14 @@ static int config_get(git_config_file *cfg, const char *name, const char **out)
if (normalize_name(name, &key) < 0)
return -1;
pos = git_khash_str_lookup_index(b->values, key);
pos = git_strmap_lookup_index(b->values, key);
git__free(key);
/* no error message; the config system will write one */
if (!git_khash_str_valid_index(b->values, pos))
if (!git_strmap_valid_index(b->values, pos))
return GIT_ENOTFOUND;
*out = ((cvar_t *)git_khash_str_value_at(b->values, pos))->value;
*out = ((cvar_t *)git_strmap_value_at(b->values, pos))->value;
return 0;
}
......@@ -311,13 +311,13 @@ static int config_get_multivar(
if (normalize_name(name, &key) < 0)
return -1;
pos = git_khash_str_lookup_index(b->values, key);
pos = git_strmap_lookup_index(b->values, key);
git__free(key);
if (!git_khash_str_valid_index(b->values, pos))
if (!git_strmap_valid_index(b->values, pos))
return GIT_ENOTFOUND;
var = git_khash_str_value_at(b->values, pos);
var = git_strmap_value_at(b->values, pos);
if (regex_str != NULL) {
regex_t regex;
......@@ -374,13 +374,13 @@ static int config_set_multivar(
if (normalize_name(name, &key) < 0)
return -1;
pos = git_khash_str_lookup_index(b->values, key);
if (!git_khash_str_valid_index(b->values, pos)) {
pos = git_strmap_lookup_index(b->values, key);
if (!git_strmap_valid_index(b->values, pos)) {
git__free(key);
return GIT_ENOTFOUND;
}
var = git_khash_str_value_at(b->values, pos);
var = git_strmap_value_at(b->values, pos);
result = regcomp(&preg, regexp, REG_EXTENDED);
if (result < 0) {
......@@ -440,20 +440,20 @@ static int config_delete(git_config_file *cfg, const char *name)
if (normalize_name(name, &key) < 0)
return -1;
pos = git_khash_str_lookup_index(b->values, key);
pos = git_strmap_lookup_index(b->values, key);
git__free(key);
if (!git_khash_str_valid_index(b->values, pos))
if (!git_strmap_valid_index(b->values, pos))
return GIT_ENOTFOUND;
var = git_khash_str_value_at(b->values, pos);
var = git_strmap_value_at(b->values, pos);
if (var->next != NULL) {
giterr_set(GITERR_CONFIG, "Cannot delete multivar with a single delete");
return -1;
}
git_khash_str_delete_at(b->values, pos);
git_strmap_delete_at(b->values, pos);
result = config_write(b, var->key, NULL, NULL);
......@@ -914,14 +914,14 @@ static int config_parse(diskfile_backend *cfg_file)
var->value = var_value;
/* Add or append the new config option */
pos = git_khash_str_lookup_index(cfg_file->values, var->key);
if (!git_khash_str_valid_index(cfg_file->values, pos)) {
git_khash_str_insert(cfg_file->values, var->key, var, result);
pos = git_strmap_lookup_index(cfg_file->values, var->key);
if (!git_strmap_valid_index(cfg_file->values, pos)) {
git_strmap_insert(cfg_file->values, var->key, var, result);
if (result < 0)
break;
result = 0;
} else {
existing = git_khash_str_value_at(cfg_file->values, pos);
existing = git_strmap_value_at(cfg_file->values, pos);
while (existing->next != NULL) {
existing = existing->next;
}
......
src/hashtable.c deleted 100644 → 0
/*
* Copyright (C) 2009-2012 the libgit2 contributors
*
* This file is part of libgit2, distributed under the GNU GPL v2 with
* a Linking Exception. For full terms see the included COPYING file.
*/
#include "common.h"
#include "repository.h"
#include "commit.h"
#define MAX_LOOPS 5
static const double max_load_factor = 0.65;
static int resize_to(git_hashtable *self, size_t new_size);
static int set_size(git_hashtable *self, size_t new_size);
static git_hashtable_node *node_with_hash(git_hashtable *self, const void *key, int hash_id);
static void node_swap_with(git_hashtable_node *self, git_hashtable_node *other);
static int node_insert(git_hashtable *self, git_hashtable_node *new_node);
static int insert_nodes(git_hashtable *self, git_hashtable_node *old_nodes, size_t old_size);
static void reinsert_stash(git_hashtable *self);
static int resize_to(git_hashtable *self, size_t new_size)
{
git_hashtable_node *old_nodes = self->nodes;
size_t old_size = self->size;
git_hashtable_node old_stash[GIT_HASHTABLE_STASH_SIZE];
size_t old_stash_count = self->stash_count;
self->is_resizing = 1;
if (old_stash_count > 0)
memcpy(old_stash, self->stash,
old_stash_count * sizeof(git_hashtable_node));
do {
self->size = new_size;
self->size_mask = new_size - 1;
self->key_count = 0;
self->stash_count = 0;
self->nodes = git__calloc(1, sizeof(git_hashtable_node) * self->size);
GITERR_CHECK_ALLOC(self->nodes);
if (insert_nodes(self, old_nodes, old_size) == 0 &&
insert_nodes(self, old_stash, old_stash_count) == 0)
self->is_resizing = 0;
else {
new_size *= 2;
git__free(self->nodes);
}
} while (self->is_resizing);
git__free(old_nodes);
return 0;
}
static int set_size(git_hashtable *self, size_t new_size)
{
self->nodes =
git__realloc(self->nodes, new_size * sizeof(git_hashtable_node));
GITERR_CHECK_ALLOC(self->nodes);
if (new_size > self->size)
memset(&self->nodes[self->size], 0x0,
(new_size - self->size) * sizeof(git_hashtable_node));
self->size = new_size;
self->size_mask = new_size - 1;
return 0;
}
GIT_INLINE(git_hashtable_node *)node_with_hash(
git_hashtable *self, const void *key, int hash_id)
{
size_t pos = self->hash(key, hash_id) & self->size_mask;
return git_hashtable_node_at(self->nodes, pos);
}
GIT_INLINE(void) node_swap_with(
git_hashtable_node *self, git_hashtable_node *other)
{
git_hashtable_node tmp = *self;
*self = *other;
*other = tmp;
}
static int node_insert(git_hashtable *self, git_hashtable_node *new_node)
{
int iteration, hash_id;
git_hashtable_node *node;
for (iteration = 0; iteration < MAX_LOOPS; iteration++) {
for (hash_id = 0; hash_id < GIT_HASHTABLE_HASHES; ++hash_id) {
node = node_with_hash(self, new_node->key, hash_id);
node_swap_with(new_node, node);
if (new_node->key == 0x0) {
self->key_count++;
return 0;
}
}
}
/* Insert into stash if there is space */
if (self->stash_count < GIT_HASHTABLE_STASH_SIZE) {
node_swap_with(new_node, &self->stash[self->stash_count++]);
self->key_count++;
return 0;
}
/* Failed to insert node. Hashtable is currently resizing */
assert(!self->is_resizing);
if (resize_to(self, self->size * 2) < 0)
return -1;
return git_hashtable_insert(self, new_node->key, new_node->value);
}
static int insert_nodes(
git_hashtable *self, git_hashtable_node *old_nodes, size_t old_size)
{
size_t i;
for (i = 0; i < old_size; ++i) {
git_hashtable_node *node = git_hashtable_node_at(old_nodes, i);
if (node->key && node_insert(self, node) < 0)
return -1;
}
return 0;
}
static void reinsert_stash(git_hashtable *self)
{
int stash_count;
struct git_hashtable_node stash[GIT_HASHTABLE_STASH_SIZE];
if (self->stash_count <= 0)
return;
memcpy(stash, self->stash, self->stash_count * sizeof(git_hashtable_node));
stash_count = self->stash_count;
self->stash_count = 0;
/* the node_insert() calls *cannot* fail because the stash is empty */
insert_nodes(self, stash, stash_count);
}
git_hashtable *git_hashtable_alloc(
size_t min_size,
git_hash_ptr hash,
git_hash_keyeq_ptr key_eq)
{
git_hashtable *table;
assert(hash && key_eq);
if ((table = git__malloc(sizeof(*table))) == NULL)
return NULL;
memset(table, 0x0, sizeof(git_hashtable));
table->hash = hash;
table->key_equal = key_eq;
min_size = git__size_t_powerof2(min_size < 8 ? 8 : min_size);
set_size(table, min_size);
return table;
}
void git_hashtable_clear(git_hashtable *self)
{
assert(self);
memset(self->nodes, 0x0, sizeof(git_hashtable_node) * self->size);
self->stash_count = 0;
self->key_count = 0;
}
void git_hashtable_free(git_hashtable *self)
{
assert(self);
git__free(self->nodes);
git__free(self);
}
int git_hashtable_insert2(
git_hashtable *self, const void *key, void *value, void **old_value)
{
int hash_id;
git_hashtable_node *node;
assert(self && self->nodes);
*old_value = NULL;
for (hash_id = 0; hash_id < GIT_HASHTABLE_HASHES; ++hash_id) {
node = node_with_hash(self, key, hash_id);
if (!node->key) {
node->key = key;
node->value = value;
self->key_count++;
return 0;
}
if (key == node->key || self->key_equal(key, node->key) == 0) {
*old_value = node->value;
node->key = key;
node->value = value;
return 0;
}
}
/* no space in table; must do cuckoo dance */
{
git_hashtable_node x;
x.key = key;
x.value = value;
return node_insert(self, &x);
}
}
static git_hashtable_node *find_node(git_hashtable *self, const void *key)
{
int hash_id, count = 0;
git_hashtable_node *node;
for (hash_id = 0; hash_id < GIT_HASHTABLE_HASHES; ++hash_id) {
node = node_with_hash(self, key, hash_id);
if (node->key) {
++count;
if (self->key_equal(key, node->key) == 0)
return node;
}
}
/* check stash if not found but all slots were filled */
if (count == GIT_HASHTABLE_HASHES) {
for (count = 0; count < self->stash_count; ++count)
if (self->key_equal(key, self->stash[count].key) == 0)
return &self->stash[count];
}
return NULL;
}
static void reset_stash(git_hashtable *self, git_hashtable_node *node)
{
/* if node was in stash, then compact stash */
ssize_t offset = node - self->stash;
if (offset >= 0 && offset < self->stash_count) {
if (offset < self->stash_count - 1)
memmove(node, node + 1, (self->stash_count - offset) *
sizeof(git_hashtable_node));
self->stash_count--;
}
reinsert_stash(self);
}
void *git_hashtable_lookup(git_hashtable *self, const void *key)
{
git_hashtable_node *node;
assert(self && key);
node = find_node(self, key);
return node ? node->value : NULL;
}
int git_hashtable_remove2(
git_hashtable *self, const void *key, void **old_value)
{
git_hashtable_node *node;
assert(self && self->nodes);
node = find_node(self, key);
if (node) {
*old_value = node->value;
node->key = NULL;
node->value = NULL;
self->key_count--;
reset_stash(self, node);
return 0;
}
return GIT_ENOTFOUND;
}
int git_hashtable_merge(git_hashtable *self, git_hashtable *other)
{
size_t new_size = git__size_t_powerof2(self->size + other->size);
if (resize_to(self, new_size) < 0)
return -1;
if (insert_nodes(self, other->nodes, other->key_count) < 0)
return -1;
return insert_nodes(self, other->stash, other->stash_count);
}
/**
* Standard string
*/
uint32_t git_hash__strhash_cb(const void *key, int hash_id)
{
static uint32_t hash_seeds[GIT_HASHTABLE_HASHES] = {
2147483647,
0x5d20bb23,
0x7daaab3c
};
size_t key_len = strlen((const char *)key);
/* won't take hash of strings longer than 2^31 right now */
assert(key_len == (size_t)((int)key_len));
return git__hash(key, (int)key_len, hash_seeds[hash_id]);
}
src/hashtable.h deleted 100644 → 0
/*
* Copyright (C) 2009-2012 the libgit2 contributors
*
* This file is part of libgit2, distributed under the GNU GPL v2 with
* a Linking Exception. For full terms see the included COPYING file.
*/
#ifndef INCLUDE_hashtable_h__
#define INCLUDE_hashtable_h__
#include "git2/common.h"
#include "git2/oid.h"
#include "git2/odb.h"
#include "common.h"
#define GIT_HASHTABLE_HASHES 3
typedef uint32_t (*git_hash_ptr)(const void *, int hash_id);
typedef int (*git_hash_keyeq_ptr)(const void *key_a, const void *key_b);
struct git_hashtable_node {
const void *key;
void *value;
};
#define GIT_HASHTABLE_STASH_SIZE 3
struct git_hashtable {
struct git_hashtable_node *nodes;
size_t size_mask;
size_t size;
size_t key_count;
struct git_hashtable_node stash[GIT_HASHTABLE_STASH_SIZE];
int stash_count;
int is_resizing;
git_hash_ptr hash;
git_hash_keyeq_ptr key_equal;
};
typedef struct git_hashtable_node git_hashtable_node;
typedef struct git_hashtable git_hashtable;
git_hashtable *git_hashtable_alloc(
size_t min_size,
git_hash_ptr hash,
git_hash_keyeq_ptr key_eq);
void *git_hashtable_lookup(git_hashtable *h, const void *key);
int git_hashtable_remove2(git_hashtable *table, const void *key, void **old_value);
GIT_INLINE(int) git_hashtable_remove(git_hashtable *table, const void *key)
{
void *_unused;
return git_hashtable_remove2(table, key, &_unused);
}
void git_hashtable_free(git_hashtable *h);
void git_hashtable_clear(git_hashtable *h);
int git_hashtable_merge(git_hashtable *self, git_hashtable *other);
int git_hashtable_insert2(git_hashtable *h, const void *key, void *value, void **old_value);
GIT_INLINE(int) git_hashtable_insert(git_hashtable *h, const void *key, void *value)
{
void *_unused;
return git_hashtable_insert2(h, key, value, &_unused);
}
#define git_hashtable_node_at(nodes, pos) ((git_hashtable_node *)(&nodes[pos]))
#define GIT_HASHTABLE__FOREACH(self,block) { \
size_t _c; \
git_hashtable_node *_n = (self)->nodes; \
for (_c = (self)->size; _c > 0; _c--, _n++) { \
if (!_n->key) continue; block } }
#define GIT_HASHTABLE_FOREACH(self, pkey, pvalue, code)\
GIT_HASHTABLE__FOREACH(self,{(pkey)=_n->key;(pvalue)=_n->value;code;})
#define GIT_HASHTABLE_FOREACH_KEY(self, pkey, code)\
GIT_HASHTABLE__FOREACH(self,{(pkey)=_n->key;code;})
#define GIT_HASHTABLE_FOREACH_VALUE(self, pvalue, code)\
GIT_HASHTABLE__FOREACH(self,{(pvalue)=_n->value;code;})
#define GIT_HASHTABLE_FOREACH_DELETE() {\
_node->key = NULL; _node->value = NULL; _self->key_count--;\
}
/*
* If you want a hashtable with standard string keys, you can
* just pass git_hash__strcmp_cb and git_hash__strhash_cb to
* git_hashtable_alloc.
*/
#define git_hash__strcmp_cb git__strcmp_cb
extern uint32_t git_hash__strhash_cb(const void *key, int hash_id);
#endif
src/khash_oid.h → src/oidmap.h
......@@ -4,8 +4,8 @@
* This file is part of libgit2, distributed under the GNU GPL v2 with
* a Linking Exception. For full terms see the included COPYING file.
*/
#ifndef INCLUDE_khash_oid_h__
#define INCLUDE_khash_oid_h__
#ifndef INCLUDE_oidmap_h__
#define INCLUDE_oidmap_h__
#include "common.h"
#include "git2/oid.h"
......@@ -17,7 +17,7 @@
#include "khash.h"
__KHASH_TYPE(oid, const git_oid *, void *);
typedef khash_t(oid) git_khash_oid;
typedef khash_t(oid) git_oidmap;
GIT_INLINE(khint_t) hash_git_oid(const git_oid *oid)
{
......@@ -33,10 +33,10 @@ GIT_INLINE(int) hash_git_oid_equal(const git_oid *a, const git_oid *b)
return (memcmp(a->id, b->id, sizeof(a->id)) == 0);
}
#define GIT_KHASH_OID__IMPLEMENTATION \
#define GIT__USE_OIDMAP \
__KHASH_IMPL(oid, static inline, const git_oid *, void *, 1, hash_git_oid, hash_git_oid_equal)
#define git_khash_oid_alloc() kh_init(oid)
#define git_khash_oid_free(h) kh_destroy(oid,h), h = NULL
#define git_oidmap_alloc() kh_init(oid)
#define git_oidmap_free(h) kh_destroy(oid,h), h = NULL
#endif
src/refs.c
......@@ -15,7 +15,7 @@
#include <git2/tag.h>
#include <git2/object.h>
GIT_KHASH_STR__IMPLEMENTATION;
GIT__USE_STRMAP;
#define DEFAULT_NESTING_LEVEL 5
#define MAX_NESTING_LEVEL 10
......@@ -423,7 +423,7 @@ static int packed_load(git_repository *repo)
/* First we make sure we have allocated the hash table */
if (ref_cache->packfile == NULL) {
ref_cache->packfile = git_khash_str_alloc();
ref_cache->packfile = git_strmap_alloc();
GITERR_CHECK_ALLOC(ref_cache->packfile);
}
......@@ -438,7 +438,7 @@ static int packed_load(git_repository *repo)
* refresh the packed refs.
*/
if (result == GIT_ENOTFOUND) {
git_khash_str_clear(ref_cache->packfile);
git_strmap_clear(ref_cache->packfile);
return 0;
}
......@@ -452,7 +452,7 @@ static int packed_load(git_repository *repo)
* At this point, we want to refresh the packed refs. We already
* have the contents in our buffer.
*/
git_khash_str_clear(ref_cache->packfile);
git_strmap_clear(ref_cache->packfile);
buffer_start = (const char *)packfile.ptr;
buffer_end = (const char *)(buffer_start) + packfile.size;
......@@ -477,7 +477,7 @@ static int packed_load(git_repository *repo)
goto parse_failed;
}
git_khash_str_insert(ref_cache->packfile, ref->name, ref, err);
git_strmap_insert(ref_cache->packfile, ref->name, ref, err);
if (err < 0)
goto parse_failed;
}
......@@ -486,7 +486,7 @@ static int packed_load(git_repository *repo)
return 0;
parse_failed:
git_khash_str_free(ref_cache->packfile);
git_strmap_free(ref_cache->packfile);
ref_cache->packfile = NULL;
git_buf_free(&packfile);
return -1;
......@@ -512,7 +512,7 @@ static int _dirent_loose_listall(void *_data, git_buf *full_path)
/* do not add twice a reference that exists already in the packfile */
if ((data->list_flags & GIT_REF_PACKED) != 0 &&
git_khash_str_exists(data->repo->references.packfile, file_path))
git_strmap_exists(data->repo->references.packfile, file_path))
return 0;
if (data->list_flags != GIT_REF_LISTALL) {
......@@ -539,7 +539,7 @@ static int _dirent_loose_load(void *data, git_buf *full_path)
if (loose_lookup_to_packfile(&ref, repository, file_path) < 0)
return -1;
git_khash_str_insert2(
git_strmap_insert2(
repository->references.packfile, ref->name, ref, old_ref, err);
if (err < 0) {
git__free(ref);
......@@ -737,7 +737,7 @@ static int packed_write(git_repository *repo)
assert(repo && repo->references.packfile);
total_refs =
(unsigned int)git_khash_str_num_entries(repo->references.packfile);
(unsigned int)git_strmap_num_entries(repo->references.packfile);
if (git_vector_init(&packing_list, total_refs, packed_sort) < 0)
return -1;
......@@ -747,7 +747,7 @@ static int packed_write(git_repository *repo)
struct packref *reference;
/* cannot fail: vector already has the right size */
git_khash_str_foreach_value(repo->references.packfile, reference, {
git_strmap_foreach_value(repo->references.packfile, reference, {
git_vector_insert(&packing_list, reference);
});
}
......@@ -873,7 +873,7 @@ static int reference_exists(int *exists, git_repository *repo, const char *ref_n
return -1;
if (git_path_isfile(ref_path.ptr) == true ||
git_khash_str_exists(repo->references.packfile, ref_path.ptr))
git_strmap_exists(repo->references.packfile, ref_path.ptr))
{
*exists = 1;
} else {
......@@ -940,7 +940,7 @@ static int reference_can_write(
static int packed_lookup(git_reference *ref)
{
struct packref *pack_ref = NULL;
git_khash_str *packfile_refs;
git_strmap *packfile_refs;
khiter_t pos;
if (packed_load(ref->owner) < 0)
......@@ -959,13 +959,13 @@ static int packed_lookup(git_reference *ref)
/* Look up on the packfile */
packfile_refs = ref->owner->references.packfile;
pos = git_khash_str_lookup_index(packfile_refs, ref->name);
if (!git_khash_str_valid_index(packfile_refs, pos)) {
pos = git_strmap_lookup_index(packfile_refs, ref->name);
if (!git_strmap_valid_index(packfile_refs, pos)) {
giterr_set(GITERR_REFERENCE, "Reference '%s' not found", ref->name);
return GIT_ENOTFOUND;
}
pack_ref = git_khash_str_value_at(packfile_refs, pos);
pack_ref = git_strmap_value_at(packfile_refs, pos);
ref->flags = GIT_REF_OID | GIT_REF_PACKED;
ref->mtime = ref->owner->references.packfile_time;
......@@ -1011,7 +1011,7 @@ static int reference_delete(git_reference *ref)
* We need to reload the packfile, remove the reference from the
* packing list, and repack */
if (ref->flags & GIT_REF_PACKED) {
git_khash_str *packfile_refs;
git_strmap *packfile_refs;
struct packref *packref;
khiter_t pos;
......@@ -1020,15 +1020,15 @@ static int reference_delete(git_reference *ref)
return -1;
packfile_refs = ref->owner->references.packfile;
pos = git_khash_str_lookup_index(packfile_refs, ref->name);
if (!git_khash_str_valid_index(packfile_refs, pos)) {
pos = git_strmap_lookup_index(packfile_refs, ref->name);
if (!git_strmap_valid_index(packfile_refs, pos)) {
giterr_set(GITERR_REFERENCE,
"Reference %s stopped existing in the packfile", ref->name);
return -1;
}
packref = git_khash_str_value_at(packfile_refs, pos);
git_khash_str_delete_at(packfile_refs, pos);
packref = git_strmap_value_at(packfile_refs, pos);
git_strmap_delete_at(packfile_refs, pos);
git__free(packref);
if (packed_write(ref->owner) < 0)
......@@ -1488,7 +1488,7 @@ int git_reference_foreach(
if (packed_load(repo) < 0)
return -1;
git_khash_str_foreach(repo->references.packfile, ref_name, ref, {
git_strmap_foreach(repo->references.packfile, ref_name, ref, {
if (callback(ref_name, payload) < 0)
return 0;
});
......@@ -1555,11 +1555,11 @@ void git_repository__refcache_free(git_refcache *refs)
if (refs->packfile) {
struct packref *reference;
git_khash_str_foreach_value(refs->packfile, reference, {
git_strmap_foreach_value(refs->packfile, reference, {
git__free(reference);
});
git_khash_str_free(refs->packfile);
git_strmap_free(refs->packfile);
}
}
......
src/refs.h
......@@ -10,7 +10,7 @@
#include "common.h"
#include "git2/oid.h"
#include "git2/refs.h"
#include "khash_str.h"
#include "strmap.h"
#define GIT_REFS_DIR "refs/"
#define GIT_REFS_HEADS_DIR GIT_REFS_DIR "heads/"
......@@ -46,7 +46,7 @@ struct git_reference {
};
typedef struct {
git_khash_str *packfile;
git_strmap *packfile;
time_t packfile_time;
} git_refcache;
......
src/repository.h
......@@ -19,7 +19,7 @@
#include "buffer.h"
#include "odb.h"
#include "attr.h"
#include "khash_str.h"
#include "strmap.h"
#define DOT_GIT ".git"
#define GIT_DIR DOT_GIT "/"
......@@ -83,7 +83,7 @@ struct git_repository {
git_cache objects;
git_refcache references;
git_attr_cache attrcache;
git_khash_str *submodules;
git_strmap *submodules;
char *path_repository;
char *workdir;
......
src/revwalk.c
......@@ -10,14 +10,14 @@
#include "odb.h"
#include "pqueue.h"
#include "pool.h"
#include "khash_oid.h"
#include "oidmap.h"
#include "git2/revwalk.h"
#include "git2/merge.h"
#include <regex.h>
GIT_KHASH_OID__IMPLEMENTATION;
GIT__USE_OIDMAP;
#define PARENT1 (1 << 0)
#define PARENT2 (1 << 1)
......@@ -48,7 +48,7 @@ struct git_revwalk {
git_repository *repo;
git_odb *odb;
git_khash_oid *commits;
git_oidmap *commits;
git_pool commit_pool;
commit_list *iterator_topo;
......@@ -726,7 +726,7 @@ int git_revwalk_new(git_revwalk **revwalk_out, git_repository *repo)
memset(walk, 0x0, sizeof(git_revwalk));
walk->commits = git_khash_oid_alloc();
walk->commits = git_oidmap_alloc();
GITERR_CHECK_ALLOC(walk->commits);
if (git_pqueue_init(&walk->iterator_time, 8, commit_time_cmp) < 0 ||
......@@ -757,7 +757,7 @@ void git_revwalk_free(git_revwalk *walk)
git_revwalk_reset(walk);
git_odb_free(walk->odb);
git_khash_oid_free(walk->commits);
git_oidmap_free(walk->commits);
git_pool_clear(&walk->commit_pool);
git_pqueue_free(&walk->iterator_time);
git_vector_free(&walk->twos);
......
src/khash_str.h → src/strmap.h
......@@ -4,8 +4,8 @@
* This file is part of libgit2, distributed under the GNU GPL v2 with
* a Linking Exception. For full terms see the included COPYING file.
*/
#ifndef INCLUDE_khash_str_h__
#define INCLUDE_khash_str_h__
#ifndef INCLUDE_strmap_h__
#define INCLUDE_strmap_h__
#include "common.h"
......@@ -16,39 +16,39 @@
#include "khash.h"
__KHASH_TYPE(str, const char *, void *);
typedef khash_t(str) git_khash_str;
typedef khash_t(str) git_strmap;
#define GIT_KHASH_STR__IMPLEMENTATION \
#define GIT__USE_STRMAP \
__KHASH_IMPL(str, static inline, const char *, void *, 1, kh_str_hash_func, kh_str_hash_equal)
#define git_khash_str_alloc() kh_init(str)
#define git_khash_str_free(h) kh_destroy(str, h), h = NULL
#define git_khash_str_clear(h) kh_clear(str, h)
#define git_strmap_alloc() kh_init(str)
#define git_strmap_free(h) kh_destroy(str, h), h = NULL
#define git_strmap_clear(h) kh_clear(str, h)
#define git_khash_str_num_entries(h) kh_size(h)
#define git_strmap_num_entries(h) kh_size(h)
#define git_khash_str_lookup_index(h, k) kh_get(str, h, k)
#define git_khash_str_valid_index(h, idx) (idx != kh_end(h))
#define git_strmap_lookup_index(h, k) kh_get(str, h, k)
#define git_strmap_valid_index(h, idx) (idx != kh_end(h))
#define git_khash_str_exists(h, k) (kh_get(str, h, k) != kh_end(h))
#define git_strmap_exists(h, k) (kh_get(str, h, k) != kh_end(h))
#define git_khash_str_value_at(h, idx) kh_val(h, idx)
#define git_khash_str_set_value_at(h, idx, v) kh_val(h, idx) = v
#define git_khash_str_delete_at(h, idx) kh_del(str, h, idx)
#define git_strmap_value_at(h, idx) kh_val(h, idx)
#define git_strmap_set_value_at(h, idx, v) kh_val(h, idx) = v
#define git_strmap_delete_at(h, idx) kh_del(str, h, idx)
#define git_khash_str_insert(h, key, val, err) do { \
#define git_strmap_insert(h, key, val, err) do { \
khiter_t __pos = kh_put(str, h, key, &err); \
if (err >= 0) kh_val(h, __pos) = val; \
} while (0)
#define git_khash_str_insert2(h, key, val, old, err) do { \
#define git_strmap_insert2(h, key, val, old, err) do { \
khiter_t __pos = kh_put(str, h, key, &err); \
if (err >= 0) { \
old = (err == 0) ? kh_val(h, __pos) : NULL; \
kh_val(h, __pos) = val; \
} } while (0)
#define git_khash_str_foreach kh_foreach
#define git_khash_str_foreach_value kh_foreach_value
#define git_strmap_foreach kh_foreach
#define git_strmap_foreach_value kh_foreach_value
#endif
src/submodule.c
......@@ -89,17 +89,17 @@ static void submodule_release(git_submodule *sm, int decr)
}
static int submodule_from_entry(
git_khash_str *smcfg, git_index_entry *entry)
git_strmap *smcfg, git_index_entry *entry)
{
git_submodule *sm;
void *old_sm;
khiter_t pos;
int error;
pos = git_khash_str_lookup_index(smcfg, entry->path);
pos = git_strmap_lookup_index(smcfg, entry->path);
if (git_khash_str_valid_index(smcfg, pos))
sm = git_khash_str_value_at(smcfg, pos);
if (git_strmap_valid_index(smcfg, pos))
sm = git_strmap_value_at(smcfg, pos);
else
sm = submodule_alloc(entry->path);
......@@ -115,7 +115,7 @@ static int submodule_from_entry(
goto fail;
}
git_khash_str_insert2(smcfg, sm->path, sm, old_sm, error);
git_strmap_insert2(smcfg, sm->path, sm, old_sm, error);
if (error < 0)
goto fail;
sm->refcount++;
......@@ -135,7 +135,7 @@ fail:
static int submodule_from_config(
const char *key, const char *value, void *data)
{
git_khash_str *smcfg = data;
git_strmap *smcfg = data;
const char *namestart;
const char *property;
git_buf name = GIT_BUF_INIT;
......@@ -158,13 +158,13 @@ static int submodule_from_config(
if (git_buf_set(&name, namestart, property - namestart - 1) < 0)
return -1;
pos = git_khash_str_lookup_index(smcfg, name.ptr);
if (!git_khash_str_valid_index(smcfg, pos) && is_path)
pos = git_khash_str_lookup_index(smcfg, value);
if (!git_khash_str_valid_index(smcfg, pos))
pos = git_strmap_lookup_index(smcfg, name.ptr);
if (!git_strmap_valid_index(smcfg, pos) && is_path)
pos = git_strmap_lookup_index(smcfg, value);
if (!git_strmap_valid_index(smcfg, pos))
sm = submodule_alloc(name.ptr);
else
sm = git_khash_str_value_at(smcfg, pos);
sm = git_strmap_value_at(smcfg, pos);
if (!sm)
goto fail;
......@@ -172,7 +172,7 @@ static int submodule_from_config(
assert(sm->path == sm->name);
sm->name = git_buf_detach(&name);
git_khash_str_insert2(smcfg, sm->name, sm, old_sm, error);
git_strmap_insert2(smcfg, sm->name, sm, old_sm, error);
if (error < 0)
goto fail;
sm->refcount++;
......@@ -183,7 +183,7 @@ static int submodule_from_config(
if (sm->path == NULL)
goto fail;
git_khash_str_insert2(smcfg, sm->path, sm, old_sm, error);
git_strmap_insert2(smcfg, sm->path, sm, old_sm, error);
if (error < 0)
goto fail;
sm->refcount++;
......@@ -247,7 +247,7 @@ static int load_submodule_config(git_repository *repo)
git_index *index;
unsigned int i, max_i;
git_oid gitmodules_oid;
git_khash_str *smcfg;
git_strmap *smcfg;
struct git_config_file *mods = NULL;
if (repo->submodules)
......@@ -257,7 +257,7 @@ static int load_submodule_config(git_repository *repo)
* under both its name and its path. These are usually the same, but
* that is not guaranteed.
*/
smcfg = git_khash_str_alloc();
smcfg = git_strmap_alloc();
GITERR_CHECK_ALLOC(smcfg);
/* scan index for gitmodules (and .gitmodules entry) */
......@@ -307,13 +307,13 @@ cleanup:
if (mods != NULL)
git_config_file_free(mods);
if (error)
git_khash_str_free(smcfg);
git_strmap_free(smcfg);
return error;
}
void git_submodule_config_free(git_repository *repo)
{
git_khash_str *smcfg = repo->submodules;
git_strmap *smcfg = repo->submodules;
git_submodule *sm;
repo->submodules = NULL;
......@@ -321,10 +321,10 @@ void git_submodule_config_free(git_repository *repo)
if (smcfg == NULL)
return;
git_khash_str_foreach_value(smcfg, sm, {
git_strmap_foreach_value(smcfg, sm, {
submodule_release(sm,1);
});
git_khash_str_free(smcfg);
git_strmap_free(smcfg);
}
static int submodule_cmp(const void *a, const void *b)
......@@ -345,7 +345,7 @@ int git_submodule_foreach(
if ((error = load_submodule_config(repo)) < 0)
return error;
git_khash_str_foreach_value(repo->submodules, sm, {
git_strmap_foreach_value(repo->submodules, sm, {
/* usually the following will not come into play */
if (sm->refcount > 1) {
if (git_vector_bsearch(&seen, sm) != GIT_ENOTFOUND)
......@@ -373,12 +373,12 @@ int git_submodule_lookup(
if (load_submodule_config(repo) < 0)
return -1;
pos = git_khash_str_lookup_index(repo->submodules, name);
if (!git_khash_str_valid_index(repo->submodules, pos))
pos = git_strmap_lookup_index(repo->submodules, name);
if (!git_strmap_valid_index(repo->submodules, pos))
return GIT_ENOTFOUND;
if (sm_ptr)
*sm_ptr = git_khash_str_value_at(repo->submodules, pos);
*sm_ptr = git_strmap_value_at(repo->submodules, pos);
return 0;
}
tests-clar/core/strmap.c 0 → 100644
#include "clar_libgit2.h"
#include "strmap.h"
GIT__USE_STRMAP;
void test_core_strmap__0(void)
{
git_strmap *table = git_strmap_alloc();
cl_assert(table != NULL);
cl_assert(git_strmap_num_entries(table) == 0);
git_strmap_free(table);
}
static void insert_strings(git_strmap *table, int count)
{
int i, j, over, err;
char *str;
for (i = 0; i < count; ++i) {
str = malloc(10);
for (j = 0; j < 10; ++j)
str[j] = 'a' + (i % 26);
str[9] = '\0';
/* if > 26, then encode larger value in first letters */
for (j = 0, over = i / 26; over > 0; j++, over = over / 26)
str[j] = 'A' + (over % 26);
git_strmap_insert(table, str, str, err);
cl_assert(err >= 0);
}
cl_assert((int)git_strmap_num_entries(table) == count);
}
void test_core_strmap__1(void)
{
int i;
char *str;
git_strmap *table = git_strmap_alloc();
cl_assert(table != NULL);
insert_strings(table, 20);
cl_assert(git_strmap_exists(table, "aaaaaaaaa"));
cl_assert(git_strmap_exists(table, "ggggggggg"));
cl_assert(!git_strmap_exists(table, "aaaaaaaab"));
cl_assert(!git_strmap_exists(table, "abcdefghi"));
i = 0;
git_strmap_foreach_value(table, str, { i++; free(str); });
cl_assert(i == 20);
git_strmap_free(table);
}
void test_core_strmap__2(void)
{
khiter_t pos;
int i;
char *str;
git_strmap *table = git_strmap_alloc();
cl_assert(table != NULL);
insert_strings(table, 20);
cl_assert(git_strmap_exists(table, "aaaaaaaaa"));
cl_assert(git_strmap_exists(table, "ggggggggg"));
cl_assert(!git_strmap_exists(table, "aaaaaaaab"));
cl_assert(!git_strmap_exists(table, "abcdefghi"));
cl_assert(git_strmap_exists(table, "bbbbbbbbb"));
pos = git_strmap_lookup_index(table, "bbbbbbbbb");
cl_assert(git_strmap_valid_index(table, pos));
cl_assert_equal_s(git_strmap_value_at(table, pos), "bbbbbbbbb");
free(git_strmap_value_at(table, pos));
git_strmap_delete_at(table, pos);
cl_assert(!git_strmap_exists(table, "bbbbbbbbb"));
i = 0;
git_strmap_foreach_value(table, str, { i++; free(str); });
cl_assert(i == 19);
git_strmap_free(table);
}
void test_core_strmap__3(void)
{
int i;
char *str;
git_strmap *table = git_strmap_alloc();
cl_assert(table != NULL);
insert_strings(table, 10000);
i = 0;
git_strmap_foreach_value(table, str, { i++; free(str); });
cl_assert(i == 10000);
git_strmap_free(table);
}
tests/t07-hashtable.c deleted 100644 → 0
/*
* This file is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License, version 2,
* as published by the Free Software Foundation.
*
* In addition to the permissions in the GNU General Public License,
* the authors give you unlimited permission to link the compiled
* version of this file into combinations with other programs,
* and to distribute those combinations without any restriction
* coming from the use of this file. (The General Public License
* restrictions do apply in other respects; for example, they cover
* modification of the file, and distribution when not linked into
* a combined executable.)
*
* This file 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
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; see the file COPYING. If not, write to
* the Free Software Foundation, 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "test_lib.h"
#include "test_helpers.h"
#include "hashtable.h"
#include "hash.h"
typedef struct _aux_object {
int __bulk;
git_oid id;
int visited;
} table_item;
static uint32_t hash_func(const void *key, int hash_id)
{
uint32_t r;
const git_oid *id = key;
memcpy(&r, id->id + (hash_id * sizeof(uint32_t)), sizeof(r));
return r;
}
static int hash_cmpkey(const void *a, const void *b)
{
return git_oid_cmp(a, b);
}
BEGIN_TEST(table0, "create a new hashtable")
git_hashtable *table = NULL;
table = git_hashtable_alloc(55, hash_func, hash_cmpkey);
must_be_true(table != NULL);
must_be_true(table->size_mask + 1 == 64);
git_hashtable_free(table);
END_TEST
BEGIN_TEST(table1, "fill the hashtable with random entries")
const int objects_n = 32;
int i;
table_item *objects;
git_hashtable *table = NULL;
table = git_hashtable_alloc(objects_n * 2, hash_func, hash_cmpkey);
must_be_true(table != NULL);
objects = git__malloc(objects_n * sizeof(table_item));
memset(objects, 0x0, objects_n * sizeof(table_item));
/* populate the hash table */
for (i = 0; i < objects_n; ++i) {
git_hash_buf(&(objects[i].id), &i, sizeof(int));
must_pass(git_hashtable_insert(table, &(objects[i].id), &(objects[i])));
}
/* make sure all the inserted objects can be found */
for (i = 0; i < objects_n; ++i) {
git_oid id;
table_item *ob;
git_hash_buf(&id, &i, sizeof(int));
ob = (table_item *)git_hashtable_lookup(table, &id);
must_be_true(ob != NULL);
must_be_true(ob == &(objects[i]));
}
/* make sure we cannot find inexisting objects */
for (i = 0; i < 50; ++i) {
int hash_id;
git_oid id;
hash_id = (rand() % 50000) + objects_n;
git_hash_buf(&id, &hash_id, sizeof(int));
must_be_true(git_hashtable_lookup(table, &id) == NULL);
}
git_hashtable_free(table);
git__free(objects);
END_TEST
BEGIN_TEST(table2, "make sure the table resizes automatically")
const int objects_n = 64;
int i;
size_t old_size;
table_item *objects;
git_hashtable *table = NULL;
table = git_hashtable_alloc(objects_n, hash_func, hash_cmpkey);
must_be_true(table != NULL);
objects = git__malloc(objects_n * sizeof(table_item));
memset(objects, 0x0, objects_n * sizeof(table_item));
old_size = table->size_mask + 1;
/* populate the hash table -- should be automatically resized */
for (i = 0; i < objects_n; ++i) {
git_hash_buf(&(objects[i].id), &i, sizeof(int));
must_pass(git_hashtable_insert(table, &(objects[i].id), &(objects[i])));
}
must_be_true(table->size_mask > old_size);
/* make sure all the inserted objects can be found */
for (i = 0; i < objects_n; ++i) {
git_oid id;
table_item *ob;
git_hash_buf(&id, &i, sizeof(int));
ob = (table_item *)git_hashtable_lookup(table, &id);
must_be_true(ob != NULL);
must_be_true(ob == &(objects[i]));
}
git_hashtable_free(table);
git__free(objects);
END_TEST
BEGIN_TEST(tableit0, "iterate through all the contents of the table")
const int objects_n = 32;
int i;
table_item *objects, *ob;
git_hashtable *table = NULL;
table = git_hashtable_alloc(objects_n * 2, hash_func, hash_cmpkey);
must_be_true(table != NULL);
objects = git__malloc(objects_n * sizeof(table_item));
memset(objects, 0x0, objects_n * sizeof(table_item));
/* populate the hash table */
for (i = 0; i < objects_n; ++i) {
git_hash_buf(&(objects[i].id), &i, sizeof(int));
must_pass(git_hashtable_insert(table, &(objects[i].id), &(objects[i])));
}
GIT_HASHTABLE_FOREACH_VALUE(table, ob, ob->visited = 1);
/* make sure all nodes have been visited */
for (i = 0; i < objects_n; ++i)
must_be_true(objects[i].visited);
git_hashtable_free(table);
git__free(objects);
END_TEST
BEGIN_SUITE(hashtable)
ADD_TEST(table0);
ADD_TEST(table1);
ADD_TEST(table2);
ADD_TEST(tableit0);
END_SUITE
tests/test_main.c
......@@ -37,7 +37,6 @@ DECLARE_SUITE(objwrite);
DECLARE_SUITE(commit);
DECLARE_SUITE(revwalk);
DECLARE_SUITE(index);
DECLARE_SUITE(hashtable);
DECLARE_SUITE(tag);
DECLARE_SUITE(tree);
DECLARE_SUITE(refs);
......@@ -53,7 +52,6 @@ static libgit2_suite suite_methods[]= {
SUITE_NAME(commit),
SUITE_NAME(revwalk),
SUITE_NAME(index),
SUITE_NAME(hashtable),
SUITE_NAME(tag),
SUITE_NAME(tree),
SUITE_NAME(refs),
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment