--- /dev/null
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * 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 "config_entries.h"
+
+typedef struct config_entry_list {
+ struct config_entry_list *next;
+ struct config_entry_list *last;
+ git_config_entry *entry;
+} config_entry_list;
+
+typedef struct {
+ git_config_entry *entry;
+ bool multivar;
+} config_entry_map_head;
+
+typedef struct config_entries_iterator {
+ git_config_iterator parent;
+ git_config_entries *entries;
+ config_entry_list *head;
+} config_entries_iterator;
+
+struct git_config_entries {
+ git_refcount rc;
+ git_strmap *map;
+ config_entry_list *list;
+};
+
+int git_config_entries_new(git_config_entries **out)
+{
+ git_config_entries *entries;
+ int error;
+
+ entries = git__calloc(1, sizeof(git_config_entries));
+ GIT_ERROR_CHECK_ALLOC(entries);
+ GIT_REFCOUNT_INC(entries);
+
+ if ((error = git_strmap_new(&entries->map)) < 0)
+ git__free(entries);
+ else
+ *out = entries;
+
+ return error;
+}
+
+int git_config_entries_dup_entry(git_config_entries *entries, const git_config_entry *entry)
+{
+ git_config_entry *duplicated;
+ int error;
+
+ duplicated = git__calloc(1, sizeof(git_config_entry));
+ GIT_ERROR_CHECK_ALLOC(duplicated);
+
+ duplicated->name = git__strdup(entry->name);
+ GIT_ERROR_CHECK_ALLOC(duplicated->name);
+
+ if (entry->value) {
+ duplicated->value = git__strdup(entry->value);
+ GIT_ERROR_CHECK_ALLOC(duplicated->value);
+ }
+ duplicated->level = entry->level;
+ duplicated->include_depth = entry->include_depth;
+
+ if ((error = git_config_entries_append(entries, duplicated)) < 0)
+ goto out;
+
+out:
+ if (error && duplicated) {
+ git__free((char *) duplicated->name);
+ git__free((char *) duplicated->value);
+ git__free(duplicated);
+ }
+ return error;
+}
+
+int git_config_entries_dup(git_config_entries **out, git_config_entries *entries)
+{
+ git_config_entries *result = NULL;
+ config_entry_list *head;
+ int error;
+
+ if ((error = git_config_entries_new(&result)) < 0)
+ goto out;
+
+ for (head = entries->list; head; head = head->next)
+ if ((git_config_entries_dup_entry(result, head->entry)) < 0)
+ goto out;
+
+ *out = result;
+ result = NULL;
+
+out:
+ git_config_entries_free(result);
+ return error;
+}
+
+void git_config_entries_incref(git_config_entries *entries)
+{
+ GIT_REFCOUNT_INC(entries);
+}
+
+static void config_entries_free(git_config_entries *entries)
+{
+ config_entry_list *list = NULL, *next;
+ config_entry_map_head *head;
+
+ git_strmap_foreach_value(entries->map, head,
+ git__free((char *) head->entry->name); git__free(head)
+ );
+ git_strmap_free(entries->map);
+
+ list = entries->list;
+ while (list != NULL) {
+ next = list->next;
+ git__free((char *) list->entry->value);
+ git__free(list->entry);
+ git__free(list);
+ list = next;
+ }
+
+ git__free(entries);
+}
+
+void git_config_entries_free(git_config_entries *entries)
+{
+ if (entries)
+ GIT_REFCOUNT_DEC(entries, config_entries_free);
+}
+
+int git_config_entries_append(git_config_entries *entries, git_config_entry *entry)
+{
+ config_entry_list *list_head;
+ config_entry_map_head *map_head;
+
+ if ((map_head = git_strmap_get(entries->map, entry->name)) != NULL) {
+ map_head->multivar = true;
+ /*
+ * This is a micro-optimization for configuration files
+ * with a lot of same keys. As for multivars the entry's
+ * key will be the same for all entries, we can just free
+ * all except the first entry's name and just re-use it.
+ */
+ git__free((char *) entry->name);
+ entry->name = map_head->entry->name;
+ } else {
+ map_head = git__calloc(1, sizeof(*map_head));
+ if ((git_strmap_set(entries->map, entry->name, map_head)) < 0)
+ return -1;
+ }
+ map_head->entry = entry;
+
+ list_head = git__calloc(1, sizeof(config_entry_list));
+ GIT_ERROR_CHECK_ALLOC(list_head);
+ list_head->entry = entry;
+
+ if (entries->list)
+ entries->list->last->next = list_head;
+ else
+ entries->list = list_head;
+ entries->list->last = list_head;
+
+ return 0;
+}
+
+int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key)
+{
+ config_entry_map_head *entry;
+ if ((entry = git_strmap_get(entries->map, key)) == NULL)
+ return GIT_ENOTFOUND;
+ *out = entry->entry;
+ return 0;
+}
+
+int git_config_entries_get_unique(git_config_entry **out, git_config_entries *entries, const char *key)
+{
+ config_entry_map_head *entry;
+
+ if ((entry = git_strmap_get(entries->map, key)) == NULL)
+ return GIT_ENOTFOUND;
+
+ if (entry->multivar) {
+ git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being a multivar");
+ return -1;
+ }
+
+ if (entry->entry->include_depth) {
+ git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being included");
+ return -1;
+ }
+
+ *out = entry->entry;
+
+ return 0;
+}
+
+static void config_iterator_free(git_config_iterator *iter)
+{
+ config_entries_iterator *it = (config_entries_iterator *) iter;
+ git_config_entries_free(it->entries);
+ git__free(it);
+}
+
+static int config_iterator_next(
+ git_config_entry **entry,
+ git_config_iterator *iter)
+{
+ config_entries_iterator *it = (config_entries_iterator *) iter;
+
+ if (!it->head)
+ return GIT_ITEROVER;
+
+ *entry = it->head->entry;
+ it->head = it->head->next;
+
+ return 0;
+}
+
+int git_config_entries_iterator_new(git_config_iterator **out, git_config_entries *entries)
+{
+ config_entries_iterator *it;
+
+ it = git__calloc(1, sizeof(config_entries_iterator));
+ GIT_ERROR_CHECK_ALLOC(it);
+ it->parent.next = config_iterator_next;
+ it->parent.free = config_iterator_free;
+ it->head = entries->list;
+ it->entries = entries;
+
+ git_config_entries_incref(entries);
+ *out = &it->parent;
+
+ return 0;
+}
projects / libgit2.git / blobdiff