rugged 0.27.7 → 0.27.10

data/vendor/libgit2/src/offmap.c

@@ -7,11 +7,24 @@
 
 #include "offmap.h"
 
-__KHASH_IMPL(off, static kh_inline, git_off_t, void *, 1, kh_int64_hash_func, kh_int64_hash_equal)
+#define kmalloc git__malloc
+#define kcalloc git__calloc
+#define krealloc git__realloc
+#define kreallocarray git__reallocarray
+#define kfree git__free
+#include "khash.h"
 
-git_offmap *git_offmap_alloc(void)
+__KHASH_TYPE(off, off64_t, void *)
+
+__KHASH_IMPL(off, static kh_inline, off64_t, void *, 1, kh_int64_hash_func, kh_int64_hash_equal)
+
+
+int git_offmap_new(git_offmap **out)
 {
-	return kh_init(off);
+	*out = kh_init(off);
+	GIT_ERROR_CHECK_ALLOC(*out);
+
+	return 0;
 }
 
 void git_offmap_free(git_offmap *map)
@@ -24,60 +37,65 @@ void git_offmap_clear(git_offmap *map)
 	kh_clear(off, map);
 }
 
-size_t git_offmap_num_entries(git_offmap *map)
+size_t git_offmap_size(git_offmap *map)
 {
 	return kh_size(map);
 }
 
-size_t git_offmap_lookup_index(git_offmap *map, const git_off_t key)
+void *git_offmap_get(git_offmap *map, const off64_t key)
 {
-	return kh_get(off, map, key);
+	size_t idx = kh_get(off, map, key);
+	if (idx == kh_end(map) || !kh_exist(map, idx))
+		return NULL;
+	return kh_val(map, idx);
 }
 
-int git_offmap_valid_index(git_offmap *map, size_t idx)
+int git_offmap_set(git_offmap *map, const off64_t key, void *value)
 {
-	return idx != kh_end(map);
-}
+	size_t idx;
+	int rval;
 
-int git_offmap_exists(git_offmap *map, const git_off_t key)
-{
-	return kh_get(off, map, key) != kh_end(map);
-}
+	idx = kh_put(off, map, key, &rval);
+	if (rval < 0)
+		return -1;
 
-void *git_offmap_value_at(git_offmap *map, size_t idx)
-{
-	return kh_val(map, idx);
-}
+	if (rval == 0)
+		kh_key(map, idx) = key;
 
-void git_offmap_set_value_at(git_offmap *map, size_t idx, void *value)
-{
 	kh_val(map, idx) = value;
+
+	return 0;
 }
 
-void git_offmap_delete_at(git_offmap *map, size_t idx)
+int git_offmap_delete(git_offmap *map, const off64_t key)
 {
+	khiter_t idx = kh_get(off, map, key);
+	if (idx == kh_end(map))
+		return GIT_ENOTFOUND;
 	kh_del(off, map, idx);
+	return 0;
 }
 
-int git_offmap_put(git_offmap *map, const git_off_t key, int *err)
+int git_offmap_exists(git_offmap *map, const off64_t key)
 {
-	return kh_put(off, map, key, err);
+	return kh_get(off, map, key) != kh_end(map);
 }
 
-void git_offmap_insert(git_offmap *map, const git_off_t key, void *value, int *rval)
+int git_offmap_iterate(void **value, git_offmap *map, size_t *iter, off64_t *key)
 {
-	khiter_t idx = kh_put(off, map, key, rval);
+	size_t i = *iter;
 
-	if ((*rval) >= 0) {
-		if ((*rval) == 0)
-			kh_key(map, idx) = key;
-		kh_val(map, idx) = value;
-	}
-}
+	while (i < map->n_buckets && !kh_exist(map, i))
+		i++;
 
-void git_offmap_delete(git_offmap *map, const git_off_t key)
-{
-	khiter_t idx = git_offmap_lookup_index(map, key);
-	if (git_offmap_valid_index(map, idx))
-		git_offmap_delete_at(map, idx);
+	if (i >= map->n_buckets)
+		return GIT_ITEROVER;
+
+	if (key)
+		*key = kh_key(map, i);
+	if (value)
+		*value = kh_value(map, i);
+	*iter = ++i;
+
+	return 0;
 }

data/vendor/libgit2/src/offmap.h

@@ -11,36 +11,123 @@
 
 #include "git2/types.h"
 
-#define kmalloc git__malloc
-#define kcalloc git__calloc
-#define krealloc git__realloc
-#define kreallocarray git__reallocarray
-#define kfree git__free
-#include "khash.h"
+/** A map with `off64_t`s as key. */
+typedef struct kh_off_s git_offmap;
 
-__KHASH_TYPE(off, git_off_t, void *)
-typedef khash_t(off) git_offmap;
+/**
+ * Allocate a new `off64_t` map.
+ *
+ * @param out Pointer to the map that shall be allocated.
+ * @return 0 on success, an error code if allocation has failed.
+ */
+int git_offmap_new(git_offmap **out);
 
-git_offmap *git_offmap_alloc(void);
+/**
+ * Free memory associated with the map.
+ *
+ * Note that this function will _not_ free values added to this
+ * map.
+ *
+ * @param map Pointer to the map that is to be free'd. May be
+ *            `NULL`.
+ */
 void git_offmap_free(git_offmap *map);
+
+/**
+ * Clear all entries from the map.
+ *
+ * This function will remove all entries from the associated map.
+ * Memory associated with it will not be released, though.
+ *
+ * @param map Pointer to the map that shall be cleared. May be
+ *            `NULL`.
+ */
 void git_offmap_clear(git_offmap *map);
 
-size_t git_offmap_num_entries(git_offmap *map);
+/**
+ * Return the number of elements in the map.
+ *
+ * @parameter map map containing the elements
+ * @return number of elements in the map
+ */
+size_t git_offmap_size(git_offmap *map);
+
+/**
+ * Return value associated with the given key.
+ *
+ * @param map map to search key in
+ * @param key key to search for
+ * @return value associated with the given key or NULL if the key was not found
+ */
+void *git_offmap_get(git_offmap *map, const off64_t key);
+
+/**
+ * Set the entry for key to value.
+ *
+ * If the map has no corresponding entry for the given key, a new
+ * entry will be created with the given value. If an entry exists
+ * already, its value will be updated to match the given value.
+ *
+ * @param map map to create new entry in
+ * @param key key to set
+ * @param value value to associate the key with; may be NULL
+ * @return zero if the key was successfully set, a negative error
+ *         code otherwise
+ */
+int git_offmap_set(git_offmap *map, const off64_t key, void *value);
 
-size_t git_offmap_lookup_index(git_offmap *map, const git_off_t key);
-int git_offmap_valid_index(git_offmap *map, size_t idx);
+/**
+ * Delete an entry from the map.
+ *
+ * Delete the given key and its value from the map. If no such
+ * key exists, this will do nothing.
+ *
+ * @param map map to delete key in
+ * @param key key to delete
+ * @return `0` if the key has been deleted, GIT_ENOTFOUND if no
+ *         such key was found, a negative code in case of an
+ *         error
+ */
+int git_offmap_delete(git_offmap *map, const off64_t key);
 
-int git_offmap_exists(git_offmap *map, const git_off_t key);
+/**
+ * Check whether a key exists in the given map.
+ *
+ * @param map map to query for the key
+ * @param key key to search for
+ * @return 0 if the key has not been found, 1 otherwise
+ */
+int git_offmap_exists(git_offmap *map, const off64_t key);
 
-void *git_offmap_value_at(git_offmap *map, size_t idx);
-void git_offmap_set_value_at(git_offmap *map, size_t idx, void *value);
-void git_offmap_delete_at(git_offmap *map, size_t idx);
+/**
+ * Iterate over entries of the map.
+ *
+ * This functions allows to iterate over all key-value entries of
+ * the map. The current position is stored in the `iter` variable
+ * and should be initialized to `0` before the first call to this
+ * function.
+ *
+ * @param map map to iterate over
+ * @param value pointer to the variable where to store the current
+ *            value. May be NULL.
+ * @param iter iterator storing the current position. Initialize
+ *             with zero previous to the first call.
+ * @param key pointer to the variable where to store the current
+ *            key. May be NULL.
+ * @return `0` if the next entry was correctly retrieved.
+ *        GIT_ITEROVER if no entries are left. A negative error
+ *        code otherwise.
+ */
+int git_offmap_iterate(void **value, git_offmap *map, size_t *iter, off64_t *key);
 
-int git_offmap_put(git_offmap *map, const git_off_t key, int *err);
-void git_offmap_insert(git_offmap *map, const git_off_t key, void *value, int *rval);
-void git_offmap_delete(git_offmap *map, const git_off_t key);
+#define git_offmap_foreach(h, kvar, vvar, code) { size_t __i = 0;		\
+	while (git_offmap_iterate((void **) &(vvar), h, &__i, &(kvar)) == 0) {	\
+		code;								\
+	} }
 
-#define git_offmap_foreach		kh_foreach
-#define git_offmap_foreach_value	kh_foreach_value
+#define git_offmap_foreach_value(h, vvar, code) { size_t __i = 0;		\
+	while (git_offmap_iterate((void **) &(vvar), h, &__i, NULL) == 0) {	\
+		code;								\
+	} }
 
 #endif

data/vendor/libgit2/src/oid.c

@@ -17,7 +17,7 @@ static char to_hex[] = "0123456789abcdef";
 
 static int oid_error_invalid(const char *msg)
 {
-	giterr_set(GITERR_INVALID, "unable to parse OID - %s", msg);
+	git_error_set(GIT_ERROR_INVALID, "unable to parse OID - %s", msg);
 	return -1;
 }
 
@@ -237,7 +237,7 @@ int git_oid_streq(const git_oid *oid_a, const char *str)
 	return git_oid_strcmp(oid_a, str) == 0 ? 0 : -1;
 }
 
-int git_oid_iszero(const git_oid *oid_a)
+int git_oid_is_zero(const git_oid *oid_a)
 {
 	const unsigned char *a = oid_a->id;
 	unsigned int i;
@@ -247,6 +247,11 @@ int git_oid_iszero(const git_oid *oid_a)
 	return 1;
 }
 
+int git_oid_iszero(const git_oid *oid_a)
+{
+	return git_oid_is_zero(oid_a);
+}
+
 typedef short node_index;
 
 typedef union {
@@ -263,7 +268,7 @@ struct git_oid_shorten {
 static int resize_trie(git_oid_shorten *self, size_t new_size)
 {
 	self->nodes = git__reallocarray(self->nodes, new_size, sizeof(trie_node));
-	GITERR_CHECK_ALLOC(self->nodes);
+	GIT_ERROR_CHECK_ALLOC(self->nodes);
 
 	if (new_size > self->size) {
 		memset(&self->nodes[self->size], 0x0, (new_size - self->size) * sizeof(trie_node));
@@ -381,7 +386,7 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 	node_index idx;
 
 	if (os->full) {
-		giterr_set(GITERR_INVALID, "unable to shorten OID - OID set full");
+		git_error_set(GIT_ERROR_INVALID, "unable to shorten OID - OID set full");
 		return -1;
 	}
 
@@ -396,7 +401,7 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 		trie_node *node;
 
 		if (c == -1) {
-			giterr_set(GITERR_INVALID, "unable to shorten OID - invalid hex value");
+			git_error_set(GIT_ERROR_INVALID, "unable to shorten OID - invalid hex value");
 			return -1;
 		}
 
@@ -411,7 +416,7 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 			node = push_leaf(os, idx, git__fromhex(tail[0]), &tail[1]);
 			if (node == NULL) {
 				if (os->full)
-					giterr_set(GITERR_INVALID, "unable to shorten OID - OID set full");
+					git_error_set(GIT_ERROR_INVALID, "unable to shorten OID - OID set full");
 				return -1;
 			}
 		}
@@ -419,7 +424,7 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 		if (node->children[c] == 0) {
 			if (push_leaf(os, idx, c, &text_oid[i + 1]) == NULL) {
 				if (os->full)
-					giterr_set(GITERR_INVALID, "unable to shorten OID - OID set full");
+					git_error_set(GIT_ERROR_INVALID, "unable to shorten OID - OID set full");
 				return -1;
 			}
 			break;

data/vendor/libgit2/src/oidmap.c

@@ -7,6 +7,15 @@
 
 #include "oidmap.h"
 
+#define kmalloc git__malloc
+#define kcalloc git__calloc
+#define krealloc git__realloc
+#define kreallocarray git__reallocarray
+#define kfree git__free
+#include "khash.h"
+
+__KHASH_TYPE(oid, const git_oid *, void *)
+
 GIT_INLINE(khint_t) git_oidmap_hash(const git_oid *oid)
 {
 	khint_t h;
@@ -16,9 +25,12 @@ GIT_INLINE(khint_t) git_oidmap_hash(const git_oid *oid)
 
 __KHASH_IMPL(oid, static kh_inline, const git_oid *, void *, 1, git_oidmap_hash, git_oid_equal)
 
-git_oidmap *git_oidmap_alloc()
+int git_oidmap_new(git_oidmap **out)
 {
-	return kh_init(oid);
+	*out = kh_init(oid);
+	GIT_ERROR_CHECK_ALLOC(*out);
+
+	return 0;
 }
 
 void git_oidmap_free(git_oidmap *map)
@@ -36,70 +48,60 @@ size_t git_oidmap_size(git_oidmap *map)
 	return kh_size(map);
 }
 
-size_t git_oidmap_lookup_index(git_oidmap *map, const git_oid *key)
+void *git_oidmap_get(git_oidmap *map, const git_oid *key)
 {
-	return kh_get(oid, map, key);
+	size_t idx = kh_get(oid, map, key);
+	if (idx == kh_end(map) || !kh_exist(map, idx))
+		return NULL;
+	return kh_val(map, idx);
 }
 
-int git_oidmap_valid_index(git_oidmap *map, size_t idx)
+int git_oidmap_set(git_oidmap *map, const git_oid *key, void *value)
 {
-	return idx != kh_end(map);
-}
+	size_t idx;
+	int rval;
 
-int git_oidmap_exists(git_oidmap *map, const git_oid *key)
-{
-	return kh_get(oid, map, key) != kh_end(map);
-}
+	idx = kh_put(oid, map, key, &rval);
+	if (rval < 0)
+		return -1;
 
-int git_oidmap_has_data(git_oidmap *map, size_t idx)
-{
-	return kh_exist(map, idx);
-}
+	if (rval == 0)
+		kh_key(map, idx) = key;
 
-const git_oid *git_oidmap_key(git_oidmap *map, size_t idx)
-{
-	return kh_key(map, idx);
-}
+	kh_val(map, idx) = value;
 
-void git_oidmap_set_key_at(git_oidmap *map, size_t idx, git_oid *key)
-{
-	kh_key(map, idx) = key;
+	return 0;
 }
 
-void *git_oidmap_value_at(git_oidmap *map, size_t idx)
+int git_oidmap_delete(git_oidmap *map, const git_oid *key)
 {
-	return kh_val(map, idx);
+	khiter_t idx = kh_get(oid, map, key);
+	if (idx == kh_end(map))
+		return GIT_ENOTFOUND;
+	kh_del(oid, map, idx);
+	return 0;
 }
 
-void git_oidmap_set_value_at(git_oidmap *map, size_t idx, void *value)
+int git_oidmap_exists(git_oidmap *map, const git_oid *key)
 {
-	kh_val(map, idx) = value;
+	return kh_get(oid, map, key) != kh_end(map);
 }
 
-void git_oidmap_delete_at(git_oidmap *map, size_t idx)
+int git_oidmap_iterate(void **value, git_oidmap *map, size_t *iter, const git_oid **key)
 {
-	kh_del(oid, map, idx);
-}
+	size_t i = *iter;
 
-int git_oidmap_put(git_oidmap *map, const git_oid *key, int *err)
-{
-	return kh_put(oid, map, key, err);
-}
+	while (i < map->n_buckets && !kh_exist(map, i))
+		i++;
 
-void git_oidmap_insert(git_oidmap *map, const git_oid *key, void *value, int *rval)
-{
-	khiter_t idx = kh_put(oid, map, key, rval);
+	if (i >= map->n_buckets)
+		return GIT_ITEROVER;
 
-	if ((*rval) >= 0) {
-		if ((*rval) == 0)
-			kh_key(map, idx) = key;
-		kh_val(map, idx) = value;
-	}
-}
+	if (key)
+		*key = kh_key(map, i);
+	if (value)
+		*value = kh_value(map, i);
+	*iter = ++i;
 
-void git_oidmap_delete(git_oidmap *map, const git_oid *key)
-{
-	khiter_t idx = git_oidmap_lookup_index(map, key);
-	if (git_oidmap_valid_index(map, idx))
-		git_oidmap_delete_at(map, idx);
+	return 0;
 }

data/vendor/libgit2/src/oidmap.h

@@ -11,41 +11,118 @@
 
 #include "git2/oid.h"
 
-#define kmalloc git__malloc
-#define kcalloc git__calloc
-#define krealloc git__realloc
-#define kreallocarray git__reallocarray
-#define kfree git__free
-#include "khash.h"
+/** A map with `git_oid`s as key. */
+typedef struct kh_oid_s git_oidmap;
 
-__KHASH_TYPE(oid, const git_oid *, void *)
-typedef khash_t(oid) git_oidmap;
+/**
+ * Allocate a new OID map.
+ *
+ * @param out Pointer to the map that shall be allocated.
+ * @return 0 on success, an error code if allocation has failed.
+ */
+int git_oidmap_new(git_oidmap **out);
 
-git_oidmap *git_oidmap_alloc(void);
+/**
+ * Free memory associated with the map.
+ *
+ * Note that this function will _not_ free values added to this
+ * map.
+ *
+ * @param map Pointer to the map that is to be free'd. May be
+ *            `NULL`.
+ */
 void git_oidmap_free(git_oidmap *map);
+
+/**
+ * Clear all entries from the map.
+ *
+ * This function will remove all entries from the associated map.
+ * Memory associated with it will not be released, though.
+ *
+ * @param map Pointer to the map that shall be cleared. May be
+ *            `NULL`.
+ */
 void git_oidmap_clear(git_oidmap *map);
 
+/**
+ * Return the number of elements in the map.
+ *
+ * @parameter map map containing the elements
+ * @return number of elements in the map
+ */
 size_t git_oidmap_size(git_oidmap *map);
 
-size_t git_oidmap_lookup_index(git_oidmap *map, const git_oid *key);
-int git_oidmap_valid_index(git_oidmap *map, size_t idx);
+/**
+ * Return value associated with the given key.
+ *
+ * @param map map to search key in
+ * @param key key to search for
+ * @return value associated with the given key or NULL if the key was not found
+ */
+void *git_oidmap_get(git_oidmap *map, const git_oid *key);
 
-int git_oidmap_exists(git_oidmap *map, const git_oid *key);
-int git_oidmap_has_data(git_oidmap *map, size_t idx);
+/**
+ * Set the entry for key to value.
+ *
+ * If the map has no corresponding entry for the given key, a new
+ * entry will be created with the given value. If an entry exists
+ * already, its value will be updated to match the given value.
+ *
+ * @param map map to create new entry in
+ * @param key key to set
+ * @param value value to associate the key with; may be NULL
+ * @return zero if the key was successfully set, a negative error
+ *         code otherwise
+ */
+int git_oidmap_set(git_oidmap *map, const git_oid *key, void *value);
 
-const git_oid *git_oidmap_key(git_oidmap *map, size_t idx);
-void git_oidmap_set_key_at(git_oidmap *map, size_t idx, git_oid *key);
-void *git_oidmap_value_at(git_oidmap *map, size_t idx);
-void git_oidmap_set_value_at(git_oidmap *map, size_t idx, void *value);
-void git_oidmap_delete_at(git_oidmap *map, size_t idx);
+/**
+ * Delete an entry from the map.
+ *
+ * Delete the given key and its value from the map. If no such
+ * key exists, this will do nothing.
+ *
+ * @param map map to delete key in
+ * @param key key to delete
+ * @return `0` if the key has been deleted, GIT_ENOTFOUND if no
+ *         such key was found, a negative code in case of an
+ *         error
+ */
+int git_oidmap_delete(git_oidmap *map, const git_oid *key);
 
-int git_oidmap_put(git_oidmap *map, const git_oid *key, int *err);
-void git_oidmap_insert(git_oidmap *map, const git_oid *key, void *value, int *rval);
-void git_oidmap_delete(git_oidmap *map, const git_oid *key);
+/**
+ * Check whether a key exists in the given map.
+ *
+ * @param map map to query for the key
+ * @param key key to search for
+ * @return 0 if the key has not been found, 1 otherwise
+ */
+int git_oidmap_exists(git_oidmap *map, const git_oid *key);
 
-#define git_oidmap_foreach_value kh_foreach_value
+/**
+ * Iterate over entries of the map.
+ *
+ * This functions allows to iterate over all key-value entries of
+ * the map. The current position is stored in the `iter` variable
+ * and should be initialized to `0` before the first call to this
+ * function.
+ *
+ * @param map map to iterate over
+ * @param value pointer to the variable where to store the current
+ *            value. May be NULL.
+ * @param iter iterator storing the current position. Initialize
+ *             with zero previous to the first call.
+ * @param key pointer to the variable where to store the current
+ *            key. May be NULL.
+ * @return `0` if the next entry was correctly retrieved.
+ *        GIT_ITEROVER if no entries are left. A negative error
+ *        code otherwise.
+ */
+int git_oidmap_iterate(void **value, git_oidmap *map, size_t *iter, const git_oid **key);
 
-#define git_oidmap_begin	kh_begin
-#define git_oidmap_end		kh_end
+#define git_oidmap_foreach_value(h, vvar, code) { size_t __i = 0;		\
+	while (git_oidmap_iterate((void **) &(vvar), h, &__i, NULL) == 0) {	\
+		code;								\
+	} }
 
 #endif