This graph shows which files directly or indirectly include this file:

Functions
void	libgit2_version (int major, int minor, int *rev)

const char *	libgit2_prerelease ()

int	libgit2_features ()

void	libgit2_opts (int option)

void	buf_dispose (git_buf *buffer)

git_oid	oid_fromstr (const char *str)

git_oid	oid_fromstrp (const char *str)

git_oid	oid_fromstrn (const char *str, size_t length)

git_oid	oid_fromraw (const unsigned char *raw)

char	oid_fmt (const git_oid *id)

char	oid_nfmt (size_t n, const git_oid *id)

char	oid_pathfmt (const git_oid *id)

char *	oid_tostr_s (const git_oid *oid)

char *	oid_tostr (size_t n, const git_oid *id)

git_oid	oid_cpy (const git_oid *src)

int	oid_cmp (const git_oid a, const git_oid b)

void	oid_equal (const git_oid a, const git_oid b)

void	oid_ncmp (const git_oid a, const git_oid b, size_t len)

void	oid_streq (const git_oid id, const char str)

void	oid_strcmp (const git_oid id, const char str)

void	oid_is_zero (const git_oid *id)

git_oid_shorten *	oid_shorten_new (size_t min_length)

void	oid_shorten_add (git_oid_shorten os, const char text_id)

void	oid_shorten_free (git_oid_shorten *os)

git_repository *	repository_open (const char *path)

git_repository *	repository_open_from_worktree (git_worktree *wt)

git_repository *	repository_wrap_odb (git_odb *odb)

git_buf	repository_discover (const char start_path, int across_fs, const char ceiling_dirs)

git_repository *	repository_open_ext (const char path, unsigned int flags, const char ceiling_dirs)

git_repository *	repository_open_bare (const char *bare_path)

void	repository_free (git_repository *repo)

git_repository *	repository_init (const char *path, unsigned int is_bare)

void	repository_init_options_init (git_repository_init_options *opts, unsigned int version)

git_repository *	repository_init_ext (const char repo_path, git_repository_init_options opts)

git_reference *	repository_head (git_repository *repo)

git_reference *	repository_head_for_worktree (git_repository repo, const char name)

void	repository_head_detached (git_repository *repo)

void	repository_head_detached_for_worktree (git_repository repo, const char name)

void	repository_head_unborn (git_repository *repo)

void	repository_is_empty (git_repository *repo)

git_buf	repository_item_path (const git_repository *repo, git_repository_item_t item)

const char *	repository_path (const git_repository *repo)

const char *	repository_workdir (const git_repository *repo)

const char *	repository_commondir (const git_repository *repo)

void	repository_set_workdir (git_repository repo, const char workdir, int update_gitlink)

void	repository_is_bare (const git_repository *repo)

void	repository_is_worktree (const git_repository *repo)

git_config *	repository_config (git_repository *repo)

git_config *	repository_config_snapshot (git_repository *repo)

git_odb *	repository_odb (git_repository *repo)

git_refdb *	repository_refdb (git_repository *repo)

git_index *	repository_index (git_repository *repo)

git_buf	repository_message (git_repository *repo)

void	repository_message_remove (git_repository *repo)

void	repository_state_cleanup (git_repository *repo)

void	repository_fetchhead_foreach (git_repository repo, git_repository_fetchhead_foreach_cb callback, void payload)

void	repository_mergehead_foreach (git_repository repo, git_repository_mergehead_foreach_cb callback, void payload)

git_oid	repository_hashfile (git_repository repo, const char path, git_object_t type, const char *as_path)

void	repository_set_head (git_repository repo, const char refname)

void	repository_set_head_detached (git_repository repo, const git_oid committish)

void	repository_set_head_detached_from_annotated (git_repository repo, const git_annotated_commit committish)

void	repository_detach_head (git_repository *repo)

void	repository_state (git_repository *repo)

void	repository_set_namespace (git_repository repo, const char nmspace)

const char *	repository_get_namespace (git_repository *repo)

void	repository_is_shallow (git_repository *repo)

void	repository_ident (const char name, const char email, const git_repository *repo)

void	repository_set_ident (git_repository repo, const char name, const char *email)

git_annotated_commit *	annotated_commit_from_ref (git_repository repo, const git_reference ref)

git_annotated_commit *	annotated_commit_from_fetchhead (git_repository repo, const char branch_name, const char remote_url, const git_oid id)

git_annotated_commit *	annotated_commit_lookup (git_repository repo, const git_oid id)

git_annotated_commit *	annotated_commit_from_revspec (git_repository repo, const char revspec)

const git_oid *	annotated_commit_id (const git_annotated_commit *commit)

const char *	annotated_commit_ref (const git_annotated_commit *commit)

void	annotated_commit_free (git_annotated_commit *commit)

void	object_lookup (git_object *object, git_repository repo, const git_oid *id, git_object_t type)

void	object_lookup_prefix (git_object *object_out, git_repository repo, const git_oid *id, size_t len, git_object_t type)

git_object *	object_lookup_bypath (const git_object treeish, const char path, git_object_t type)

const git_oid *	object_id (const git_object *obj)

git_buf	object_short_id (const git_object *obj)

git_object_t	object_type (const git_object *obj)

git_repository *	object_owner (const git_object *obj)

void	object_free (git_object *object)

const char *	object_type2string (git_object_t type)

git_object_t	object_string2type (const char *str)

void	object_typeisloose (git_object_t type)

void	object_peel (git_object *peeled, const git_object object, git_object_t target_type)

void	object_dup (git_object *dest, git_object source)

void	object_rawcontent_is_valid (int valid, const char buf, size_t len, git_object_t type)

git_tree *	tree_lookup (git_repository repo, const git_oid id)

git_tree *	tree_lookup_prefix (git_repository repo, const git_oid id, size_t len)

void	tree_free (git_tree *tree)

const git_oid *	tree_id (const git_tree *tree)

git_repository *	tree_owner (const git_tree *tree)

size_t	tree_entrycount (const git_tree *tree)

const git_tree_entry *	tree_entry_byname (const git_tree tree, const char filename)

const git_tree_entry *	tree_entry_byindex (const git_tree *tree, size_t idx)

const git_tree_entry *	tree_entry_byid (const git_tree tree, const git_oid id)

git_tree_entry *	tree_entry_bypath (const git_tree root, const char path)

git_tree_entry *	tree_entry_dup (const git_tree_entry *source)

void	tree_entry_free (git_tree_entry *entry)

const char *	tree_entry_name (const git_tree_entry *entry)

const git_oid *	tree_entry_id (const git_tree_entry *entry)

git_object_t	tree_entry_type (const git_tree_entry *entry)

git_filemode_t	tree_entry_filemode (const git_tree_entry *entry)

git_filemode_t	tree_entry_filemode_raw (const git_tree_entry *entry)

void	tree_entry_cmp (const git_tree_entry e1, const git_tree_entry e2)

git_object *	tree_entry_to_object (git_repository repo, const git_tree_entry entry)

git_treebuilder *	treebuilder_new (git_repository repo, const git_tree source)

void	treebuilder_clear (git_treebuilder *bld)

size_t	treebuilder_entrycount (git_treebuilder *bld)

void	treebuilder_free (git_treebuilder *bld)

const git_tree_entry *	treebuilder_get (git_treebuilder bld, const char filename)

const git_tree_entry *	treebuilder_insert (git_treebuilder bld, const char filename, const git_oid *id, git_filemode_t filemode)

void	treebuilder_remove (git_treebuilder bld, const char filename)

void	treebuilder_filter (git_treebuilder bld, git_treebuilder_filter_cb filter, void payload)

void	treebuilder_write (git_oid id, git_treebuilder bld)

void	tree_walk (const git_tree tree, git_treewalk_mode mode, git_treewalk_cb callback, void payload)

git_tree *	tree_dup (git_tree *source)

git_oid	tree_create_updated (git_repository repo, git_tree baseline, size_t nupdates, const git_tree_update *updates)

void	strarray_dispose (git_strarray *array)

void	strarray_copy (git_strarray tgt, const git_strarray src)

git_reference *	reference_lookup (git_repository repo, const char name)

git_oid	reference_name_to_id (git_repository repo, const char name)

git_reference *	reference_dwim (git_repository repo, const char shorthand)

git_reference *	reference_symbolic_create_matching (git_repository repo, const char name, const char target, int force, const char current_value, const char *log_message)

git_reference *	reference_symbolic_create (git_repository repo, const char name, const char target, int force, const char log_message)

git_reference *	reference_create (git_repository repo, const char name, const git_oid id, int force, const char log_message)

git_reference *	reference_create_matching (git_repository repo, const char name, const git_oid id, int force, const git_oid current_id, const char *log_message)

const git_oid *	reference_target (const git_reference *ref)

const git_oid *	reference_target_peel (const git_reference *ref)

const char *	reference_symbolic_target (const git_reference *ref)

git_reference_t	reference_type (const git_reference *ref)

const char *	reference_name (const git_reference *ref)

git_reference *	reference_resolve (const git_reference *ref)

git_repository *	reference_owner (const git_reference *ref)

git_reference *	reference_symbolic_set_target (git_reference ref, const char target, const char *log_message)

git_reference *	reference_set_target (git_reference ref, const git_oid id, const char *log_message)

void	reference_rename (git_reference *new_ref, git_reference ref, const char new_name, int force, const char log_message)

void	reference_delete (git_reference *ref)

void	reference_remove (git_repository repo, const char name)

void	reference_list (git_strarray array, git_repository repo)

void	reference_foreach (git_repository repo, git_reference_foreach_cb callback, void payload)

void	reference_foreach_name (git_repository repo, git_reference_foreach_name_cb callback, void payload)

void	reference_dup (git_reference *dest, git_reference source)

void	reference_free (git_reference *ref)

void	reference_cmp (const git_reference ref1, const git_reference ref2)

git_reference_iterator *	reference_iterator_new (git_repository *repo)

git_reference_iterator *	reference_iterator_glob_new (git_repository repo, const char glob)

git_reference *	reference_next (git_reference_iterator *iter)

const char *	reference_next_name (git_reference_iterator *iter)

void	reference_iterator_free (git_reference_iterator *iter)

void	reference_foreach_glob (git_repository repo, const char glob, git_reference_foreach_name_cb callback, void *payload)

void	reference_has_log (git_repository repo, const char refname)

void	reference_ensure_log (git_repository repo, const char refname)

void	reference_is_branch (const git_reference *ref)

void	reference_is_remote (const git_reference *ref)

void	reference_is_tag (const git_reference *ref)

void	reference_is_note (const git_reference *ref)

void	reference_normalize_name (char buffer_out, size_t buffer_size, const char name, unsigned int flags)

git_object *	reference_peel (const git_reference *ref, git_object_t type)

void	reference_name_is_valid (int valid, const char refname)

const char *	reference_shorthand (const git_reference *ref)

void	diff_options_init (git_diff_options *opts, unsigned int version)

void	diff_find_options_init (git_diff_find_options *opts, unsigned int version)

void	diff_free (git_diff *diff)

git_diff *	diff_tree_to_tree (git_repository repo, git_tree old_tree, git_tree new_tree, const git_diff_options opts)

void	diff_tree_to_index (git_diff *diff, git_repository repo, git_tree old_tree, git_index index, const git_diff_options *opts)

void	diff_index_to_workdir (git_diff *diff, git_repository repo, git_index index, const git_diff_options opts)

void	diff_tree_to_workdir (git_diff *diff, git_repository repo, git_tree old_tree, const git_diff_options opts)

void	diff_tree_to_workdir_with_index (git_diff *diff, git_repository repo, git_tree old_tree, const git_diff_options opts)

void	diff_index_to_index (git_diff *diff, git_repository repo, git_index old_index, git_index new_index, const git_diff_options *opts)

void	diff_merge (git_diff onto, const git_diff from)

void	diff_find_similar (git_diff diff, const git_diff_find_options options)

size_t	diff_num_deltas (const git_diff *diff)

size_t	diff_num_deltas_of_type (const git_diff *diff, git_delta_t type)

const git_diff_delta *	diff_get_delta (const git_diff *diff, size_t idx)

void	diff_is_sorted_icase (const git_diff *diff)

void	diff_foreach (git_diff diff, git_diff_file_cb file_cb, git_diff_binary_cb binary_cb, git_diff_hunk_cb hunk_cb, git_diff_line_cb line_cb, void payload)

char	diff_status_char (git_delta_t status)

void	diff_print (git_diff diff, git_diff_format_t format, git_diff_line_cb print_cb, void payload)

git_buf	diff_to_buf (git_diff *diff, git_diff_format_t format)

void	diff_blobs (const git_blob old_blob, const char old_as_path, const git_blob new_blob, const char new_as_path, const git_diff_options options, git_diff_file_cb file_cb, git_diff_binary_cb binary_cb, git_diff_hunk_cb hunk_cb, git_diff_line_cb line_cb, void payload)

void	diff_blob_to_buffer (const git_blob old_blob, const char old_as_path, const char buffer, size_t buffer_len, const char buffer_as_path, const git_diff_options options, git_diff_file_cb file_cb, git_diff_binary_cb binary_cb, git_diff_hunk_cb hunk_cb, git_diff_line_cb line_cb, void payload)

void	diff_buffers (const void old_buffer, size_t old_len, const char old_as_path, const void new_buffer, size_t new_len, const char new_as_path, const git_diff_options options, git_diff_file_cb file_cb, git_diff_binary_cb binary_cb, git_diff_hunk_cb hunk_cb, git_diff_line_cb line_cb, void payload)

git_diff *	diff_from_buffer (const char *content, size_t content_len)

git_diff_stats *	diff_get_stats (git_diff *diff)

size_t	diff_stats_files_changed (const git_diff_stats *stats)

size_t	diff_stats_insertions (const git_diff_stats *stats)

size_t	diff_stats_deletions (const git_diff_stats *stats)

git_buf	diff_stats_to_buf (const git_diff_stats *stats, git_diff_stats_format_t format, size_t width)

void	diff_stats_free (git_diff_stats *stats)

void	diff_patchid_options_init (git_diff_patchid_options *opts, unsigned int version)

git_oid	diff_patchid (git_diff diff, git_diff_patchid_options opts)

void	apply_options_init (git_apply_options *opts, unsigned int version)

git_index *	apply_to_tree (git_repository repo, git_tree preimage, git_diff diff, const git_apply_options options)

void	apply (git_repository repo, git_diff diff, git_apply_location_t location, const git_apply_options *options)

git_attr_value_t	attr_value (const char *attr)

void	attr_get (const char *value_out, git_repository repo, uint32_t flags, const char path, const char name)

void	attr_get_ext (const char *value_out, git_repository repo, git_attr_options opts, const char path, const char *name)

void	attr_get_many (const char *values_out, git_repository repo, uint32_t flags, const char path, size_t num_attr, const char *names)

void	attr_get_many_ext (const char *values_out, git_repository repo, git_attr_options opts, const char path, size_t num_attr, const char **names)

void	attr_foreach (git_repository repo, uint32_t flags, const char path, git_attr_foreach_cb callback, void *payload)

void	attr_foreach_ext (git_repository repo, git_attr_options opts, const char path, git_attr_foreach_cb callback, void payload)

void	attr_cache_flush (git_repository *repo)

void	attr_add_macro (git_repository repo, const char name, const char *values)

void	blob_lookup (git_blob *blob, git_repository repo, const git_oid *id)

void	blob_lookup_prefix (git_blob *blob, git_repository repo, const git_oid *id, size_t len)

void	blob_free (git_blob *blob)

const git_oid *	blob_id (const git_blob *blob)

git_repository *	blob_owner (const git_blob *blob)

const void *	blob_rawcontent (const git_blob *blob)

git_object_size_t	blob_rawsize (const git_blob *blob)

void	blob_filter_options_init (git_blob_filter_options *opts, unsigned int version)

git_buf	blob_filter (git_blob blob, const char as_path, git_blob_filter_options *opts)

void	blob_create_from_workdir (git_oid id, git_repository repo, const char *relative_path)

void	blob_create_from_disk (git_oid id, git_repository repo, const char *path)

git_writestream *	blob_create_from_stream (git_repository repo, const char hintpath)

git_oid	blob_create_from_stream_commit (git_writestream *stream)

void	blob_create_from_buffer (git_oid id, git_repository repo, const void *buffer, size_t len)

void	blob_is_binary (const git_blob *blob)

void	blob_data_is_binary (const char *data, size_t len)

git_blob *	blob_dup (git_blob *source)

void	blame_options_init (git_blame_options *opts, unsigned int version)

uint32_t	blame_get_hunk_count (git_blame *blame)

const git_blame_hunk *	blame_get_hunk_byindex (git_blame *blame, uint32_t index)

const git_blame_hunk *	blame_get_hunk_byline (git_blame *blame, size_t lineno)

git_blame *	blame_file (git_repository repo, const char path, git_blame_options *options)

git_blame *	blame_buffer (git_blame reference, const char buffer, size_t buffer_len)

void	blame_free (git_blame *blame)

git_reference *	branch_create (git_repository repo, const char branch_name, const git_commit *target, int force)

void	branch_create_from_annotated (git_reference *ref_out, git_repository repository, const char branch_name, const git_annotated_commit commit, int force)

void	branch_delete (git_reference *branch)

git_branch_iterator *	branch_iterator_new (git_repository *repo, git_branch_t list_flags)

git_reference *	branch_next (git_branch_t out_type, git_branch_iterator iter)

void	branch_iterator_free (git_branch_iterator *iter)

git_reference *	branch_move (git_reference branch, const char new_branch_name, int force)

git_reference *	branch_lookup (git_repository repo, const char branch_name, git_branch_t branch_type)

const char *	branch_name (const git_reference *ref)

git_reference *	branch_upstream (const git_reference *branch)

void	branch_set_upstream (git_reference branch, const char branch_name)

git_buf	branch_upstream_name (git_repository repo, const char refname)

void	branch_is_head (const git_reference *branch)

void	branch_is_checked_out (const git_reference *branch)

git_buf	branch_remote_name (git_repository repo, const char refname)

void	branch_upstream_remote (git_buf buf, git_repository repo, const char *refname)

void	branch_upstream_merge (git_buf buf, git_repository repo, const char *refname)

void	branch_name_is_valid (int valid, const char name)

void	checkout_options_init (git_checkout_options *opts, unsigned int version)

void	checkout_head (git_repository repo, const git_checkout_options opts)

void	checkout_index (git_repository repo, git_index index, const git_checkout_options *opts)

void	checkout_tree (git_repository repo, const git_object treeish, const git_checkout_options *opts)

void	oidarray_dispose (git_oidarray *array)

void	indexer_options_init (git_indexer_options *opts, unsigned int version)

git_indexer *	indexer_new (const char path, unsigned int mode, git_odb odb, git_indexer_options *opts)

void	indexer_append (git_indexer idx, const void data, size_t size, git_indexer_progress *stats)

void	indexer_commit (git_indexer idx, git_indexer_progress stats)

const git_oid *	indexer_hash (const git_indexer *idx)

const char *	indexer_name (const git_indexer *idx)

void	indexer_free (git_indexer *idx)

git_index *	index_open (const char *index_path)

git_index *	index_new ()

void	index_free (git_index *index)

git_repository *	index_owner (const git_index *index)

void	index_caps (const git_index *index)

void	index_set_caps (git_index *index, int caps)

unsigned int	index_version (git_index *index)

void	index_set_version (git_index *index, unsigned int version)

void	index_read (git_index *index, int force)

void	index_write (git_index *index)

const char *	index_path (const git_index *index)

const git_oid *	index_checksum (git_index *index)

void	index_read_tree (git_index index, const git_tree tree)

git_oid	index_write_tree (git_index *index)

git_oid	index_write_tree_to (git_index index, git_repository repo)

size_t	index_entrycount (const git_index *index)

void	index_clear (git_index *index)

const git_index_entry *	index_get_byindex (git_index *index, size_t n)

const git_index_entry *	index_get_bypath (git_index index, const char path, int stage)

void	index_remove (git_index index, const char path, int stage)

void	index_remove_directory (git_index index, const char dir, int stage)

void	index_add (git_index index, const git_index_entry source_entry)

void	index_entry_stage (const git_index_entry *entry)

void	index_entry_is_conflict (const git_index_entry *entry)

void	index_iterator_new (git_index_iterator *iterator_out, git_index index)

const git_index_entry *	index_iterator_next (git_index_iterator *iterator)

void	index_iterator_free (git_index_iterator *iterator)

void	index_add_bypath (git_index index, const char path)

void	index_add_from_buffer (git_index index, const git_index_entry entry, const void *buffer, size_t len)

void	index_remove_bypath (git_index index, const char path)

void	index_add_all (git_index index, const git_strarray pathspec, unsigned int flags, git_index_matched_path_cb callback, void *payload)

void	index_remove_all (git_index index, const git_strarray pathspec, git_index_matched_path_cb callback, void *payload)

void	index_update_all (git_index index, const git_strarray pathspec, git_index_matched_path_cb callback, void *payload)

void	index_find (size_t at_pos, git_index index, const char *path)

void	index_find_prefix (size_t at_pos, git_index index, const char *prefix)

void	index_conflict_add (git_index index, const git_index_entry ancestor_entry, const git_index_entry our_entry, const git_index_entry their_entry)

void	index_conflict_get (const git_index_entry ancestor_out, const git_index_entry our_out, const git_index_entry *their_out, git_index index, const char *path)

void	index_conflict_remove (git_index index, const char path)

void	index_conflict_cleanup (git_index *index)

void	index_has_conflicts (const git_index *index)

void	index_conflict_iterator_new (git_index_conflict_iterator *iterator_out, git_index index)

void	index_conflict_next (const git_index_entry ancestor_out, const git_index_entry our_out, const git_index_entry *their_out, git_index_conflict_iterator iterator)

void	index_conflict_iterator_free (git_index_conflict_iterator *iterator)

void	merge_file_input_init (git_merge_file_input *opts, unsigned int version)

void	merge_file_options_init (git_merge_file_options *opts, unsigned int version)

void	merge_options_init (git_merge_options *opts, unsigned int version)

void	merge_analysis (git_merge_analysis_t analysis_out, git_merge_preference_t preference_out, git_repository repo, const git_annotated_commit *their_heads, size_t their_heads_len)

void	merge_analysis_for_ref (git_merge_analysis_t analysis_out, git_merge_preference_t preference_out, git_repository repo, git_reference our_ref, const git_annotated_commit **their_heads, size_t their_heads_len)

git_oid	merge_base (git_repository repo, const git_oid one, const git_oid *two)

git_oidarray	merge_bases (git_repository repo, const git_oid one, const git_oid *two)

git_oid	merge_base_many (git_repository *repo, size_t length, const git_oid input_array[])

git_oidarray	merge_bases_many (git_repository *repo, size_t length, const git_oid input_array[])

git_oid	merge_base_octopus (git_repository *repo, size_t length, const git_oid input_array[])

git_merge_file_result	merge_file (const git_merge_file_input ancestor, const git_merge_file_input ours, const git_merge_file_input theirs, const git_merge_file_options opts)

git_merge_file_result	merge_file_from_index (git_repository repo, const git_index_entry ancestor, const git_index_entry ours, const git_index_entry theirs, const git_merge_file_options *opts)

void	merge_file_result_free (git_merge_file_result *result)

git_index *	merge_trees (git_repository repo, const git_tree ancestor_tree, const git_tree our_tree, const git_tree their_tree, const git_merge_options *opts)

git_index *	merge_commits (git_repository repo, const git_commit our_commit, const git_commit their_commit, const git_merge_options opts)

void	merge (git_repository repo, const git_annotated_commit their_heads, size_t their_heads_len, const git_merge_options merge_opts, const git_checkout_options *checkout_opts)

void	cherrypick_options_init (git_cherrypick_options *opts, unsigned int version)

git_index *	cherrypick_commit (git_repository repo, git_commit cherrypick_commit, git_commit our_commit, unsigned int mainline, const git_merge_options merge_options)

void	cherrypick (git_repository repo, git_commit commit, const git_cherrypick_options *cherrypick_options)

void	refspec_parse (git_refspec *refspec, const char input, int is_fetch)

void	refspec_free (git_refspec *refspec)

const char *	refspec_src (const git_refspec *refspec)

const char *	refspec_dst (const git_refspec *refspec)

const char *	refspec_string (const git_refspec *refspec)

void	refspec_force (const git_refspec *refspec)

git_direction	refspec_direction (const git_refspec *spec)

void	refspec_src_matches (const git_refspec refspec, const char refname)

void	refspec_dst_matches (const git_refspec refspec, const char refname)

git_buf	refspec_transform (const git_refspec spec, const char name)

git_buf	refspec_rtransform (const git_refspec spec, const char name)

void	credential_free (git_credential *cred)

void	credential_has_username (git_credential *cred)

const char *	credential_get_username (git_credential *cred)

git_credential *	credential_userpass_plaintext_new (const char username, const char password)

git_credential *	credential_default_new ()

git_credential *	credential_username_new (const char *username)

git_credential *	credential_ssh_key_new (const char username, const char publickey, const char privatekey, const char passphrase)

git_credential *	credential_ssh_key_memory_new (const char username, const char publickey, const char privatekey, const char passphrase)

git_credential *	credential_ssh_interactive_new (const char username, git_credential_ssh_interactive_cb prompt_callback, void payload)

git_credential *	credential_ssh_key_from_agent (const char *username)

git_credential *	credential_ssh_custom_new (const char username, const char publickey, size_t publickey_len, git_credential_sign_cb sign_callback, void *payload)

git_packbuilder *	packbuilder_new (git_repository *repo)

unsigned int	packbuilder_set_threads (git_packbuilder *pb, unsigned int n)

void	packbuilder_insert (git_packbuilder pb, const git_oid id, const char *name)

void	packbuilder_insert_tree (git_packbuilder pb, const git_oid id)

void	packbuilder_insert_commit (git_packbuilder pb, const git_oid id)

void	packbuilder_insert_walk (git_packbuilder pb, git_revwalk walk)

void	packbuilder_insert_recur (git_packbuilder pb, const git_oid id, const char *name)

void	packbuilder_write_buf (git_buf buf, git_packbuilder pb)

void	packbuilder_write (git_packbuilder pb, const char path, unsigned int mode, git_indexer_progress_cb progress_cb, void *progress_cb_payload)

const git_oid *	packbuilder_hash (git_packbuilder *pb)

const char *	packbuilder_name (git_packbuilder *pb)

void	packbuilder_foreach (git_packbuilder pb, git_packbuilder_foreach_cb cb, void payload)

size_t	packbuilder_object_count (git_packbuilder *pb)

size_t	packbuilder_written (git_packbuilder *pb)

void	packbuilder_set_callbacks (git_packbuilder pb, git_packbuilder_progress progress_cb, void progress_cb_payload)

void	packbuilder_free (git_packbuilder *pb)

void	proxy_options_init (git_proxy_options *opts, unsigned int version)

git_remote *	remote_create (git_repository repo, const char name, const char *url)

void	remote_create_options_init (git_remote_create_options *opts, unsigned int version)

git_remote *	remote_create_with_opts (const char url, const git_remote_create_options opts)

git_remote *	remote_create_with_fetchspec (git_repository repo, const char name, const char url, const char fetch)

git_remote *	remote_create_anonymous (git_repository repo, const char url)

git_remote *	remote_create_detached (const char *url)

git_remote *	remote_lookup (git_repository repo, const char name)

void	remote_dup (git_remote *dest, git_remote source)

git_repository *	remote_owner (const git_remote *remote)

const char *	remote_name (const git_remote *remote)

const char *	remote_url (const git_remote *remote)

const char *	remote_pushurl (const git_remote *remote)

void	remote_set_url (git_repository repo, const char remote, const char *url)

void	remote_set_pushurl (git_repository repo, const char remote, const char *url)

void	remote_set_instance_url (git_remote remote, const char url)

void	remote_set_instance_pushurl (git_remote remote, const char url)

void	remote_add_fetch (git_repository repo, const char remote, const char *refspec)

void	remote_get_fetch_refspecs (git_strarray array, const git_remote remote)

void	remote_add_push (git_repository repo, const char remote, const char *refspec)

void	remote_get_push_refspecs (git_strarray array, const git_remote remote)

size_t	remote_refspec_count (const git_remote *remote)

const git_refspec *	remote_get_refspec (const git_remote *remote, size_t n)

const git_remote_head **	remote_ls (size_t size, git_remote remote)

void	remote_connected (const git_remote *remote)

void	remote_stop (git_remote *remote)

void	remote_disconnect (git_remote *remote)

void	remote_free (git_remote *remote)

git_strarray	remote_list (git_repository *repo)

void	remote_init_callbacks (git_remote_callbacks *opts, unsigned int version)

void	fetch_options_init (git_fetch_options *opts, unsigned int version)

void	push_options_init (git_push_options *opts, unsigned int version)

void	remote_connect_options_init (git_remote_connect_options *opts, unsigned int version)

void	remote_connect (git_remote remote, git_direction direction, const git_remote_callbacks callbacks, const git_proxy_options proxy_opts, const git_strarray custom_headers)

void	remote_connect_ext (git_remote remote, git_direction direction, const git_remote_connect_options opts)

void	remote_download (git_remote remote, const git_strarray refspecs, const git_fetch_options *opts)

void	remote_upload (git_remote remote, const git_strarray refspecs, const git_push_options *opts)

void	remote_update_tips (git_remote remote, const git_remote_callbacks callbacks, int update_fetchhead, git_remote_autotag_option_t download_tags, const char *reflog_message)

void	remote_fetch (git_remote remote, const git_strarray refspecs, const git_fetch_options opts, const char reflog_message)

void	remote_prune (git_remote remote, const git_remote_callbacks callbacks)

void	remote_push (git_remote remote, const git_strarray refspecs, const git_push_options *opts)

const git_indexer_progress *	remote_stats (git_remote *remote)

git_remote_autotag_option_t	remote_autotag (const git_remote *remote)

void	remote_set_autotag (git_repository repo, const char remote, git_remote_autotag_option_t value)

void	remote_prune_refs (const git_remote *remote)

void	remote_rename (git_strarray problems, git_repository repo, const char name, const char new_name)

void	remote_name_is_valid (int valid, const char remote_name)

void	remote_delete (git_repository repo, const char name)

git_buf	remote_default_branch (git_remote *remote)

void	clone_options_init (git_clone_options *opts, unsigned int version)

git_repository *	clone (const char url, const char local_path, const git_clone_options *options)

git_commit *	commit_lookup (git_repository repo, const git_oid id)

git_commit *	commit_lookup_prefix (git_repository repo, const git_oid id, size_t len)

void	commit_free (git_commit *commit)

const git_oid *	commit_id (const git_commit *commit)

git_repository *	commit_owner (const git_commit *commit)

const char *	commit_message_encoding (const git_commit *commit)

const char *	commit_message (const git_commit *commit)

const char *	commit_message_raw (const git_commit *commit)

const char *	commit_summary (git_commit *commit)

const char *	commit_body (git_commit *commit)

git_time_t	commit_time (const git_commit *commit)

int	commit_time_offset (const git_commit *commit)

const git_signature *	commit_committer (const git_commit *commit)

const git_signature *	commit_author (const git_commit *commit)

git_signature *	commit_committer_with_mailmap (const git_commit commit, const git_mailmap mailmap)

git_signature *	commit_author_with_mailmap (const git_commit commit, const git_mailmap mailmap)

const char *	commit_raw_header (const git_commit *commit)

git_tree *	commit_tree (const git_commit *commit)

const git_oid *	commit_tree_id (const git_commit *commit)

unsigned int	commit_parentcount (const git_commit *commit)

git_commit *	commit_parent (const git_commit *commit, unsigned int n)

const git_oid *	commit_parent_id (const git_commit *commit, unsigned int n)

void	commit_nth_gen_ancestor (git_commit *ancestor, const git_commit commit, unsigned int n)

git_buf	commit_header_field (const git_commit commit, const char field)

void	commit_extract_signature (git_buf signature, git_buf signed_data, git_repository repo, git_oid commit_id, const char *field)

void	commit_create (git_oid id, git_repository repo, const char update_ref, const git_signature author, const git_signature committer, const char message_encoding, const char message, const git_tree tree, size_t parent_count, const git_commit *parents[])

void	commit_create_v (git_oid id, git_repository repo, const char update_ref, const git_signature author, const git_signature committer, const char message_encoding, const char message, const git_tree tree, size_t parent_count)

void	commit_amend (git_oid id, const git_commit commit_to_amend, const char update_ref, const git_signature author, const git_signature committer, const char message_encoding, const char message, const git_tree tree)

git_buf	commit_create_buffer (git_repository repo, const git_signature author, const git_signature committer, const char message_encoding, const char message, const git_tree tree, size_t parent_count, const git_commit *parents[])

git_oid	commit_create_with_signature (git_repository repo, const char commit_content, const char signature, const char signature_field)

git_commit *	commit_dup (git_commit *source)

void	config_entry_free (git_config_entry *entry)

git_buf	config_find_global ()

git_buf	config_find_xdg ()

git_buf	config_find_system ()

git_buf	config_find_programdata ()

git_config *	config_open_default ()

git_config *	config_new ()

void	config_add_file_ondisk (git_config cfg, const char path, git_config_level_t level, const git_repository *repo, int force)

git_config *	config_open_ondisk (const char *path)

git_config *	config_open_level (const git_config *parent, git_config_level_t level)

git_config *	config_open_global (git_config *config)

git_config *	config_snapshot (git_config *config)

void	config_free (git_config *cfg)

git_config_entry *	config_get_entry (const git_config cfg, const char name)

int32_t	config_get_int32 (const git_config cfg, const char name)

int64_t	config_get_int64 (const git_config cfg, const char name)

int	config_get_bool (const git_config cfg, const char name)

git_buf	config_get_path (const git_config cfg, const char name)

const char *	config_get_string (const git_config cfg, const char name)

git_buf	config_get_string_buf (const git_config cfg, const char name)

void	config_get_multivar_foreach (const git_config cfg, const char name, const char regexp, git_config_foreach_cb callback, void payload)

git_config_iterator *	config_multivar_iterator_new (const git_config cfg, const char name, const char *regexp)

git_config_entry *	config_next (git_config_iterator *iter)

void	config_iterator_free (git_config_iterator *iter)

void	config_set_int32 (git_config cfg, const char name, int32_t value)

void	config_set_int64 (git_config cfg, const char name, int64_t value)

void	config_set_bool (git_config cfg, const char name, int value)

void	config_set_string (git_config cfg, const char name, const char *value)

void	config_set_multivar (git_config cfg, const char name, const char regexp, const char value)

void	config_delete_entry (git_config cfg, const char name)

void	config_delete_multivar (git_config cfg, const char name, const char *regexp)

void	config_foreach (const git_config cfg, git_config_foreach_cb callback, void payload)

git_config_iterator *	config_iterator_new (const git_config *cfg)

git_config_iterator *	config_iterator_glob_new (const git_config cfg, const char regexp)

void	config_foreach_match (const git_config cfg, const char regexp, git_config_foreach_cb callback, void *payload)

int	config_get_mapped (const git_config cfg, const char name, const git_configmap *maps, size_t map_n)

int	config_lookup_map_value (const git_configmap maps, size_t map_n, const char value)

int	config_parse_bool (const char *value)

int32_t	config_parse_int32 (const char *value)

int64_t	config_parse_int64 (const char *value)

git_buf	config_parse_path (const char *value)

void	config_backend_foreach_match (git_config_backend backend, const char regexp, git_config_foreach_cb callback, void *payload)

void	config_lock (git_transaction *tx, git_config cfg)

void	describe_options_init (git_describe_options *opts, unsigned int version)

void	describe_format_options_init (git_describe_format_options *opts, unsigned int version)

void	describe_commit (git_describe_result *result, git_object committish, git_describe_options *opts)

git_describe_result *	describe_workdir (git_repository repo, git_describe_options opts)

git_buf	describe_format (const git_describe_result result, const git_describe_format_options opts)

void	describe_result_free (git_describe_result *result)

const git_error *	error_last ()

void	error_clear ()

void	error_set (int error_class, const char *fmt)

void	error_set_str (int error_class, const char *string)

void	error_set_oom ()

void	filter_list_load (git_filter_list *filters, git_repository repo, git_blob blob, const char path, git_filter_mode_t mode, uint32_t flags)

void	filter_list_load_ext (git_filter_list *filters, git_repository repo, git_blob blob, const char path, git_filter_mode_t mode, git_filter_options *opts)

void	filter_list_contains (git_filter_list filters, const char name)

git_buf	filter_list_apply_to_buffer (git_filter_list filters, const char in, size_t in_len)

git_buf	filter_list_apply_to_file (git_filter_list filters, git_repository repo, const char *path)

git_buf	filter_list_apply_to_blob (git_filter_list filters, git_blob blob)

void	filter_list_stream_buffer (git_filter_list filters, const char buffer, size_t len, git_writestream *target)

void	filter_list_stream_file (git_filter_list filters, git_repository repo, const char path, git_writestream target)

void	filter_list_stream_blob (git_filter_list filters, git_blob blob, git_writestream *target)

void	filter_list_free (git_filter_list *filters)

void	rebase_options_init (git_rebase_options *opts, unsigned int version)

git_rebase *	rebase_init (git_repository repo, const git_annotated_commit branch, const git_annotated_commit upstream, const git_annotated_commit onto, const git_rebase_options *opts)

git_rebase *	rebase_open (git_repository repo, const git_rebase_options opts)

const char *	rebase_orig_head_name (git_rebase *rebase)

const git_oid *	rebase_orig_head_id (git_rebase *rebase)

const char *	rebase_onto_name (git_rebase *rebase)

const git_oid *	rebase_onto_id (git_rebase *rebase)

size_t	rebase_operation_entrycount (git_rebase *rebase)

size_t	rebase_operation_current (git_rebase *rebase)

git_rebase_operation *	rebase_operation_byindex (git_rebase *rebase, size_t idx)

void	rebase_next (git_rebase_operation *operation, git_rebase rebase)

void	rebase_inmemory_index (git_index *index, git_rebase rebase)

void	rebase_commit (git_oid id, git_rebase rebase, const git_signature author, const git_signature committer, const char message_encoding, const char message)

void	rebase_abort (git_rebase *rebase)

void	rebase_finish (git_rebase rebase, const git_signature signature)

void	rebase_free (git_rebase *rebase)

void	trace_set (git_trace_level_t level, git_trace_cb cb)

void	revert_options_init (git_revert_options *opts, unsigned int version)

git_index *	revert_commit (git_repository repo, git_commit revert_commit, git_commit our_commit, unsigned int mainline, const git_merge_options merge_options)

void	revert (git_repository repo, git_commit commit, const git_revert_options *given_opts)

git_object *	revparse_single (git_repository repo, const char spec)

void	revparse_ext (git_object object_out, git_reference reference_out, git_repository repo, const char spec)

git_revspec	revparse (git_repository repo, const char spec)

git_oid	stash_save (git_repository repo, const git_signature stasher, const char *message, uint32_t flags)

void	stash_apply_options_init (git_stash_apply_options *opts, unsigned int version)

void	stash_apply (git_repository repo, size_t index, const git_stash_apply_options options)

void	stash_foreach (git_repository repo, git_stash_cb callback, void payload)

void	stash_drop (git_repository *repo, size_t index)

void	stash_pop (git_repository repo, size_t index, const git_stash_apply_options options)

void	status_options_init (git_status_options *opts, unsigned int version)

void	status_foreach (git_repository repo, git_status_cb callback, void payload)

void	status_foreach_ext (git_repository repo, const git_status_options opts, git_status_cb callback, void *payload)

void	status_file (unsigned int status_flags, git_repository repo, const char *path)

git_status_list *	status_list_new (git_repository repo, const git_status_options opts)

size_t	status_list_entrycount (git_status_list *statuslist)

const git_status_entry *	status_byindex (git_status_list *statuslist, size_t idx)

void	status_list_free (git_status_list *statuslist)

void	status_should_ignore (int ignored, git_repository repo, const char *path)

void	submodule_update_options_init (git_submodule_update_options *opts, unsigned int version)

void	submodule_update (git_submodule submodule, int init, git_submodule_update_options options)

git_submodule *	submodule_lookup (git_repository repo, const char name)

git_submodule *	submodule_dup (git_submodule *source)

void	submodule_free (git_submodule *submodule)

void	submodule_foreach (git_repository repo, git_submodule_cb callback, void payload)

git_submodule *	submodule_add_setup (git_repository repo, const char url, const char *path, int use_gitlink)

git_repository *	submodule_clone (git_submodule submodule, const git_submodule_update_options opts)

void	submodule_add_finalize (git_submodule *submodule)

void	submodule_add_to_index (git_submodule *submodule, int write_index)

git_repository *	submodule_owner (git_submodule *submodule)

const char *	submodule_name (git_submodule *submodule)

const char *	submodule_path (git_submodule *submodule)

const char *	submodule_url (git_submodule *submodule)

git_buf	submodule_resolve_url (git_repository repo, const char url)

const char *	submodule_branch (git_submodule *submodule)

void	submodule_set_branch (git_repository repo, const char name, const char *branch)

void	submodule_set_url (git_repository repo, const char name, const char *url)

const git_oid *	submodule_index_id (git_submodule *submodule)

const git_oid *	submodule_head_id (git_submodule *submodule)

const git_oid *	submodule_wd_id (git_submodule *submodule)

git_submodule_ignore_t	submodule_ignore (git_submodule *submodule)

void	submodule_set_ignore (git_repository repo, const char name, git_submodule_ignore_t ignore)

git_submodule_update_t	submodule_update_strategy (git_submodule *submodule)

void	submodule_set_update (git_repository repo, const char name, git_submodule_update_t update)

git_submodule_recurse_t	submodule_fetch_recurse_submodules (git_submodule *submodule)

void	submodule_set_fetch_recurse_submodules (git_repository repo, const char name, git_submodule_recurse_t fetch_recurse_submodules)

void	submodule_init (git_submodule *submodule, int overwrite)

git_repository *	submodule_repo_init (const git_submodule *sm, int use_gitlink)

void	submodule_sync (git_submodule *submodule)

void	submodule_open (git_repository *repo, git_submodule submodule)

void	submodule_reload (git_submodule *submodule, int force)

void	submodule_status (unsigned int status, git_repository repo, const char *name, git_submodule_ignore_t ignore)

void	submodule_location (unsigned int location_status, git_submodule submodule)

git_strarray	worktree_list (git_repository *repo)

git_worktree *	worktree_lookup (git_repository repo, const char name)

git_worktree *	worktree_open_from_repository (git_repository *repo)

void	worktree_free (git_worktree *wt)

void	worktree_validate (const git_worktree *wt)

void	worktree_add_options_init (git_worktree_add_options *opts, unsigned int version)

git_worktree *	worktree_add (git_repository repo, const char name, const char path, const git_worktree_add_options opts)

void	worktree_lock (git_worktree wt, const char reason)

void	worktree_unlock (git_worktree *wt)

void	worktree_is_locked (git_buf reason, const git_worktree wt)

const char *	worktree_name (const git_worktree *wt)

const char *	worktree_path (const git_worktree *wt)

void	worktree_prune_options_init (git_worktree_prune_options *opts, unsigned int version)

void	worktree_is_prunable (git_worktree wt, git_worktree_prune_options opts)

void	worktree_prune (git_worktree wt, git_worktree_prune_options opts)

git_credential *	credential_userpass (const char url, const char user_from_url, unsigned int allowed_types, void *payload)

git_buf	email_create_from_diff (git_diff diff, size_t patch_idx, size_t patch_count, const git_oid commit_id, const char summary, const char body, const git_signature author, const git_email_create_options opts)

git_buf	email_create_from_commit (git_commit commit, const git_email_create_options opts)

void	libgit2_init ()

void	libgit2_shutdown ()

void	graph_ahead_behind (size_t ahead, size_t behind, git_repository repo, const git_oid local, const git_oid *upstream)

void	graph_descendant_of (git_repository repo, const git_oid commit, const git_oid *ancestor)

void	graph_reachable_from_any (git_repository repo, const git_oid commit, const git_oid descendant_array[], size_t length)

void	ignore_add_rule (git_repository repo, const char rules)

void	ignore_clear_internal_rules (git_repository *repo)

void	ignore_path_is_ignored (int ignored, git_repository repo, const char *path)

git_mailmap *	mailmap_new ()

void	mailmap_free (git_mailmap *mm)

void	mailmap_add_entry (git_mailmap mm, const char real_name, const char real_email, const char replace_name, const char *replace_email)

git_mailmap *	mailmap_from_buffer (const char *buf, size_t len)

git_mailmap *	mailmap_from_repository (git_repository *repo)

void	mailmap_resolve (const char real_name, const char real_email, const git_mailmap mm, const char name, const char *email)

git_signature *	mailmap_resolve_signature (const git_mailmap mm, const git_signature sig)

git_buf	message_prettify (const char *message, int strip_comments, char comment_char)

void	message_trailers (git_message_trailer_array arr, const char message)

void	message_trailer_array_free (git_message_trailer_array *arr)

git_note_iterator *	note_iterator_new (git_repository repo, const char notes_ref)

git_note_iterator *	note_commit_iterator_new (git_commit *notes_commit)

void	note_iterator_free (git_note_iterator *it)

void	note_next (git_oid note_id, git_oid annotated_id, git_note_iterator *it)

git_note *	note_read (git_repository repo, const char notes_ref, const git_oid *oid)

git_note *	note_commit_read (git_repository repo, git_commit notes_commit, const git_oid *oid)

const git_signature *	note_author (const git_note *note)

const git_signature *	note_committer (const git_note *note)

const char *	note_message (const git_note *note)

const git_oid *	note_id (const git_note *note)

git_oid	note_create (git_repository repo, const char notes_ref, const git_signature author, const git_signature committer, const git_oid oid, const char note, int force)

void	note_commit_create (git_oid notes_commit_out, git_oid notes_blob_out, git_repository repo, git_commit parent, const git_signature author, const git_signature committer, const git_oid oid, const char note, int allow_note_overwrite)

void	note_remove (git_repository repo, const char notes_ref, const git_signature author, const git_signature committer, const git_oid *oid)

void	note_commit_remove (git_oid notes_commit_out, git_repository repo, git_commit notes_commit, const git_signature author, const git_signature committer, const git_oid oid)

void	note_free (git_note *note)

git_buf	note_default_ref (git_repository *repo)

void	note_foreach (git_repository repo, const char notes_ref, git_note_foreach_cb note_cb, void *payload)

git_odb *	odb_new ()

git_odb *	odb_open (const char *objects_dir)

void	odb_add_disk_alternate (git_odb odb, const char path)

void	odb_free (git_odb *db)

git_odb_object *	odb_read (git_odb db, const git_oid id)

git_odb_object *	odb_read_prefix (git_odb db, const git_oid short_id, size_t len)

void	odb_read_header (size_t len_out, git_object_t type_out, git_odb db, const git_oid id)

void	odb_exists (git_odb db, const git_oid id)

void	odb_exists_ext (git_odb db, const git_oid id, unsigned int flags)

git_oid	odb_exists_prefix (git_odb db, const git_oid short_id, size_t len)

void	odb_expand_ids (git_odb db, git_odb_expand_id ids, size_t count)

void	odb_refresh (struct git_odb *db)

void	odb_foreach (git_odb db, git_odb_foreach_cb cb, void payload)

git_oid	odb_write (git_odb odb, const void data, size_t len, git_object_t type)

git_odb_stream *	odb_open_wstream (git_odb *db, git_object_size_t size, git_object_t type)

void	odb_stream_write (git_odb_stream stream, const char buffer, size_t len)

git_oid	odb_stream_finalize_write (git_odb_stream *stream)

void	odb_stream_read (git_odb_stream stream, char buffer, size_t len)

void	odb_stream_free (git_odb_stream *stream)

git_odb_stream *	odb_open_rstream (size_t len, git_object_t type, git_odb db, const git_oid oid)

git_odb_writepack *	odb_write_pack (git_odb db, git_indexer_progress_cb progress_cb, void progress_payload)

void	odb_write_multi_pack_index (git_odb *db)

git_oid	odb_hash (const void *data, size_t len, git_object_t type)

git_oid	odb_hashfile (const char *path, git_object_t type)

void	odb_object_dup (git_odb_object *dest, git_odb_object source)

void	odb_object_free (git_odb_object *object)

const git_oid *	odb_object_id (git_odb_object *object)

const void *	odb_object_data (git_odb_object *object)

size_t	odb_object_size (git_odb_object *object)

git_object_t	odb_object_type (git_odb_object *object)

void	odb_add_backend (git_odb odb, git_odb_backend backend, int priority)

void	odb_add_alternate (git_odb odb, git_odb_backend backend, int priority)

size_t	odb_num_backends (git_odb *odb)

git_odb_backend *	odb_get_backend (git_odb *odb, size_t pos)

void	odb_set_commit_graph (git_odb odb, git_commit_graph cgraph)

git_odb_backend *	odb_backend_pack (const char *objects_dir)

git_odb_backend *	odb_backend_loose (const char *objects_dir, int compression_level, int do_fsync, unsigned int dir_mode, unsigned int file_mode)

git_odb_backend *	odb_backend_one_pack (const char *index_file)

git_repository *	patch_owner (const git_patch *patch)

git_patch *	patch_from_diff (git_diff *diff, size_t idx)

git_patch *	patch_from_blobs (const git_blob old_blob, const char old_as_path, const git_blob new_blob, const char new_as_path, const git_diff_options *opts)

git_patch *	patch_from_blob_and_buffer (const git_blob old_blob, const char old_as_path, const void buffer, size_t buffer_len, const char buffer_as_path, const git_diff_options *opts)

git_patch *	patch_from_buffers (const void old_buffer, size_t old_len, const char old_as_path, const void new_buffer, size_t new_len, const char new_as_path, const git_diff_options *opts)

void	patch_free (git_patch *patch)

const git_diff_delta *	patch_get_delta (const git_patch *patch)

size_t	patch_num_hunks (const git_patch *patch)

void	patch_line_stats (size_t total_context, size_t total_additions, size_t total_deletions, const git_patch patch)

const git_diff_hunk *	patch_get_hunk (size_t lines_in_hunk, git_patch patch, size_t hunk_idx)

void	patch_num_lines_in_hunk (const git_patch *patch, size_t hunk_idx)

const git_diff_line *	patch_get_line_in_hunk (git_patch *patch, size_t hunk_idx, size_t line_of_hunk)

size_t	patch_size (git_patch *patch, int include_context, int include_hunk_headers, int include_file_headers)

void	patch_print (git_patch patch, git_diff_line_cb print_cb, void payload)

git_buf	patch_to_buf (git_patch *patch)

git_pathspec *	pathspec_new (const git_strarray *pathspec)

void	pathspec_free (git_pathspec *ps)

void	pathspec_matches_path (const git_pathspec ps, uint32_t flags, const char path)

git_pathspec_match_list *	pathspec_match_workdir (git_repository repo, uint32_t flags, git_pathspec ps)

git_pathspec_match_list *	pathspec_match_index (git_index index, uint32_t flags, git_pathspec ps)

git_pathspec_match_list *	pathspec_match_tree (git_tree tree, uint32_t flags, git_pathspec ps)

git_pathspec_match_list *	pathspec_match_diff (git_diff diff, uint32_t flags, git_pathspec ps)

void	pathspec_match_list_free (git_pathspec_match_list *m)

size_t	pathspec_match_list_entrycount (const git_pathspec_match_list *m)

const char *	pathspec_match_list_entry (const git_pathspec_match_list *m, size_t pos)

const git_diff_delta *	pathspec_match_list_diff_entry (const git_pathspec_match_list *m, size_t pos)

size_t	pathspec_match_list_failed_entrycount (const git_pathspec_match_list *m)

const char *	pathspec_match_list_failed_entry (const git_pathspec_match_list *m, size_t pos)

git_refdb *	refdb_new (git_repository *repo)

git_refdb *	refdb_open (git_repository *repo)

void	refdb_compress (git_refdb *refdb)

void	refdb_free (git_refdb *refdb)

git_reflog *	reflog_read (git_repository repo, const char name)

void	reflog_write (git_reflog *reflog)

void	reflog_append (git_reflog reflog, const git_oid id, const git_signature committer, const char msg)

void	reflog_rename (git_repository repo, const char old_name, const char *name)

void	reflog_delete (git_repository repo, const char name)

size_t	reflog_entrycount (git_reflog *reflog)

const git_reflog_entry *	reflog_entry_byindex (const git_reflog *reflog, size_t idx)

void	reflog_drop (git_reflog *reflog, size_t idx, int rewrite_previous_entry)

const git_oid *	reflog_entry_id_old (const git_reflog_entry *entry)

const git_oid *	reflog_entry_id_new (const git_reflog_entry *entry)

const git_signature *	reflog_entry_committer (const git_reflog_entry *entry)

const char *	reflog_entry_message (const git_reflog_entry *entry)

void	reflog_free (git_reflog *reflog)

void	reset (git_repository repo, const git_object target, git_reset_t reset_type, const git_checkout_options *checkout_opts)

void	reset_from_annotated (git_repository repo, const git_annotated_commit commit, git_reset_t reset_type, const git_checkout_options *checkout_opts)

void	reset_default (git_repository repo, const git_object target, const git_strarray *pathspecs)

git_revwalk *	revwalk_new (git_repository *repo)

void	revwalk_reset (git_revwalk *walker)

void	revwalk_push (git_revwalk walk, const git_oid id)

void	revwalk_push_glob (git_revwalk walk, const char glob)

void	revwalk_push_head (git_revwalk *walk)

void	revwalk_hide (git_revwalk walk, const git_oid commit_id)

void	revwalk_hide_glob (git_revwalk walk, const char glob)

void	revwalk_hide_head (git_revwalk *walk)

void	revwalk_push_ref (git_revwalk walk, const char refname)

void	revwalk_hide_ref (git_revwalk walk, const char refname)

int	revwalk_next (git_oid out, git_revwalk walk)

void	revwalk_sorting (git_revwalk *walk, unsigned int sort_mode)

void	revwalk_push_range (git_revwalk walk, const char range)

void	revwalk_simplify_first_parent (git_revwalk *walk)

void	revwalk_free (git_revwalk *walk)

git_repository *	revwalk_repository (git_revwalk *walk)

void	revwalk_add_hide_cb (git_revwalk walk, git_revwalk_hide_cb hide_cb, void payload)

git_signature *	signature_new (const char name, const char email, git_time_t time, int offset)

git_signature *	signature_now (const char name, const char email)

git_signature *	signature_default (git_repository *repo)

git_signature *	signature_from_buffer (const char *buf)

void	signature_dup (git_signature *dest, const git_signature sig)

void	signature_free (git_signature *sig)

git_tag *	tag_lookup (git_repository repo, const git_oid id)

git_tag *	tag_lookup_prefix (git_repository repo, const git_oid id, size_t len)

void	tag_free (git_tag *tag)

const git_oid *	tag_id (const git_tag *tag)

git_repository *	tag_owner (const git_tag *tag)

void	tag_target (git_object *target_out, const git_tag tag)

const git_oid *	tag_target_id (const git_tag *tag)

git_object_t	tag_target_type (const git_tag *tag)

const char *	tag_name (const git_tag *tag)

const git_signature *	tag_tagger (const git_tag *tag)

const char *	tag_message (const git_tag *tag)

void	tag_create (git_oid oid, git_repository repo, const char tag_name, const git_object target, const git_signature tagger, const char message, int force)

void	tag_annotation_create (git_oid oid, git_repository repo, const char tag_name, const git_object target, const git_signature tagger, const char message)

void	tag_create_from_buffer (git_oid oid, git_repository repo, const char *buffer, int force)

void	tag_create_lightweight (git_oid oid, git_repository repo, const char tag_name, const git_object target, int force)

void	tag_delete (git_repository repo, const char tag_name)

void	tag_list (git_strarray tag_names, git_repository repo)

void	tag_list_match (git_strarray tag_names, const char pattern, git_repository *repo)

void	tag_foreach (git_repository repo, git_tag_foreach_cb callback, void payload)

void	tag_peel (git_object *tag_target_out, const git_tag tag)

git_tag *	tag_dup (git_tag *source)

void	tag_name_is_valid (int valid, const char name)

git_transaction *	transaction_new (git_repository *repo)

void	transaction_lock_ref (git_transaction tx, const char refname)

void	transaction_set_target (git_transaction tx, const char refname, const git_oid target, const git_signature sig, const char *msg)

void	transaction_set_symbolic_target (git_transaction tx, const char refname, const char target, const git_signature sig, const char *msg)

void	transaction_set_reflog (git_transaction tx, const char refname, const git_reflog *reflog)

void	transaction_remove (git_transaction tx, const char refname)

void	transaction_commit (git_transaction *tx)

void	transaction_free (git_transaction *tx)

Function Documentation

◆ annotated_commit_free()

void annotated_commit_free ( git_annotated_commit * commit )

inline

◆ annotated_commit_from_fetchhead()

git_annotated_commit* annotated_commit_from_fetchhead	(	git_repository *	repo,
		const char *	branch_name,
		const char *	remote_url,
		const git_oid *	id
	)

inline

◆ annotated_commit_from_ref()

git_annotated_commit* annotated_commit_from_ref	(	git_repository *	repo,
		const git_reference *	ref
	)

inline

◆ annotated_commit_from_revspec()

git_annotated_commit* annotated_commit_from_revspec	(	git_repository *	repo,
		const char *	revspec
	)

inline

◆ annotated_commit_id()

const git_oid* annotated_commit_id ( const git_annotated_commit * commit )

inline

◆ annotated_commit_lookup()

git_annotated_commit* annotated_commit_lookup	(	git_repository *	repo,
		const git_oid *	id
	)

inline

◆ annotated_commit_ref()

const char* annotated_commit_ref ( const git_annotated_commit * commit )

inline

◆ apply()

void apply	(	git_repository *	repo,
		git_diff *	diff,
		git_apply_location_t	location,
		const git_apply_options *	options
	)

inline

◆ apply_options_init()

void apply_options_init	(	git_apply_options *	opts,
		unsigned int	version
	)

inline

◆ apply_to_tree()

git_index* apply_to_tree	(	git_repository *	repo,
		git_tree *	preimage,
		git_diff *	diff,
		const git_apply_options *	options
	)

inline

◆ attr_add_macro()

void attr_add_macro	(	git_repository *	repo,
		const char *	name,
		const char *	values
	)

inline

◆ attr_cache_flush()

void attr_cache_flush ( git_repository * repo )

inline

◆ attr_foreach()

void attr_foreach	(	git_repository *	repo,
		uint32_t	flags,
		const char *	path,
		git_attr_foreach_cb	callback,
		void *	payload
	)

inline

◆ attr_foreach_ext()

void attr_foreach_ext	(	git_repository *	repo,
		git_attr_options *	opts,
		const char *	path,
		git_attr_foreach_cb	callback,
		void *	payload
	)

inline

◆ attr_get()

void attr_get	(	const char **	value_out,
		git_repository *	repo,
		uint32_t	flags,
		const char *	path,
		const char *	name
	)

inline

◆ attr_get_ext()

void attr_get_ext	(	const char **	value_out,
		git_repository *	repo,
		git_attr_options *	opts,
		const char *	path,
		const char *	name
	)

inline

◆ attr_get_many()

void attr_get_many	(	const char **	values_out,
		git_repository *	repo,
		uint32_t	flags,
		const char *	path,
		size_t	num_attr,
		const char **	names
	)

inline

◆ attr_get_many_ext()

void attr_get_many_ext	(	const char **	values_out,
		git_repository *	repo,
		git_attr_options *	opts,
		const char *	path,
		size_t	num_attr,
		const char **	names
	)

inline

◆ attr_value()

git_attr_value_t attr_value ( const char * attr )

inline

◆ blame_buffer()

git_blame* blame_buffer	(	git_blame *	reference,
		const char *	buffer,
		size_t	buffer_len
	)

inline

◆ blame_file()

git_blame* blame_file	(	git_repository *	repo,
		const char *	path,
		git_blame_options *	options
	)

inline

◆ blame_free()

void blame_free ( git_blame * blame )

inline

◆ blame_get_hunk_byindex()

const git_blame_hunk* blame_get_hunk_byindex	(	git_blame *	blame,
		uint32_t	index
	)

inline

◆ blame_get_hunk_byline()

const git_blame_hunk* blame_get_hunk_byline	(	git_blame *	blame,
		size_t	lineno
	)

inline

◆ blame_get_hunk_count()

uint32_t blame_get_hunk_count ( git_blame * blame )

inline

◆ blame_options_init()

void blame_options_init	(	git_blame_options *	opts,
		unsigned int	version
	)

inline

◆ blob_create_from_buffer()

void blob_create_from_buffer	(	git_oid *	id,
		git_repository *	repo,
		const void *	buffer,
		size_t	len
	)

inline

◆ blob_create_from_disk()

void blob_create_from_disk	(	git_oid *	id,
		git_repository *	repo,
		const char *	path
	)

inline

◆ blob_create_from_stream()

git_writestream* blob_create_from_stream	(	git_repository *	repo,
		const char *	hintpath
	)

inline

◆ blob_create_from_stream_commit()

git_oid blob_create_from_stream_commit ( git_writestream * stream )

inline

◆ blob_create_from_workdir()

void blob_create_from_workdir	(	git_oid *	id,
		git_repository *	repo,
		const char *	relative_path
	)

inline

◆ blob_data_is_binary()

void blob_data_is_binary	(	const char *	data,
		size_t	len
	)

inline

◆ blob_dup()

git_blob* blob_dup ( git_blob * source )

inline

◆ blob_filter()

git_buf blob_filter	(	git_blob *	blob,
		const char *	as_path,
		git_blob_filter_options *	opts
	)

inline

◆ blob_filter_options_init()

void blob_filter_options_init	(	git_blob_filter_options *	opts,
		unsigned int	version
	)

inline

◆ blob_free()

void blob_free ( git_blob * blob )

inline

◆ blob_id()

const git_oid* blob_id ( const git_blob * blob )

inline

◆ blob_is_binary()

void blob_is_binary ( const git_blob * blob )

inline

◆ blob_lookup()

void blob_lookup	(	git_blob **	blob,
		git_repository *	repo,
		const git_oid *	id
	)

inline

◆ blob_lookup_prefix()

void blob_lookup_prefix	(	git_blob **	blob,
		git_repository *	repo,
		const git_oid *	id,
		size_t	len
	)

inline

◆ blob_owner()

git_repository* blob_owner ( const git_blob * blob )

inline

◆ blob_rawcontent()

const void* blob_rawcontent ( const git_blob * blob )

inline

◆ blob_rawsize()

git_object_size_t blob_rawsize ( const git_blob * blob )

inline

◆ branch_create()

git_reference* branch_create	(	git_repository *	repo,
		const char *	branch_name,
		const git_commit *	target,
		int	force
	)

inline

◆ branch_create_from_annotated()

void branch_create_from_annotated	(	git_reference **	ref_out,
		git_repository *	repository,
		const char *	branch_name,
		const git_annotated_commit *	commit,
		int	force
	)

inline

◆ branch_delete()

void branch_delete ( git_reference * branch )

inline

◆ branch_is_checked_out()

void branch_is_checked_out ( const git_reference * branch )

inline

◆ branch_is_head()

void branch_is_head ( const git_reference * branch )

inline

◆ branch_iterator_free()

void branch_iterator_free ( git_branch_iterator * iter )

inline

◆ branch_iterator_new()

git_branch_iterator* branch_iterator_new	(	git_repository *	repo,
		git_branch_t	list_flags
	)

inline

◆ branch_lookup()

git_reference* branch_lookup	(	git_repository *	repo,
		const char *	branch_name,
		git_branch_t	branch_type
	)

inline

◆ branch_move()

git_reference* branch_move	(	git_reference *	branch,
		const char *	new_branch_name,
		int	force
	)

inline

◆ branch_name()

const char* branch_name ( const git_reference * ref )

inline

◆ branch_name_is_valid()

void branch_name_is_valid	(	int *	valid,
		const char *	name
	)

inline

◆ branch_next()

git_reference* branch_next	(	git_branch_t *	out_type,
		git_branch_iterator *	iter
	)

inline

◆ branch_remote_name()

git_buf branch_remote_name	(	git_repository *	repo,
		const char *	refname
	)

inline

◆ branch_set_upstream()

void branch_set_upstream	(	git_reference *	branch,
		const char *	branch_name
	)

inline

◆ branch_upstream()

git_reference* branch_upstream ( const git_reference * branch )

inline

◆ branch_upstream_merge()

void branch_upstream_merge	(	git_buf *	buf,
		git_repository *	repo,
		const char *	refname
	)

inline

◆ branch_upstream_name()

git_buf branch_upstream_name	(	git_repository *	repo,
		const char *	refname
	)

inline

◆ branch_upstream_remote()

void branch_upstream_remote	(	git_buf *	buf,
		git_repository *	repo,
		const char *	refname
	)

inline

◆ buf_dispose()

void buf_dispose ( git_buf * buffer )

inline

◆ checkout_head()

void checkout_head	(	git_repository *	repo,
		const git_checkout_options *	opts
	)

inline

◆ checkout_index()

void checkout_index	(	git_repository *	repo,
		git_index *	index,
		const git_checkout_options *	opts
	)

inline

◆ checkout_options_init()

void checkout_options_init	(	git_checkout_options *	opts,
		unsigned int	version
	)

inline

◆ checkout_tree()

void checkout_tree	(	git_repository *	repo,
		const git_object *	treeish,
		const git_checkout_options *	opts
	)

inline

◆ cherrypick()

void cherrypick	(	git_repository *	repo,
		git_commit *	commit,
		const git_cherrypick_options *	cherrypick_options
	)

inline

◆ cherrypick_commit()

git_index* cherrypick_commit	(	git_repository *	repo,
		git_commit *	cherrypick_commit,
		git_commit *	our_commit,
		unsigned int	mainline,
		const git_merge_options *	merge_options
	)

inline

◆ cherrypick_options_init()

void cherrypick_options_init	(	git_cherrypick_options *	opts,
		unsigned int	version
	)

inline

◆ clone()

git_repository* clone	(	const char *	url,
		const char *	local_path,
		const git_clone_options *	options
	)

inline

◆ clone_options_init()

void clone_options_init	(	git_clone_options *	opts,
		unsigned int	version
	)

inline

◆ commit_amend()

void commit_amend	(	git_oid *	id,
		const git_commit *	commit_to_amend,
		const char *	update_ref,
		const git_signature *	author,
		const git_signature *	committer,
		const char *	message_encoding,
		const char *	message,
		const git_tree *	tree
	)

inline

◆ commit_author()

const git_signature* commit_author ( const git_commit * commit )

inline

◆ commit_author_with_mailmap()

git_signature* commit_author_with_mailmap	(	const git_commit *	commit,
		const git_mailmap *	mailmap
	)

inline

◆ commit_body()

const char* commit_body ( git_commit * commit )

inline

◆ commit_committer()

const git_signature* commit_committer ( const git_commit * commit )

inline

◆ commit_committer_with_mailmap()

git_signature* commit_committer_with_mailmap	(	const git_commit *	commit,
		const git_mailmap *	mailmap
	)

inline

◆ commit_create()

void commit_create	(	git_oid *	id,
		git_repository *	repo,
		const char *	update_ref,
		const git_signature *	author,
		const git_signature *	committer,
		const char *	message_encoding,
		const char *	message,
		const git_tree *	tree,
		size_t	parent_count,
		const git_commit *	parents[]
	)

inline

◆ commit_create_buffer()

git_buf commit_create_buffer	(	git_repository *	repo,
		const git_signature *	author,
		const git_signature *	committer,
		const char *	message_encoding,
		const char *	message,
		const git_tree *	tree,
		size_t	parent_count,
		const git_commit *	parents[]
	)

inline

◆ commit_create_v()

void commit_create_v	(	git_oid *	id,
		git_repository *	repo,
		const char *	update_ref,
		const git_signature *	author,
		const git_signature *	committer,
		const char *	message_encoding,
		const char *	message,
		const git_tree *	tree,
		size_t	parent_count
	)

inline

◆ commit_create_with_signature()

git_oid commit_create_with_signature	(	git_repository *	repo,
		const char *	commit_content,
		const char *	signature,
		const char *	signature_field
	)

inline

◆ commit_dup()

git_commit* commit_dup ( git_commit * source )

inline

◆ commit_extract_signature()

void commit_extract_signature	(	git_buf *	signature,
		git_buf *	signed_data,
		git_repository *	repo,
		git_oid *	commit_id,
		const char *	field
	)

inline

◆ commit_free()

void commit_free ( git_commit * commit )

inline

◆ commit_header_field()

git_buf commit_header_field	(	const git_commit *	commit,
		const char *	field
	)

inline

◆ commit_id()

const git_oid* commit_id ( const git_commit * commit )

inline

◆ commit_lookup()

git_commit* commit_lookup	(	git_repository *	repo,
		const git_oid *	id
	)

inline

◆ commit_lookup_prefix()

git_commit* commit_lookup_prefix	(	git_repository *	repo,
		const git_oid *	id,
		size_t	len
	)

inline

◆ commit_message()

const char* commit_message ( const git_commit * commit )

inline

◆ commit_message_encoding()

const char* commit_message_encoding ( const git_commit * commit )

inline

◆ commit_message_raw()

const char* commit_message_raw ( const git_commit * commit )

inline

◆ commit_nth_gen_ancestor()

void commit_nth_gen_ancestor	(	git_commit **	ancestor,
		const git_commit *	commit,
		unsigned int	n
	)

inline

◆ commit_owner()

git_repository* commit_owner ( const git_commit * commit )

inline

◆ commit_parent()

git_commit* commit_parent	(	const git_commit *	commit,
		unsigned int	n
	)

inline

◆ commit_parent_id()

const git_oid* commit_parent_id	(	const git_commit *	commit,
		unsigned int	n
	)

inline

◆ commit_parentcount()

unsigned int commit_parentcount ( const git_commit * commit )

inline

◆ commit_raw_header()

const char* commit_raw_header ( const git_commit * commit )

inline

◆ commit_summary()

const char* commit_summary ( git_commit * commit )

inline

◆ commit_time()

git_time_t commit_time ( const git_commit * commit )

inline

◆ commit_time_offset()

int commit_time_offset ( const git_commit * commit )

inline

◆ commit_tree()

git_tree* commit_tree ( const git_commit * commit )

inline

◆ commit_tree_id()

const git_oid* commit_tree_id ( const git_commit * commit )

inline

◆ config_add_file_ondisk()

void config_add_file_ondisk	(	git_config *	cfg,
		const char *	path,
		git_config_level_t	level,
		const git_repository *	repo,
		int	force
	)

inline

◆ config_backend_foreach_match()

void config_backend_foreach_match	(	git_config_backend *	backend,
		const char *	regexp,
		git_config_foreach_cb	callback,
		void *	payload
	)

inline

◆ config_delete_entry()

void config_delete_entry	(	git_config *	cfg,
		const char *	name
	)

inline

◆ config_delete_multivar()

void config_delete_multivar	(	git_config *	cfg,
		const char *	name,
		const char *	regexp
	)

inline

◆ config_entry_free()

void config_entry_free ( git_config_entry * entry )

inline

◆ config_find_global()

git_buf config_find_global ( )

inline

◆ config_find_programdata()

git_buf config_find_programdata ( )

inline

◆ config_find_system()

git_buf config_find_system ( )

inline

◆ config_find_xdg()

git_buf config_find_xdg ( )

inline

◆ config_foreach()

void config_foreach	(	const git_config *	cfg,
		git_config_foreach_cb	callback,
		void *	payload
	)

inline

◆ config_foreach_match()

void config_foreach_match	(	const git_config *	cfg,
		const char *	regexp,
		git_config_foreach_cb	callback,
		void *	payload
	)

inline

◆ config_free()

void config_free ( git_config * cfg )

inline

◆ config_get_bool()

int config_get_bool	(	const git_config *	cfg,
		const char *	name
	)

inline

◆ config_get_entry()

git_config_entry* config_get_entry	(	const git_config *	cfg,
		const char *	name
	)

inline

◆ config_get_int32()

int32_t config_get_int32	(	const git_config *	cfg,
		const char *	name
	)

inline

◆ config_get_int64()

int64_t config_get_int64	(	const git_config *	cfg,
		const char *	name
	)

inline

◆ config_get_mapped()

int config_get_mapped	(	const git_config *	cfg,
		const char *	name,
		const git_configmap *	maps,
		size_t	map_n
	)

inline

◆ config_get_multivar_foreach()

void config_get_multivar_foreach	(	const git_config *	cfg,
		const char *	name,
		const char *	regexp,
		git_config_foreach_cb	callback,
		void *	payload
	)

inline

◆ config_get_path()

git_buf config_get_path	(	const git_config *	cfg,
		const char *	name
	)

inline

◆ config_get_string()

const char* config_get_string	(	const git_config *	cfg,
		const char *	name
	)

inline

◆ config_get_string_buf()

git_buf config_get_string_buf	(	const git_config *	cfg,
		const char *	name
	)

inline

◆ config_iterator_free()

void config_iterator_free ( git_config_iterator * iter )

inline

◆ config_iterator_glob_new()

git_config_iterator* config_iterator_glob_new	(	const git_config *	cfg,
		const char *	regexp
	)

inline

◆ config_iterator_new()

git_config_iterator* config_iterator_new ( const git_config * cfg )

inline

◆ config_lock()

void config_lock	(	git_transaction **	tx,
		git_config *	cfg
	)

inline

◆ config_lookup_map_value()

int config_lookup_map_value	(	const git_configmap *	maps,
		size_t	map_n,
		const char *	value
	)

inline

◆ config_multivar_iterator_new()

git_config_iterator* config_multivar_iterator_new	(	const git_config *	cfg,
		const char *	name,
		const char *	regexp
	)

inline

◆ config_new()

git_config* config_new ( )

inline

◆ config_next()

git_config_entry* config_next ( git_config_iterator * iter )

inline

◆ config_open_default()

git_config* config_open_default ( )

inline

◆ config_open_global()

git_config* config_open_global ( git_config * config )

inline

◆ config_open_level()

git_config* config_open_level	(	const git_config *	parent,
		git_config_level_t	level
	)

inline

◆ config_open_ondisk()

git_config* config_open_ondisk ( const char * path )

inline

◆ config_parse_bool()

int config_parse_bool ( const char * value )

inline

◆ config_parse_int32()

int32_t config_parse_int32 ( const char * value )

inline

◆ config_parse_int64()

int64_t config_parse_int64 ( const char * value )

inline

◆ config_parse_path()

git_buf config_parse_path ( const char * value )

inline

◆ config_set_bool()

void config_set_bool	(	git_config *	cfg,
		const char *	name,
		int	value
	)

inline

◆ config_set_int32()

void config_set_int32	(	git_config *	cfg,
		const char *	name,
		int32_t	value
	)

inline

◆ config_set_int64()

void config_set_int64	(	git_config *	cfg,
		const char *	name,
		int64_t	value
	)

inline

◆ config_set_multivar()

void config_set_multivar	(	git_config *	cfg,
		const char *	name,
		const char *	regexp,
		const char *	value
	)

inline

◆ config_set_string()

void config_set_string	(	git_config *	cfg,
		const char *	name,
		const char *	value
	)

inline

◆ config_snapshot()

git_config* config_snapshot ( git_config * config )

inline

◆ credential_default_new()

git_credential* credential_default_new ( )

inline

◆ credential_free()

void credential_free ( git_credential * cred )

inline

◆ credential_get_username()

const char* credential_get_username ( git_credential * cred )

inline

◆ credential_has_username()

void credential_has_username ( git_credential * cred )

inline

◆ credential_ssh_custom_new()

git_credential* credential_ssh_custom_new	(	const char *	username,
		const char *	publickey,
		size_t	publickey_len,
		git_credential_sign_cb	sign_callback,
		void *	payload
	)

inline

◆ credential_ssh_interactive_new()

git_credential* credential_ssh_interactive_new	(	const char *	username,
		git_credential_ssh_interactive_cb	prompt_callback,
		void *	payload
	)

inline

◆ credential_ssh_key_from_agent()

git_credential* credential_ssh_key_from_agent ( const char * username )

inline

◆ credential_ssh_key_memory_new()

git_credential* credential_ssh_key_memory_new	(	const char *	username,
		const char *	publickey,
		const char *	privatekey,
		const char *	passphrase
	)

inline

◆ credential_ssh_key_new()

git_credential* credential_ssh_key_new	(	const char *	username,
		const char *	publickey,
		const char *	privatekey,
		const char *	passphrase
	)

inline

◆ credential_username_new()

git_credential* credential_username_new ( const char * username )

inline

◆ credential_userpass()

git_credential* credential_userpass	(	const char *	url,
		const char *	user_from_url,
		unsigned int	allowed_types,
		void *	payload
	)

inline

◆ credential_userpass_plaintext_new()

git_credential* credential_userpass_plaintext_new	(	const char *	username,
		const char *	password
	)

inline

◆ describe_commit()

void describe_commit	(	git_describe_result **	result,
		git_object *	committish,
		git_describe_options *	opts
	)

inline

◆ describe_format()

git_buf describe_format	(	const git_describe_result *	result,
		const git_describe_format_options *	opts
	)

inline

◆ describe_format_options_init()

void describe_format_options_init	(	git_describe_format_options *	opts,
		unsigned int	version
	)

inline

◆ describe_options_init()

void describe_options_init	(	git_describe_options *	opts,
		unsigned int	version
	)

inline

◆ describe_result_free()

void describe_result_free ( git_describe_result * result )

inline

◆ describe_workdir()

git_describe_result* describe_workdir	(	git_repository *	repo,
		git_describe_options *	opts
	)

inline

◆ diff_blob_to_buffer()

void diff_blob_to_buffer	(	const git_blob *	old_blob,
		const char *	old_as_path,
		const char *	buffer,
		size_t	buffer_len,
		const char *	buffer_as_path,
		const git_diff_options *	options,
		git_diff_file_cb	file_cb,
		git_diff_binary_cb	binary_cb,
		git_diff_hunk_cb	hunk_cb,
		git_diff_line_cb	line_cb,
		void *	payload
	)

inline

◆ diff_blobs()

void diff_blobs	(	const git_blob *	old_blob,
		const char *	old_as_path,
		const git_blob *	new_blob,
		const char *	new_as_path,
		const git_diff_options *	options,
		git_diff_file_cb	file_cb,
		git_diff_binary_cb	binary_cb,
		git_diff_hunk_cb	hunk_cb,
		git_diff_line_cb	line_cb,
		void *	payload
	)

inline

◆ diff_buffers()

void diff_buffers	(	const void *	old_buffer,
		size_t	old_len,
		const char *	old_as_path,
		const void *	new_buffer,
		size_t	new_len,
		const char *	new_as_path,
		const git_diff_options *	options,
		git_diff_file_cb	file_cb,
		git_diff_binary_cb	binary_cb,
		git_diff_hunk_cb	hunk_cb,
		git_diff_line_cb	line_cb,
		void *	payload
	)

inline

◆ diff_find_options_init()

void diff_find_options_init	(	git_diff_find_options *	opts,
		unsigned int	version
	)

inline

◆ diff_find_similar()

void diff_find_similar	(	git_diff *	diff,
		const git_diff_find_options *	options
	)

inline

◆ diff_foreach()

void diff_foreach	(	git_diff *	diff,
		git_diff_file_cb	file_cb,
		git_diff_binary_cb	binary_cb,
		git_diff_hunk_cb	hunk_cb,
		git_diff_line_cb	line_cb,
		void *	payload
	)

inline

◆ diff_free()

void diff_free ( git_diff * diff )

inline

◆ diff_from_buffer()

git_diff* diff_from_buffer	(	const char *	content,
		size_t	content_len
	)

inline

◆ diff_get_delta()

const git_diff_delta* diff_get_delta	(	const git_diff *	diff,
		size_t	idx
	)

inline

◆ diff_get_stats()

git_diff_stats* diff_get_stats ( git_diff * diff )

inline

◆ diff_index_to_index()

void diff_index_to_index	(	git_diff **	diff,
		git_repository *	repo,
		git_index *	old_index,
		git_index *	new_index,
		const git_diff_options *	opts
	)

inline

◆ diff_index_to_workdir()

void diff_index_to_workdir	(	git_diff **	diff,
		git_repository *	repo,
		git_index *	index,
		const git_diff_options *	opts
	)

inline

◆ diff_is_sorted_icase()

void diff_is_sorted_icase ( const git_diff * diff )

inline

◆ diff_merge()

void diff_merge	(	git_diff *	onto,
		const git_diff *	from
	)

inline

◆ diff_num_deltas()

size_t diff_num_deltas ( const git_diff * diff )

inline

◆ diff_num_deltas_of_type()

size_t diff_num_deltas_of_type	(	const git_diff *	diff,
		git_delta_t	type
	)

inline

◆ diff_options_init()

void diff_options_init	(	git_diff_options *	opts,
		unsigned int	version
	)

inline

◆ diff_patchid()

git_oid diff_patchid	(	git_diff *	diff,
		git_diff_patchid_options *	opts
	)

inline

◆ diff_patchid_options_init()

void diff_patchid_options_init	(	git_diff_patchid_options *	opts,
		unsigned int	version
	)

inline

◆ diff_print()

void diff_print	(	git_diff *	diff,
		git_diff_format_t	format,
		git_diff_line_cb	print_cb,
		void *	payload
	)

inline

◆ diff_stats_deletions()

size_t diff_stats_deletions ( const git_diff_stats * stats )

inline

◆ diff_stats_files_changed()

size_t diff_stats_files_changed ( const git_diff_stats * stats )

inline

◆ diff_stats_free()

void diff_stats_free ( git_diff_stats * stats )

inline

◆ diff_stats_insertions()

size_t diff_stats_insertions ( const git_diff_stats * stats )

inline

◆ diff_stats_to_buf()

git_buf diff_stats_to_buf	(	const git_diff_stats *	stats,
		git_diff_stats_format_t	format,
		size_t	width
	)

inline

◆ diff_status_char()

char diff_status_char ( git_delta_t status )

inline

◆ diff_to_buf()

git_buf diff_to_buf	(	git_diff *	diff,
		git_diff_format_t	format
	)

inline

◆ diff_tree_to_index()

void diff_tree_to_index	(	git_diff **	diff,
		git_repository *	repo,
		git_tree *	old_tree,
		git_index *	index,
		const git_diff_options *	opts
	)

inline

◆ diff_tree_to_tree()

git_diff* diff_tree_to_tree	(	git_repository *	repo,
		git_tree *	old_tree,
		git_tree *	new_tree,
		const git_diff_options *	opts
	)

inline

◆ diff_tree_to_workdir()

void diff_tree_to_workdir	(	git_diff **	diff,
		git_repository *	repo,
		git_tree *	old_tree,
		const git_diff_options *	opts
	)

inline

◆ diff_tree_to_workdir_with_index()

void diff_tree_to_workdir_with_index	(	git_diff **	diff,
		git_repository *	repo,
		git_tree *	old_tree,
		const git_diff_options *	opts
	)

inline

◆ email_create_from_commit()

git_buf email_create_from_commit	(	git_commit *	commit,
		const git_email_create_options *	opts
	)

inline

◆ email_create_from_diff()

git_buf email_create_from_diff	(	git_diff *	diff,
		size_t	patch_idx,
		size_t	patch_count,
		const git_oid *	commit_id,
		const char *	summary,
		const char *	body,
		const git_signature *	author,
		const git_email_create_options *	opts
	)

inline

◆ error_clear()

void error_clear ( )

inline

◆ error_last()

const git_error* error_last ( )

inline

◆ error_set()

void error_set	(	int	error_class,
		const char *	fmt
	)

inline

◆ error_set_oom()

void error_set_oom ( )

inline

◆ error_set_str()

void error_set_str	(	int	error_class,
		const char *	string
	)

inline

◆ fetch_options_init()

void fetch_options_init	(	git_fetch_options *	opts,
		unsigned int	version
	)

inline

◆ filter_list_apply_to_blob()

git_buf filter_list_apply_to_blob	(	git_filter_list *	filters,
		git_blob *	blob
	)

inline

◆ filter_list_apply_to_buffer()

git_buf filter_list_apply_to_buffer	(	git_filter_list *	filters,
		const char *	in,
		size_t	in_len
	)

inline

◆ filter_list_apply_to_file()

git_buf filter_list_apply_to_file	(	git_filter_list *	filters,
		git_repository *	repo,
		const char *	path
	)

inline

◆ filter_list_contains()

void filter_list_contains	(	git_filter_list *	filters,
		const char *	name
	)

inline

◆ filter_list_free()

void filter_list_free ( git_filter_list * filters )

inline

◆ filter_list_load()

void filter_list_load	(	git_filter_list **	filters,
		git_repository *	repo,
		git_blob *	blob,
		const char *	path,
		git_filter_mode_t	mode,
		uint32_t	flags
	)

inline

◆ filter_list_load_ext()

void filter_list_load_ext	(	git_filter_list **	filters,
		git_repository *	repo,
		git_blob *	blob,
		const char *	path,
		git_filter_mode_t	mode,
		git_filter_options *	opts
	)

inline

◆ filter_list_stream_blob()

void filter_list_stream_blob	(	git_filter_list *	filters,
		git_blob *	blob,
		git_writestream *	target
	)

inline

◆ filter_list_stream_buffer()

void filter_list_stream_buffer	(	git_filter_list *	filters,
		const char *	buffer,
		size_t	len,
		git_writestream *	target
	)

inline

◆ filter_list_stream_file()

void filter_list_stream_file	(	git_filter_list *	filters,
		git_repository *	repo,
		const char *	path,
		git_writestream *	target
	)

inline

◆ graph_ahead_behind()

void graph_ahead_behind	(	size_t *	ahead,
		size_t *	behind,
		git_repository *	repo,
		const git_oid *	local,
		const git_oid *	upstream
	)

inline

◆ graph_descendant_of()

void graph_descendant_of	(	git_repository *	repo,
		const git_oid *	commit,
		const git_oid *	ancestor
	)

inline

◆ graph_reachable_from_any()

void graph_reachable_from_any	(	git_repository *	repo,
		const git_oid *	commit,
		const git_oid	descendant_array[],
		size_t	length
	)

inline

◆ ignore_add_rule()

void ignore_add_rule	(	git_repository *	repo,
		const char *	rules
	)

inline

◆ ignore_clear_internal_rules()

void ignore_clear_internal_rules ( git_repository * repo )

inline

◆ ignore_path_is_ignored()

void ignore_path_is_ignored	(	int *	ignored,
		git_repository *	repo,
		const char *	path
	)

inline

◆ index_add()

void index_add	(	git_index *	index,
		const git_index_entry *	source_entry
	)

inline

◆ index_add_all()

void index_add_all	(	git_index *	index,
		const git_strarray *	pathspec,
		unsigned int	flags,
		git_index_matched_path_cb	callback,
		void *	payload
	)

inline

◆ index_add_bypath()

void index_add_bypath	(	git_index *	index,
		const char *	path
	)

inline

◆ index_add_from_buffer()

void index_add_from_buffer	(	git_index *	index,
		const git_index_entry *	entry,
		const void *	buffer,
		size_t	len
	)

inline

◆ index_caps()

void index_caps ( const git_index * index )

inline

◆ index_checksum()

const git_oid* index_checksum ( git_index * index )

inline

◆ index_clear()

void index_clear ( git_index * index )

inline

◆ index_conflict_add()

void index_conflict_add	(	git_index *	index,
		const git_index_entry *	ancestor_entry,
		const git_index_entry *	our_entry,
		const git_index_entry *	their_entry
	)

inline

◆ index_conflict_cleanup()

void index_conflict_cleanup ( git_index * index )

inline

◆ index_conflict_get()

void index_conflict_get	(	const git_index_entry **	ancestor_out,
		const git_index_entry **	our_out,
		const git_index_entry **	their_out,
		git_index *	index,
		const char *	path
	)

inline

◆ index_conflict_iterator_free()

void index_conflict_iterator_free ( git_index_conflict_iterator * iterator )

inline

◆ index_conflict_iterator_new()

void index_conflict_iterator_new	(	git_index_conflict_iterator **	iterator_out,
		git_index *	index
	)

inline

◆ index_conflict_next()

void index_conflict_next	(	const git_index_entry **	ancestor_out,
		const git_index_entry **	our_out,
		const git_index_entry **	their_out,
		git_index_conflict_iterator *	iterator
	)

inline

◆ index_conflict_remove()

void index_conflict_remove	(	git_index *	index,
		const char *	path
	)

inline

◆ index_entry_is_conflict()

void index_entry_is_conflict ( const git_index_entry * entry )

inline

◆ index_entry_stage()

void index_entry_stage ( const git_index_entry * entry )

inline

◆ index_entrycount()

size_t index_entrycount ( const git_index * index )

inline

◆ index_find()

void index_find	(	size_t *	at_pos,
		git_index *	index,
		const char *	path
	)

inline

◆ index_find_prefix()

void index_find_prefix	(	size_t *	at_pos,
		git_index *	index,
		const char *	prefix
	)

inline

◆ index_free()

void index_free ( git_index * index )

inline

◆ index_get_byindex()

const git_index_entry* index_get_byindex	(	git_index *	index,
		size_t	n
	)

inline

◆ index_get_bypath()

const git_index_entry* index_get_bypath	(	git_index *	index,
		const char *	path,
		int	stage
	)

inline

◆ index_has_conflicts()

void index_has_conflicts ( const git_index * index )

inline

◆ index_iterator_free()

void index_iterator_free ( git_index_iterator * iterator )

inline

◆ index_iterator_new()

void index_iterator_new	(	git_index_iterator **	iterator_out,
		git_index *	index
	)

inline

◆ index_iterator_next()

const git_index_entry* index_iterator_next ( git_index_iterator * iterator )

inline

◆ index_new()

git_index* index_new ( )

inline

◆ index_open()

git_index* index_open ( const char * index_path )

inline

◆ index_owner()

git_repository* index_owner ( const git_index * index )

inline

◆ index_path()

const char* index_path ( const git_index * index )

inline

◆ index_read()

void index_read	(	git_index *	index,
		int	force
	)

inline

◆ index_read_tree()

void index_read_tree	(	git_index *	index,
		const git_tree *	tree
	)

inline

◆ index_remove()

void index_remove	(	git_index *	index,
		const char *	path,
		int	stage
	)

inline

◆ index_remove_all()

void index_remove_all	(	git_index *	index,
		const git_strarray *	pathspec,
		git_index_matched_path_cb	callback,
		void *	payload
	)

inline

◆ index_remove_bypath()

void index_remove_bypath	(	git_index *	index,
		const char *	path
	)

inline

◆ index_remove_directory()

void index_remove_directory	(	git_index *	index,
		const char *	dir,
		int	stage
	)

inline

◆ index_set_caps()

void index_set_caps	(	git_index *	index,
		int	caps
	)

inline

◆ index_set_version()

void index_set_version	(	git_index *	index,
		unsigned int	version
	)

inline

◆ index_update_all()

void index_update_all	(	git_index *	index,
		const git_strarray *	pathspec,
		git_index_matched_path_cb	callback,
		void *	payload
	)

inline

◆ index_version()

unsigned int index_version ( git_index * index )

inline

◆ index_write()

void index_write ( git_index * index )

inline

◆ index_write_tree()

git_oid index_write_tree ( git_index * index )

inline

◆ index_write_tree_to()

git_oid index_write_tree_to	(	git_index *	index,
		git_repository *	repo
	)

inline

◆ indexer_append()

void indexer_append	(	git_indexer *	idx,
		const void *	data,
		size_t	size,
		git_indexer_progress *	stats
	)

inline

◆ indexer_commit()

void indexer_commit	(	git_indexer *	idx,
		git_indexer_progress *	stats
	)

inline

◆ indexer_free()

void indexer_free ( git_indexer * idx )

inline

◆ indexer_hash()

const git_oid* indexer_hash ( const git_indexer * idx )

inline

◆ indexer_name()

const char* indexer_name ( const git_indexer * idx )

inline

◆ indexer_new()

git_indexer* indexer_new	(	const char *	path,
		unsigned int	mode,
		git_odb *	odb,
		git_indexer_options *	opts
	)

inline

◆ indexer_options_init()

void indexer_options_init	(	git_indexer_options *	opts,
		unsigned int	version
	)

inline

◆ libgit2_features()

int libgit2_features ( )

inline

◆ libgit2_init()

void libgit2_init ( )

inline

◆ libgit2_opts()

void libgit2_opts ( int option )

inline

◆ libgit2_prerelease()

const char* libgit2_prerelease ( )

inline

◆ libgit2_shutdown()

void libgit2_shutdown ( )

inline

◆ libgit2_version()

void libgit2_version	(	int *	major,
		int *	minor,
		int *	rev
	)

inline

◆ mailmap_add_entry()

void mailmap_add_entry	(	git_mailmap *	mm,
		const char *	real_name,
		const char *	real_email,
		const char *	replace_name,
		const char *	replace_email
	)

inline

◆ mailmap_free()

void mailmap_free ( git_mailmap * mm )

inline

◆ mailmap_from_buffer()

git_mailmap* mailmap_from_buffer	(	const char *	buf,
		size_t	len
	)

inline

◆ mailmap_from_repository()

git_mailmap* mailmap_from_repository ( git_repository * repo )

inline

◆ mailmap_new()

git_mailmap* mailmap_new ( )

inline

◆ mailmap_resolve()

void mailmap_resolve	(	const char **	real_name,
		const char **	real_email,
		const git_mailmap *	mm,
		const char *	name,
		const char *	email
	)

inline

◆ mailmap_resolve_signature()

git_signature* mailmap_resolve_signature	(	const git_mailmap *	mm,
		const git_signature *	sig
	)

inline

◆ merge()

void merge	(	git_repository *	repo,
		const git_annotated_commit **	their_heads,
		size_t	their_heads_len,
		const git_merge_options *	merge_opts,
		const git_checkout_options *	checkout_opts
	)

inline

◆ merge_analysis()

void merge_analysis	(	git_merge_analysis_t *	analysis_out,
		git_merge_preference_t *	preference_out,
		git_repository *	repo,
		const git_annotated_commit **	their_heads,
		size_t	their_heads_len
	)

inline

◆ merge_analysis_for_ref()

void merge_analysis_for_ref	(	git_merge_analysis_t *	analysis_out,
		git_merge_preference_t *	preference_out,
		git_repository *	repo,
		git_reference *	our_ref,
		const git_annotated_commit **	their_heads,
		size_t	their_heads_len
	)

inline

◆ merge_base()

git_oid merge_base	(	git_repository *	repo,
		const git_oid *	one,
		const git_oid *	two
	)

inline

◆ merge_base_many()

git_oid merge_base_many	(	git_repository *	repo,
		size_t	length,
		const git_oid	input_array[]
	)

inline

◆ merge_base_octopus()

git_oid merge_base_octopus	(	git_repository *	repo,
		size_t	length,
		const git_oid	input_array[]
	)

inline

◆ merge_bases()

git_oidarray merge_bases	(	git_repository *	repo,
		const git_oid *	one,
		const git_oid *	two
	)

inline

◆ merge_bases_many()

git_oidarray merge_bases_many	(	git_repository *	repo,
		size_t	length,
		const git_oid	input_array[]
	)

inline

◆ merge_commits()

git_index* merge_commits	(	git_repository *	repo,
		const git_commit *	our_commit,
		const git_commit *	their_commit,
		const git_merge_options *	opts
	)

inline

◆ merge_file()

git_merge_file_result merge_file	(	const git_merge_file_input *	ancestor,
		const git_merge_file_input *	ours,
		const git_merge_file_input *	theirs,
		const git_merge_file_options *	opts
	)

inline

◆ merge_file_from_index()

git_merge_file_result merge_file_from_index	(	git_repository *	repo,
		const git_index_entry *	ancestor,
		const git_index_entry *	ours,
		const git_index_entry *	theirs,
		const git_merge_file_options *	opts
	)

inline

◆ merge_file_input_init()

void merge_file_input_init	(	git_merge_file_input *	opts,
		unsigned int	version
	)

inline

◆ merge_file_options_init()

void merge_file_options_init	(	git_merge_file_options *	opts,
		unsigned int	version
	)

inline

◆ merge_file_result_free()

void merge_file_result_free ( git_merge_file_result * result )

inline

◆ merge_options_init()

void merge_options_init	(	git_merge_options *	opts,
		unsigned int	version
	)

inline

◆ merge_trees()

git_index* merge_trees	(	git_repository *	repo,
		const git_tree *	ancestor_tree,
		const git_tree *	our_tree,
		const git_tree *	their_tree,
		const git_merge_options *	opts
	)

inline

◆ message_prettify()

git_buf message_prettify	(	const char *	message,
		int	strip_comments,
		char	comment_char
	)

inline

◆ message_trailer_array_free()

void message_trailer_array_free ( git_message_trailer_array * arr )

inline

◆ message_trailers()

void message_trailers	(	git_message_trailer_array *	arr,
		const char *	message
	)

inline

◆ note_author()

const git_signature* note_author ( const git_note * note )

inline

◆ note_commit_create()

void note_commit_create	(	git_oid *	notes_commit_out,
		git_oid *	notes_blob_out,
		git_repository *	repo,
		git_commit *	parent,
		const git_signature *	author,
		const git_signature *	committer,
		const git_oid *	oid,
		const char *	note,
		int	allow_note_overwrite
	)

inline

◆ note_commit_iterator_new()

git_note_iterator* note_commit_iterator_new ( git_commit * notes_commit )

inline

◆ note_commit_read()

git_note* note_commit_read	(	git_repository *	repo,
		git_commit *	notes_commit,
		const git_oid *	oid
	)

inline

◆ note_commit_remove()

void note_commit_remove	(	git_oid *	notes_commit_out,
		git_repository *	repo,
		git_commit *	notes_commit,
		const git_signature *	author,
		const git_signature *	committer,
		const git_oid *	oid
	)

inline

◆ note_committer()

const git_signature* note_committer ( const git_note * note )

inline

◆ note_create()

git_oid note_create	(	git_repository *	repo,
		const char *	notes_ref,
		const git_signature *	author,
		const git_signature *	committer,
		const git_oid *	oid,
		const char *	note,
		int	force
	)

inline

◆ note_default_ref()

git_buf note_default_ref ( git_repository * repo )

inline

◆ note_foreach()

void note_foreach	(	git_repository *	repo,
		const char *	notes_ref,
		git_note_foreach_cb	note_cb,
		void *	payload
	)

inline

◆ note_free()

void note_free ( git_note * note )

inline

◆ note_id()

const git_oid* note_id ( const git_note * note )

inline

◆ note_iterator_free()

void note_iterator_free ( git_note_iterator * it )

inline

◆ note_iterator_new()

git_note_iterator* note_iterator_new	(	git_repository *	repo,
		const char *	notes_ref
	)

inline

◆ note_message()

const char* note_message ( const git_note * note )

inline

◆ note_next()

void note_next	(	git_oid *	note_id,
		git_oid *	annotated_id,
		git_note_iterator *	it
	)

inline

◆ note_read()

git_note* note_read	(	git_repository *	repo,
		const char *	notes_ref,
		const git_oid *	oid
	)

inline

◆ note_remove()

void note_remove	(	git_repository *	repo,
		const char *	notes_ref,
		const git_signature *	author,
		const git_signature *	committer,
		const git_oid *	oid
	)

inline

◆ object_dup()

void object_dup	(	git_object **	dest,
		git_object *	source
	)

inline

◆ object_free()

void object_free ( git_object * object )

inline

◆ object_id()

const git_oid* object_id ( const git_object * obj )

inline

◆ object_lookup()

void object_lookup	(	git_object **	object,
		git_repository *	repo,
		const git_oid *	id,
		git_object_t	type
	)

inline

◆ object_lookup_bypath()

git_object* object_lookup_bypath	(	const git_object *	treeish,
		const char *	path,
		git_object_t	type
	)

inline

◆ object_lookup_prefix()

void object_lookup_prefix	(	git_object **	object_out,
		git_repository *	repo,
		const git_oid *	id,
		size_t	len,
		git_object_t	type
	)

inline

◆ object_owner()

git_repository* object_owner ( const git_object * obj )

inline

◆ object_peel()

void object_peel	(	git_object **	peeled,
		const git_object *	object,
		git_object_t	target_type
	)

inline

◆ object_rawcontent_is_valid()

void object_rawcontent_is_valid	(	int *	valid,
		const char *	buf,
		size_t	len,
		git_object_t	type
	)

inline

◆ object_short_id()

git_buf object_short_id ( const git_object * obj )

inline

◆ object_string2type()

git_object_t object_string2type ( const char * str )

inline

◆ object_type()

git_object_t object_type ( const git_object * obj )

inline

◆ object_type2string()

const char* object_type2string ( git_object_t type )

inline

◆ object_typeisloose()

void object_typeisloose ( git_object_t type )

inline

◆ odb_add_alternate()

void odb_add_alternate	(	git_odb *	odb,
		git_odb_backend *	backend,
		int	priority
	)

inline

◆ odb_add_backend()

void odb_add_backend	(	git_odb *	odb,
		git_odb_backend *	backend,
		int	priority
	)

inline

◆ odb_add_disk_alternate()

void odb_add_disk_alternate	(	git_odb *	odb,
		const char *	path
	)

inline

◆ odb_backend_loose()

git_odb_backend* odb_backend_loose	(	const char *	objects_dir,
		int	compression_level,
		int	do_fsync,
		unsigned int	dir_mode,
		unsigned int	file_mode
	)

inline

◆ odb_backend_one_pack()

git_odb_backend* odb_backend_one_pack ( const char * index_file )

inline

◆ odb_backend_pack()

git_odb_backend* odb_backend_pack ( const char * objects_dir )

inline

◆ odb_exists()

void odb_exists	(	git_odb *	db,
		const git_oid *	id
	)

inline

◆ odb_exists_ext()

void odb_exists_ext	(	git_odb *	db,
		const git_oid *	id,
		unsigned int	flags
	)

inline

◆ odb_exists_prefix()

git_oid odb_exists_prefix	(	git_odb *	db,
		const git_oid *	short_id,
		size_t	len
	)

inline

◆ odb_expand_ids()

void odb_expand_ids	(	git_odb *	db,
		git_odb_expand_id *	ids,
		size_t	count
	)

inline

◆ odb_foreach()

void odb_foreach	(	git_odb *	db,
		git_odb_foreach_cb	cb,
		void *	payload
	)

inline

◆ odb_free()

void odb_free ( git_odb * db )

inline

◆ odb_get_backend()

git_odb_backend* odb_get_backend	(	git_odb *	odb,
		size_t	pos
	)

inline

◆ odb_hash()

git_oid odb_hash	(	const void *	data,
		size_t	len,
		git_object_t	type
	)

inline

◆ odb_hashfile()

git_oid odb_hashfile	(	const char *	path,
		git_object_t	type
	)

inline

◆ odb_new()

git_odb* odb_new ( )

inline

◆ odb_num_backends()

size_t odb_num_backends ( git_odb * odb )

inline

◆ odb_object_data()

const void* odb_object_data ( git_odb_object * object )

inline

◆ odb_object_dup()

void odb_object_dup	(	git_odb_object **	dest,
		git_odb_object *	source
	)

inline

◆ odb_object_free()

void odb_object_free ( git_odb_object * object )

inline

◆ odb_object_id()

const git_oid* odb_object_id ( git_odb_object * object )

inline

◆ odb_object_size()

size_t odb_object_size ( git_odb_object * object )

inline

◆ odb_object_type()

git_object_t odb_object_type ( git_odb_object * object )

inline

◆ odb_open()

git_odb* odb_open ( const char * objects_dir )

inline

◆ odb_open_rstream()

git_odb_stream* odb_open_rstream	(	size_t *	len,
		git_object_t *	type,
		git_odb *	db,
		const git_oid *	oid
	)

inline

◆ odb_open_wstream()

git_odb_stream* odb_open_wstream	(	git_odb *	db,
		git_object_size_t	size,
		git_object_t	type
	)

inline

◆ odb_read()

git_odb_object* odb_read	(	git_odb *	db,
		const git_oid *	id
	)

inline

◆ odb_read_header()

void odb_read_header	(	size_t *	len_out,
		git_object_t *	type_out,
		git_odb *	db,
		const git_oid *	id
	)

inline

◆ odb_read_prefix()

git_odb_object* odb_read_prefix	(	git_odb *	db,
		const git_oid *	short_id,
		size_t	len
	)

inline

◆ odb_refresh()

void odb_refresh ( struct git_odb * db )

inline

◆ odb_set_commit_graph()

void odb_set_commit_graph	(	git_odb *	odb,
		git_commit_graph *	cgraph
	)

inline

◆ odb_stream_finalize_write()

git_oid odb_stream_finalize_write ( git_odb_stream * stream )

inline

◆ odb_stream_free()

void odb_stream_free ( git_odb_stream * stream )

inline

◆ odb_stream_read()

void odb_stream_read	(	git_odb_stream *	stream,
		char *	buffer,
		size_t	len
	)

inline

◆ odb_stream_write()

void odb_stream_write	(	git_odb_stream *	stream,
		const char *	buffer,
		size_t	len
	)

inline

◆ odb_write()

git_oid odb_write	(	git_odb *	odb,
		const void *	data,
		size_t	len,
		git_object_t	type
	)

inline

◆ odb_write_multi_pack_index()

void odb_write_multi_pack_index ( git_odb * db )

inline

◆ odb_write_pack()

git_odb_writepack* odb_write_pack	(	git_odb *	db,
		git_indexer_progress_cb	progress_cb,
		void *	progress_payload
	)

inline

◆ oid_cmp()

int oid_cmp	(	const git_oid *	a,
		const git_oid *	b
	)

inline

◆ oid_cpy()

git_oid oid_cpy ( const git_oid * src )

inline

◆ oid_equal()

void oid_equal	(	const git_oid *	a,
		const git_oid *	b
	)

inline

◆ oid_fmt()

char oid_fmt ( const git_oid * id )

inline

◆ oid_fromraw()

git_oid oid_fromraw ( const unsigned char * raw )

inline

◆ oid_fromstr()

git_oid oid_fromstr ( const char * str )

inline

◆ oid_fromstrn()

git_oid oid_fromstrn	(	const char *	str,
		size_t	length
	)

inline

◆ oid_fromstrp()

git_oid oid_fromstrp ( const char * str )

inline

◆ oid_is_zero()

void oid_is_zero ( const git_oid * id )

inline

◆ oid_ncmp()

void oid_ncmp	(	const git_oid *	a,
		const git_oid *	b,
		size_t	len
	)

inline

◆ oid_nfmt()

char oid_nfmt	(	size_t	n,
		const git_oid *	id
	)

inline

◆ oid_pathfmt()

char oid_pathfmt ( const git_oid * id )

inline

◆ oid_shorten_add()

void oid_shorten_add	(	git_oid_shorten *	os,
		const char *	text_id
	)

inline

◆ oid_shorten_free()

void oid_shorten_free ( git_oid_shorten * os )

inline

◆ oid_shorten_new()

git_oid_shorten* oid_shorten_new ( size_t min_length )

inline

◆ oid_strcmp()

void oid_strcmp	(	const git_oid *	id,
		const char *	str
	)

inline

◆ oid_streq()

void oid_streq	(	const git_oid *	id,
		const char *	str
	)

inline

◆ oid_tostr()

char* oid_tostr	(	size_t	n,
		const git_oid *	id
	)

inline

◆ oid_tostr_s()

char* oid_tostr_s ( const git_oid * oid )

inline

◆ oidarray_dispose()

void oidarray_dispose ( git_oidarray * array )

inline

◆ packbuilder_foreach()

void packbuilder_foreach	(	git_packbuilder *	pb,
		git_packbuilder_foreach_cb	cb,
		void *	payload
	)

inline

◆ packbuilder_free()

void packbuilder_free ( git_packbuilder * pb )

inline

◆ packbuilder_hash()

const git_oid* packbuilder_hash ( git_packbuilder * pb )

inline

◆ packbuilder_insert()

void packbuilder_insert	(	git_packbuilder *	pb,
		const git_oid *	id,
		const char *	name
	)

inline

◆ packbuilder_insert_commit()

void packbuilder_insert_commit	(	git_packbuilder *	pb,
		const git_oid *	id
	)

inline

◆ packbuilder_insert_recur()

void packbuilder_insert_recur	(	git_packbuilder *	pb,
		const git_oid *	id,
		const char *	name
	)

inline

◆ packbuilder_insert_tree()

void packbuilder_insert_tree	(	git_packbuilder *	pb,
		const git_oid *	id
	)

inline

◆ packbuilder_insert_walk()

void packbuilder_insert_walk	(	git_packbuilder *	pb,
		git_revwalk *	walk
	)

inline

◆ packbuilder_name()

const char* packbuilder_name ( git_packbuilder * pb )

inline

◆ packbuilder_new()

git_packbuilder* packbuilder_new ( git_repository * repo )

inline

◆ packbuilder_object_count()

size_t packbuilder_object_count ( git_packbuilder * pb )

inline

◆ packbuilder_set_callbacks()

void packbuilder_set_callbacks	(	git_packbuilder *	pb,
		git_packbuilder_progress	progress_cb,
		void *	progress_cb_payload
	)

inline

◆ packbuilder_set_threads()

unsigned int packbuilder_set_threads	(	git_packbuilder *	pb,
		unsigned int	n
	)

inline

◆ packbuilder_write()

void packbuilder_write	(	git_packbuilder *	pb,
		const char *	path,
		unsigned int	mode,
		git_indexer_progress_cb	progress_cb,
		void *	progress_cb_payload
	)

inline

◆ packbuilder_write_buf()

void packbuilder_write_buf	(	git_buf *	buf,
		git_packbuilder *	pb
	)

inline

◆ packbuilder_written()

size_t packbuilder_written ( git_packbuilder * pb )

inline

◆ patch_free()

void patch_free ( git_patch * patch )

inline

◆ patch_from_blob_and_buffer()

git_patch* patch_from_blob_and_buffer	(	const git_blob *	old_blob,
		const char *	old_as_path,
		const void *	buffer,
		size_t	buffer_len,
		const char *	buffer_as_path,
		const git_diff_options *	opts
	)

inline

◆ patch_from_blobs()

git_patch* patch_from_blobs	(	const git_blob *	old_blob,
		const char *	old_as_path,
		const git_blob *	new_blob,
		const char *	new_as_path,
		const git_diff_options *	opts
	)

inline

◆ patch_from_buffers()

git_patch* patch_from_buffers	(	const void *	old_buffer,
		size_t	old_len,
		const char *	old_as_path,
		const void *	new_buffer,
		size_t	new_len,
		const char *	new_as_path,
		const git_diff_options *	opts
	)

inline

◆ patch_from_diff()

git_patch* patch_from_diff	(	git_diff *	diff,
		size_t	idx
	)

inline

◆ patch_get_delta()

const git_diff_delta* patch_get_delta ( const git_patch * patch )

inline

◆ patch_get_hunk()

const git_diff_hunk* patch_get_hunk	(	size_t *	lines_in_hunk,
		git_patch *	patch,
		size_t	hunk_idx
	)

inline

◆ patch_get_line_in_hunk()

const git_diff_line* patch_get_line_in_hunk	(	git_patch *	patch,
		size_t	hunk_idx,
		size_t	line_of_hunk
	)

inline

◆ patch_line_stats()

void patch_line_stats	(	size_t *	total_context,
		size_t *	total_additions,
		size_t *	total_deletions,
		const git_patch *	patch
	)

inline

◆ patch_num_hunks()

size_t patch_num_hunks ( const git_patch * patch )

inline

◆ patch_num_lines_in_hunk()

void patch_num_lines_in_hunk	(	const git_patch *	patch,
		size_t	hunk_idx
	)

inline

◆ patch_owner()

git_repository* patch_owner ( const git_patch * patch )

inline

◆ patch_print()

void patch_print	(	git_patch *	patch,
		git_diff_line_cb	print_cb,
		void *	payload
	)

inline

◆ patch_size()

size_t patch_size	(	git_patch *	patch,
		int	include_context,
		int	include_hunk_headers,
		int	include_file_headers
	)

inline

◆ patch_to_buf()

git_buf patch_to_buf ( git_patch * patch )

inline

◆ pathspec_free()

void pathspec_free ( git_pathspec * ps )

inline

◆ pathspec_match_diff()

git_pathspec_match_list* pathspec_match_diff	(	git_diff *	diff,
		uint32_t	flags,
		git_pathspec *	ps
	)

inline

◆ pathspec_match_index()

git_pathspec_match_list* pathspec_match_index	(	git_index *	index,
		uint32_t	flags,
		git_pathspec *	ps
	)

inline

◆ pathspec_match_list_diff_entry()

const git_diff_delta* pathspec_match_list_diff_entry	(	const git_pathspec_match_list *	m,
		size_t	pos
	)

inline

◆ pathspec_match_list_entry()

const char* pathspec_match_list_entry	(	const git_pathspec_match_list *	m,
		size_t	pos
	)

inline

◆ pathspec_match_list_entrycount()

size_t pathspec_match_list_entrycount ( const git_pathspec_match_list * m )

inline

◆ pathspec_match_list_failed_entry()

const char* pathspec_match_list_failed_entry	(	const git_pathspec_match_list *	m,
		size_t	pos
	)

inline

◆ pathspec_match_list_failed_entrycount()

size_t pathspec_match_list_failed_entrycount ( const git_pathspec_match_list * m )

inline

◆ pathspec_match_list_free()

void pathspec_match_list_free ( git_pathspec_match_list * m )

inline

◆ pathspec_match_tree()

git_pathspec_match_list* pathspec_match_tree	(	git_tree *	tree,
		uint32_t	flags,
		git_pathspec *	ps
	)

inline

◆ pathspec_match_workdir()

git_pathspec_match_list* pathspec_match_workdir	(	git_repository *	repo,
		uint32_t	flags,
		git_pathspec *	ps
	)

inline

◆ pathspec_matches_path()

void pathspec_matches_path	(	const git_pathspec *	ps,
		uint32_t	flags,
		const char *	path
	)

inline

◆ pathspec_new()

git_pathspec* pathspec_new ( const git_strarray * pathspec )

inline

◆ proxy_options_init()

void proxy_options_init	(	git_proxy_options *	opts,
		unsigned int	version
	)

inline

◆ push_options_init()

void push_options_init	(	git_push_options *	opts,
		unsigned int	version
	)

inline

◆ rebase_abort()

void rebase_abort ( git_rebase * rebase )

inline

◆ rebase_commit()

void rebase_commit	(	git_oid *	id,
		git_rebase *	rebase,
		const git_signature *	author,
		const git_signature *	committer,
		const char *	message_encoding,
		const char *	message
	)

inline

◆ rebase_finish()

void rebase_finish	(	git_rebase *	rebase,
		const git_signature *	signature
	)

inline

◆ rebase_free()

void rebase_free ( git_rebase * rebase )

inline

◆ rebase_init()

git_rebase* rebase_init	(	git_repository *	repo,
		const git_annotated_commit *	branch,
		const git_annotated_commit *	upstream,
		const git_annotated_commit *	onto,
		const git_rebase_options *	opts
	)

inline

◆ rebase_inmemory_index()

void rebase_inmemory_index	(	git_index **	index,
		git_rebase *	rebase
	)

inline

◆ rebase_next()

void rebase_next	(	git_rebase_operation **	operation,
		git_rebase *	rebase
	)

inline

◆ rebase_onto_id()

const git_oid* rebase_onto_id ( git_rebase * rebase )

inline

◆ rebase_onto_name()

const char* rebase_onto_name ( git_rebase * rebase )

inline

◆ rebase_open()

git_rebase* rebase_open	(	git_repository *	repo,
		const git_rebase_options *	opts
	)

inline

◆ rebase_operation_byindex()

git_rebase_operation* rebase_operation_byindex	(	git_rebase *	rebase,
		size_t	idx
	)

inline

◆ rebase_operation_current()

size_t rebase_operation_current ( git_rebase * rebase )

inline

◆ rebase_operation_entrycount()

size_t rebase_operation_entrycount ( git_rebase * rebase )

inline

◆ rebase_options_init()

void rebase_options_init	(	git_rebase_options *	opts,
		unsigned int	version
	)

inline

◆ rebase_orig_head_id()

const git_oid* rebase_orig_head_id ( git_rebase * rebase )

inline

◆ rebase_orig_head_name()

const char* rebase_orig_head_name ( git_rebase * rebase )

inline

◆ refdb_compress()

void refdb_compress ( git_refdb * refdb )

inline

◆ refdb_free()

void refdb_free ( git_refdb * refdb )

inline

◆ refdb_new()

git_refdb* refdb_new ( git_repository * repo )

inline

◆ refdb_open()

git_refdb* refdb_open ( git_repository * repo )

inline

◆ reference_cmp()

void reference_cmp	(	const git_reference *	ref1,
		const git_reference *	ref2
	)

inline

◆ reference_create()

git_reference* reference_create	(	git_repository *	repo,
		const char *	name,
		const git_oid *	id,
		int	force,
		const char *	log_message
	)

inline

◆ reference_create_matching()

git_reference* reference_create_matching	(	git_repository *	repo,
		const char *	name,
		const git_oid *	id,
		int	force,
		const git_oid *	current_id,
		const char *	log_message
	)

inline

◆ reference_delete()

void reference_delete ( git_reference * ref )

inline

◆ reference_dup()

void reference_dup	(	git_reference **	dest,
		git_reference *	source
	)

inline

◆ reference_dwim()

git_reference* reference_dwim	(	git_repository *	repo,
		const char *	shorthand
	)

inline

◆ reference_ensure_log()

void reference_ensure_log	(	git_repository *	repo,
		const char *	refname
	)

inline

◆ reference_foreach()

void reference_foreach	(	git_repository *	repo,
		git_reference_foreach_cb	callback,
		void *	payload
	)

inline

◆ reference_foreach_glob()

void reference_foreach_glob	(	git_repository *	repo,
		const char *	glob,
		git_reference_foreach_name_cb	callback,
		void *	payload
	)

inline

◆ reference_foreach_name()

void reference_foreach_name	(	git_repository *	repo,
		git_reference_foreach_name_cb	callback,
		void *	payload
	)

inline

◆ reference_free()

void reference_free ( git_reference * ref )

inline

◆ reference_has_log()

void reference_has_log	(	git_repository *	repo,
		const char *	refname
	)

inline

◆ reference_is_branch()

void reference_is_branch ( const git_reference * ref )

inline

◆ reference_is_note()

void reference_is_note ( const git_reference * ref )

inline

◆ reference_is_remote()

void reference_is_remote ( const git_reference * ref )

inline

◆ reference_is_tag()

void reference_is_tag ( const git_reference * ref )

inline

◆ reference_iterator_free()

void reference_iterator_free ( git_reference_iterator * iter )

inline

◆ reference_iterator_glob_new()

git_reference_iterator* reference_iterator_glob_new	(	git_repository *	repo,
		const char *	glob
	)

inline

◆ reference_iterator_new()

git_reference_iterator* reference_iterator_new ( git_repository * repo )

inline

◆ reference_list()

void reference_list	(	git_strarray *	array,
		git_repository *	repo
	)

inline

◆ reference_lookup()

git_reference* reference_lookup	(	git_repository *	repo,
		const char *	name
	)

inline

◆ reference_name()

const char* reference_name ( const git_reference * ref )

inline

◆ reference_name_is_valid()

void reference_name_is_valid	(	int *	valid,
		const char *	refname
	)

inline

◆ reference_name_to_id()

git_oid reference_name_to_id	(	git_repository *	repo,
		const char *	name
	)

inline

◆ reference_next()

git_reference* reference_next ( git_reference_iterator * iter )

inline

◆ reference_next_name()

const char* reference_next_name ( git_reference_iterator * iter )

inline

◆ reference_normalize_name()

void reference_normalize_name	(	char *	buffer_out,
		size_t	buffer_size,
		const char *	name,
		unsigned int	flags
	)

inline

◆ reference_owner()

git_repository* reference_owner ( const git_reference * ref )

inline

◆ reference_peel()

git_object* reference_peel	(	const git_reference *	ref,
		git_object_t	type
	)

inline

◆ reference_remove()

void reference_remove	(	git_repository *	repo,
		const char *	name
	)

inline

◆ reference_rename()

void reference_rename	(	git_reference **	new_ref,
		git_reference *	ref,
		const char *	new_name,
		int	force,
		const char *	log_message
	)

inline

◆ reference_resolve()

git_reference* reference_resolve ( const git_reference * ref )

inline

◆ reference_set_target()

git_reference* reference_set_target	(	git_reference *	ref,
		const git_oid *	id,
		const char *	log_message
	)

inline

◆ reference_shorthand()

const char* reference_shorthand ( const git_reference * ref )

inline

◆ reference_symbolic_create()

git_reference* reference_symbolic_create	(	git_repository *	repo,
		const char *	name,
		const char *	target,
		int	force,
		const char *	log_message
	)

inline

◆ reference_symbolic_create_matching()

git_reference* reference_symbolic_create_matching	(	git_repository *	repo,
		const char *	name,
		const char *	target,
		int	force,
		const char *	current_value,
		const char *	log_message
	)

inline

◆ reference_symbolic_set_target()

git_reference* reference_symbolic_set_target	(	git_reference *	ref,
		const char *	target,
		const char *	log_message
	)

inline

◆ reference_symbolic_target()

const char* reference_symbolic_target ( const git_reference * ref )

inline

◆ reference_target()

const git_oid* reference_target ( const git_reference * ref )

inline

◆ reference_target_peel()

const git_oid* reference_target_peel ( const git_reference * ref )

inline

◆ reference_type()

git_reference_t reference_type ( const git_reference * ref )

inline

◆ reflog_append()

void reflog_append	(	git_reflog *	reflog,
		const git_oid *	id,
		const git_signature *	committer,
		const char *	msg
	)

inline

◆ reflog_delete()

void reflog_delete	(	git_repository *	repo,
		const char *	name
	)

inline

◆ reflog_drop()

void reflog_drop	(	git_reflog *	reflog,
		size_t	idx,
		int	rewrite_previous_entry
	)

inline

◆ reflog_entry_byindex()

const git_reflog_entry* reflog_entry_byindex	(	const git_reflog *	reflog,
		size_t	idx
	)

inline

◆ reflog_entry_committer()

const git_signature* reflog_entry_committer ( const git_reflog_entry * entry )

inline

◆ reflog_entry_id_new()

const git_oid* reflog_entry_id_new ( const git_reflog_entry * entry )

inline

◆ reflog_entry_id_old()

const git_oid* reflog_entry_id_old ( const git_reflog_entry * entry )

inline

◆ reflog_entry_message()

const char* reflog_entry_message ( const git_reflog_entry * entry )

inline

◆ reflog_entrycount()

size_t reflog_entrycount ( git_reflog * reflog )

inline

◆ reflog_free()

void reflog_free ( git_reflog * reflog )

inline

◆ reflog_read()

git_reflog* reflog_read	(	git_repository *	repo,
		const char *	name
	)

inline

◆ reflog_rename()

void reflog_rename	(	git_repository *	repo,
		const char *	old_name,
		const char *	name
	)

inline

◆ reflog_write()

void reflog_write ( git_reflog * reflog )

inline

◆ refspec_direction()

git_direction refspec_direction ( const git_refspec * spec )

inline

◆ refspec_dst()

const char* refspec_dst ( const git_refspec * refspec )

inline

◆ refspec_dst_matches()

void refspec_dst_matches	(	const git_refspec *	refspec,
		const char *	refname
	)

inline

◆ refspec_force()

void refspec_force ( const git_refspec * refspec )

inline

◆ refspec_free()

void refspec_free ( git_refspec * refspec )

inline

◆ refspec_parse()

void refspec_parse	(	git_refspec **	refspec,
		const char *	input,
		int	is_fetch
	)

inline

◆ refspec_rtransform()

git_buf refspec_rtransform	(	const git_refspec *	spec,
		const char *	name
	)

inline

◆ refspec_src()

const char* refspec_src ( const git_refspec * refspec )

inline

◆ refspec_src_matches()

void refspec_src_matches	(	const git_refspec *	refspec,
		const char *	refname
	)

inline

◆ refspec_string()

const char* refspec_string ( const git_refspec * refspec )

inline

◆ refspec_transform()

git_buf refspec_transform	(	const git_refspec *	spec,
		const char *	name
	)

inline

◆ remote_add_fetch()

void remote_add_fetch	(	git_repository *	repo,
		const char *	remote,
		const char *	refspec
	)

inline

◆ remote_add_push()

void remote_add_push	(	git_repository *	repo,
		const char *	remote,
		const char *	refspec
	)

inline

◆ remote_autotag()

git_remote_autotag_option_t remote_autotag ( const git_remote * remote )

inline

◆ remote_connect()

void remote_connect	(	git_remote *	remote,
		git_direction	direction,
		const git_remote_callbacks *	callbacks,
		const git_proxy_options *	proxy_opts,
		const git_strarray *	custom_headers
	)

inline

◆ remote_connect_ext()

void remote_connect_ext	(	git_remote *	remote,
		git_direction	direction,
		const git_remote_connect_options *	opts
	)

inline

◆ remote_connect_options_init()

void remote_connect_options_init	(	git_remote_connect_options *	opts,
		unsigned int	version
	)

inline

◆ remote_connected()

void remote_connected ( const git_remote * remote )

inline

◆ remote_create()

git_remote* remote_create	(	git_repository *	repo,
		const char *	name,
		const char *	url
	)

inline

◆ remote_create_anonymous()

git_remote* remote_create_anonymous	(	git_repository *	repo,
		const char *	url
	)

inline

◆ remote_create_detached()

git_remote* remote_create_detached ( const char * url )

inline

◆ remote_create_options_init()

void remote_create_options_init	(	git_remote_create_options *	opts,
		unsigned int	version
	)

inline

◆ remote_create_with_fetchspec()

git_remote* remote_create_with_fetchspec	(	git_repository *	repo,
		const char *	name,
		const char *	url,
		const char *	fetch
	)

inline

◆ remote_create_with_opts()

git_remote* remote_create_with_opts	(	const char *	url,
		const git_remote_create_options *	opts
	)

inline

◆ remote_default_branch()

git_buf remote_default_branch ( git_remote * remote )

inline

◆ remote_delete()

void remote_delete	(	git_repository *	repo,
		const char *	name
	)

inline

◆ remote_disconnect()

void remote_disconnect ( git_remote * remote )

inline

◆ remote_download()

void remote_download	(	git_remote *	remote,
		const git_strarray *	refspecs,
		const git_fetch_options *	opts
	)

inline

◆ remote_dup()

void remote_dup	(	git_remote **	dest,
		git_remote *	source
	)

inline

◆ remote_fetch()

void remote_fetch	(	git_remote *	remote,
		const git_strarray *	refspecs,
		const git_fetch_options *	opts,
		const char *	reflog_message
	)

inline

◆ remote_free()

void remote_free ( git_remote * remote )

inline

◆ remote_get_fetch_refspecs()

void remote_get_fetch_refspecs	(	git_strarray *	array,
		const git_remote *	remote
	)

inline

◆ remote_get_push_refspecs()

void remote_get_push_refspecs	(	git_strarray *	array,
		const git_remote *	remote
	)

inline

◆ remote_get_refspec()

const git_refspec* remote_get_refspec	(	const git_remote *	remote,
		size_t	n
	)

inline

◆ remote_init_callbacks()

void remote_init_callbacks	(	git_remote_callbacks *	opts,
		unsigned int	version
	)

inline

◆ remote_list()

git_strarray remote_list ( git_repository * repo )

inline

◆ remote_lookup()

git_remote* remote_lookup	(	git_repository *	repo,
		const char *	name
	)

inline

◆ remote_ls()

const git_remote_head** remote_ls	(	size_t *	size,
		git_remote *	remote
	)

inline

◆ remote_name()

const char* remote_name ( const git_remote * remote )

inline

◆ remote_name_is_valid()

void remote_name_is_valid	(	int *	valid,
		const char *	remote_name
	)

inline

◆ remote_owner()

git_repository* remote_owner ( const git_remote * remote )

inline

◆ remote_prune()

void remote_prune	(	git_remote *	remote,
		const git_remote_callbacks *	callbacks
	)

inline

◆ remote_prune_refs()

void remote_prune_refs ( const git_remote * remote )

inline

◆ remote_push()

void remote_push	(	git_remote *	remote,
		const git_strarray *	refspecs,
		const git_push_options *	opts
	)

inline

◆ remote_pushurl()

const char* remote_pushurl ( const git_remote * remote )

inline

◆ remote_refspec_count()

size_t remote_refspec_count ( const git_remote * remote )

inline

◆ remote_rename()

void remote_rename	(	git_strarray *	problems,
		git_repository *	repo,
		const char *	name,
		const char *	new_name
	)

inline

◆ remote_set_autotag()

void remote_set_autotag	(	git_repository *	repo,
		const char *	remote,
		git_remote_autotag_option_t	value
	)

inline

◆ remote_set_instance_pushurl()

void remote_set_instance_pushurl	(	git_remote *	remote,
		const char *	url
	)

inline

◆ remote_set_instance_url()

void remote_set_instance_url	(	git_remote *	remote,
		const char *	url
	)

inline

◆ remote_set_pushurl()

void remote_set_pushurl	(	git_repository *	repo,
		const char *	remote,
		const char *	url
	)

inline

◆ remote_set_url()

void remote_set_url	(	git_repository *	repo,
		const char *	remote,
		const char *	url
	)

inline

◆ remote_stats()

const git_indexer_progress* remote_stats ( git_remote * remote )

inline

◆ remote_stop()

void remote_stop ( git_remote * remote )

inline

◆ remote_update_tips()

void remote_update_tips	(	git_remote *	remote,
		const git_remote_callbacks *	callbacks,
		int	update_fetchhead,
		git_remote_autotag_option_t	download_tags,
		const char *	reflog_message
	)

inline

◆ remote_upload()

void remote_upload	(	git_remote *	remote,
		const git_strarray *	refspecs,
		const git_push_options *	opts
	)

inline

◆ remote_url()

const char* remote_url ( const git_remote * remote )

inline

◆ repository_commondir()

const char* repository_commondir ( const git_repository * repo )

inline

◆ repository_config()

git_config* repository_config ( git_repository * repo )

inline

◆ repository_config_snapshot()

git_config* repository_config_snapshot ( git_repository * repo )

inline

◆ repository_detach_head()

void repository_detach_head ( git_repository * repo )

inline

◆ repository_discover()

git_buf repository_discover	(	const char *	start_path,
		int	across_fs,
		const char *	ceiling_dirs
	)

inline

◆ repository_fetchhead_foreach()

void repository_fetchhead_foreach	(	git_repository *	repo,
		git_repository_fetchhead_foreach_cb	callback,
		void *	payload
	)

inline

◆ repository_free()

void repository_free ( git_repository * repo )

inline

◆ repository_get_namespace()

const char* repository_get_namespace ( git_repository * repo )

inline

◆ repository_hashfile()

git_oid repository_hashfile	(	git_repository *	repo,
		const char *	path,
		git_object_t	type,
		const char *	as_path
	)

inline

◆ repository_head()

git_reference* repository_head ( git_repository * repo )

inline

◆ repository_head_detached()

void repository_head_detached ( git_repository * repo )

inline

◆ repository_head_detached_for_worktree()

void repository_head_detached_for_worktree	(	git_repository *	repo,
		const char *	name
	)

inline

◆ repository_head_for_worktree()

git_reference* repository_head_for_worktree	(	git_repository *	repo,
		const char *	name
	)

inline

◆ repository_head_unborn()

void repository_head_unborn ( git_repository * repo )

inline

◆ repository_ident()

void repository_ident	(	const char **	name,
		const char **	email,
		const git_repository *	repo
	)

inline

◆ repository_index()

git_index* repository_index ( git_repository * repo )

inline

◆ repository_init()

git_repository* repository_init	(	const char *	path,
		unsigned int	is_bare
	)

inline

◆ repository_init_ext()

git_repository* repository_init_ext	(	const char *	repo_path,
		git_repository_init_options *	opts
	)

inline

◆ repository_init_options_init()

void repository_init_options_init	(	git_repository_init_options *	opts,
		unsigned int	version
	)

inline

◆ repository_is_bare()

void repository_is_bare ( const git_repository * repo )

inline

◆ repository_is_empty()

void repository_is_empty ( git_repository * repo )

inline

◆ repository_is_shallow()

void repository_is_shallow ( git_repository * repo )

inline

◆ repository_is_worktree()

void repository_is_worktree ( const git_repository * repo )

inline

◆ repository_item_path()

git_buf repository_item_path	(	const git_repository *	repo,
		git_repository_item_t	item
	)

inline

◆ repository_mergehead_foreach()

void repository_mergehead_foreach	(	git_repository *	repo,
		git_repository_mergehead_foreach_cb	callback,
		void *	payload
	)

inline

◆ repository_message()

git_buf repository_message ( git_repository * repo )

inline

◆ repository_message_remove()

void repository_message_remove ( git_repository * repo )

inline

◆ repository_odb()

git_odb* repository_odb ( git_repository * repo )

inline

◆ repository_open()

git_repository* repository_open ( const char * path )

inline

◆ repository_open_bare()

git_repository* repository_open_bare ( const char * bare_path )

inline

◆ repository_open_ext()

git_repository* repository_open_ext	(	const char *	path,
		unsigned int	flags,
		const char *	ceiling_dirs
	)

inline

◆ repository_open_from_worktree()

git_repository* repository_open_from_worktree ( git_worktree * wt )

inline

◆ repository_path()

const char* repository_path ( const git_repository * repo )

inline

◆ repository_refdb()

git_refdb* repository_refdb ( git_repository * repo )

inline

◆ repository_set_head()

void repository_set_head	(	git_repository *	repo,
		const char *	refname
	)

inline

◆ repository_set_head_detached()

void repository_set_head_detached	(	git_repository *	repo,
		const git_oid *	committish
	)

inline

◆ repository_set_head_detached_from_annotated()

void repository_set_head_detached_from_annotated	(	git_repository *	repo,
		const git_annotated_commit *	committish
	)

inline

◆ repository_set_ident()

void repository_set_ident	(	git_repository *	repo,
		const char *	name,
		const char *	email
	)

inline

◆ repository_set_namespace()

void repository_set_namespace	(	git_repository *	repo,
		const char *	nmspace
	)

inline

◆ repository_set_workdir()

void repository_set_workdir	(	git_repository *	repo,
		const char *	workdir,
		int	update_gitlink
	)

inline

◆ repository_state()

void repository_state ( git_repository * repo )

inline

◆ repository_state_cleanup()

void repository_state_cleanup ( git_repository * repo )

inline

◆ repository_workdir()

const char* repository_workdir ( const git_repository * repo )

inline

◆ repository_wrap_odb()

git_repository* repository_wrap_odb ( git_odb * odb )

inline

◆ reset()

void reset	(	git_repository *	repo,
		const git_object *	target,
		git_reset_t	reset_type,
		const git_checkout_options *	checkout_opts
	)

inline

◆ reset_default()

void reset_default	(	git_repository *	repo,
		const git_object *	target,
		const git_strarray *	pathspecs
	)

inline

◆ reset_from_annotated()

void reset_from_annotated	(	git_repository *	repo,
		const git_annotated_commit *	commit,
		git_reset_t	reset_type,
		const git_checkout_options *	checkout_opts
	)

inline

◆ revert()

void revert	(	git_repository *	repo,
		git_commit *	commit,
		const git_revert_options *	given_opts
	)

inline

◆ revert_commit()

git_index* revert_commit	(	git_repository *	repo,
		git_commit *	revert_commit,
		git_commit *	our_commit,
		unsigned int	mainline,
		const git_merge_options *	merge_options
	)

inline

◆ revert_options_init()

void revert_options_init	(	git_revert_options *	opts,
		unsigned int	version
	)

inline

◆ revparse()

git_revspec revparse	(	git_repository *	repo,
		const char *	spec
	)

inline

◆ revparse_ext()

void revparse_ext	(	git_object **	object_out,
		git_reference **	reference_out,
		git_repository *	repo,
		const char *	spec
	)

inline

◆ revparse_single()

git_object* revparse_single	(	git_repository *	repo,
		const char *	spec
	)

inline

◆ revwalk_add_hide_cb()

void revwalk_add_hide_cb	(	git_revwalk *	walk,
		git_revwalk_hide_cb	hide_cb,
		void *	payload
	)

inline

◆ revwalk_free()

void revwalk_free ( git_revwalk * walk )

inline

◆ revwalk_hide()

void revwalk_hide	(	git_revwalk *	walk,
		const git_oid *	commit_id
	)

inline

◆ revwalk_hide_glob()

void revwalk_hide_glob	(	git_revwalk *	walk,
		const char *	glob
	)

inline

◆ revwalk_hide_head()

void revwalk_hide_head ( git_revwalk * walk )

inline

◆ revwalk_hide_ref()

void revwalk_hide_ref	(	git_revwalk *	walk,
		const char *	refname
	)

inline

◆ revwalk_new()

git_revwalk* revwalk_new ( git_repository * repo )

inline

◆ revwalk_next()

int revwalk_next	(	git_oid *	out,
		git_revwalk *	walk
	)

inline

◆ revwalk_push()

void revwalk_push	(	git_revwalk *	walk,
		const git_oid *	id
	)

inline

◆ revwalk_push_glob()

void revwalk_push_glob	(	git_revwalk *	walk,
		const char *	glob
	)

inline

◆ revwalk_push_head()

void revwalk_push_head ( git_revwalk * walk )

inline

◆ revwalk_push_range()

void revwalk_push_range	(	git_revwalk *	walk,
		const char *	range
	)

inline

◆ revwalk_push_ref()

void revwalk_push_ref	(	git_revwalk *	walk,
		const char *	refname
	)

inline

◆ revwalk_repository()

git_repository* revwalk_repository ( git_revwalk * walk )

inline

◆ revwalk_reset()

void revwalk_reset ( git_revwalk * walker )

inline

◆ revwalk_simplify_first_parent()

void revwalk_simplify_first_parent ( git_revwalk * walk )

inline

◆ revwalk_sorting()

void revwalk_sorting	(	git_revwalk *	walk,
		unsigned int	sort_mode
	)

inline

◆ signature_default()

git_signature* signature_default ( git_repository * repo )

inline

◆ signature_dup()

void signature_dup	(	git_signature **	dest,
		const git_signature *	sig
	)

inline

◆ signature_free()

void signature_free ( git_signature * sig )

inline

◆ signature_from_buffer()

git_signature* signature_from_buffer ( const char * buf )

inline

◆ signature_new()

git_signature* signature_new	(	const char *	name,
		const char *	email,
		git_time_t	time,
		int	offset
	)

inline

◆ signature_now()

git_signature* signature_now	(	const char *	name,
		const char *	email
	)

inline

◆ stash_apply()

void stash_apply	(	git_repository *	repo,
		size_t	index,
		const git_stash_apply_options *	options
	)

inline

◆ stash_apply_options_init()

void stash_apply_options_init	(	git_stash_apply_options *	opts,
		unsigned int	version
	)

inline

◆ stash_drop()

void stash_drop	(	git_repository *	repo,
		size_t	index
	)

inline

◆ stash_foreach()

void stash_foreach	(	git_repository *	repo,
		git_stash_cb	callback,
		void *	payload
	)

inline

◆ stash_pop()

void stash_pop	(	git_repository *	repo,
		size_t	index,
		const git_stash_apply_options *	options
	)

inline

◆ stash_save()

git_oid stash_save	(	git_repository *	repo,
		const git_signature *	stasher,
		const char *	message,
		uint32_t	flags
	)

inline

◆ status_byindex()

const git_status_entry* status_byindex	(	git_status_list *	statuslist,
		size_t	idx
	)

inline

◆ status_file()

void status_file	(	unsigned int *	status_flags,
		git_repository *	repo,
		const char *	path
	)

inline

◆ status_foreach()

void status_foreach	(	git_repository *	repo,
		git_status_cb	callback,
		void *	payload
	)

inline

◆ status_foreach_ext()

void status_foreach_ext	(	git_repository *	repo,
		const git_status_options *	opts,
		git_status_cb	callback,
		void *	payload
	)

inline

◆ status_list_entrycount()

size_t status_list_entrycount ( git_status_list * statuslist )

inline

◆ status_list_free()

void status_list_free ( git_status_list * statuslist )

inline

◆ status_list_new()

git_status_list* status_list_new	(	git_repository *	repo,
		const git_status_options *	opts
	)

inline

◆ status_options_init()

void status_options_init	(	git_status_options *	opts,
		unsigned int	version
	)

inline

◆ status_should_ignore()

void status_should_ignore	(	int *	ignored,
		git_repository *	repo,
		const char *	path
	)

inline

◆ strarray_copy()

void strarray_copy	(	git_strarray *	tgt,
		const git_strarray *	src
	)

inline

◆ strarray_dispose()

void strarray_dispose ( git_strarray * array )

inline

◆ submodule_add_finalize()

void submodule_add_finalize ( git_submodule * submodule )

inline

◆ submodule_add_setup()

git_submodule* submodule_add_setup	(	git_repository *	repo,
		const char *	url,
		const char *	path,
		int	use_gitlink
	)

inline

◆ submodule_add_to_index()

void submodule_add_to_index	(	git_submodule *	submodule,
		int	write_index
	)

inline

◆ submodule_branch()

const char* submodule_branch ( git_submodule * submodule )

inline

◆ submodule_clone()

git_repository* submodule_clone	(	git_submodule *	submodule,
		const git_submodule_update_options *	opts
	)

inline

◆ submodule_dup()

git_submodule* submodule_dup ( git_submodule * source )

inline

◆ submodule_fetch_recurse_submodules()

git_submodule_recurse_t submodule_fetch_recurse_submodules ( git_submodule * submodule )

inline

◆ submodule_foreach()

void submodule_foreach	(	git_repository *	repo,
		git_submodule_cb	callback,
		void *	payload
	)

inline

◆ submodule_free()

void submodule_free ( git_submodule * submodule )

inline

◆ submodule_head_id()

const git_oid* submodule_head_id ( git_submodule * submodule )

inline

◆ submodule_ignore()

git_submodule_ignore_t submodule_ignore ( git_submodule * submodule )

inline

◆ submodule_index_id()

const git_oid* submodule_index_id ( git_submodule * submodule )

inline

◆ submodule_init()

void submodule_init	(	git_submodule *	submodule,
		int	overwrite
	)

inline

◆ submodule_location()

void submodule_location	(	unsigned int *	location_status,
		git_submodule *	submodule
	)

inline

◆ submodule_lookup()

git_submodule* submodule_lookup	(	git_repository *	repo,
		const char *	name
	)

inline

◆ submodule_name()

const char* submodule_name ( git_submodule * submodule )

inline

◆ submodule_open()

void submodule_open	(	git_repository **	repo,
		git_submodule *	submodule
	)

inline

◆ submodule_owner()

git_repository* submodule_owner ( git_submodule * submodule )

inline

◆ submodule_path()

const char* submodule_path ( git_submodule * submodule )

inline

◆ submodule_reload()

void submodule_reload	(	git_submodule *	submodule,
		int	force
	)

inline

◆ submodule_repo_init()

git_repository* submodule_repo_init	(	const git_submodule *	sm,
		int	use_gitlink
	)

inline

◆ submodule_resolve_url()

git_buf submodule_resolve_url	(	git_repository *	repo,
		const char *	url
	)

inline

◆ submodule_set_branch()

void submodule_set_branch	(	git_repository *	repo,
		const char *	name,
		const char *	branch
	)

inline

◆ submodule_set_fetch_recurse_submodules()

void submodule_set_fetch_recurse_submodules	(	git_repository *	repo,
		const char *	name,
		git_submodule_recurse_t	fetch_recurse_submodules
	)

inline

◆ submodule_set_ignore()

void submodule_set_ignore	(	git_repository *	repo,
		const char *	name,
		git_submodule_ignore_t	ignore
	)

inline

◆ submodule_set_update()

void submodule_set_update	(	git_repository *	repo,
		const char *	name,
		git_submodule_update_t	update
	)

inline

◆ submodule_set_url()

void submodule_set_url	(	git_repository *	repo,
		const char *	name,
		const char *	url
	)

inline

◆ submodule_status()

void submodule_status	(	unsigned int *	status,
		git_repository *	repo,
		const char *	name,
		git_submodule_ignore_t	ignore
	)

inline

◆ submodule_sync()

void submodule_sync ( git_submodule * submodule )

inline

◆ submodule_update()

void submodule_update	(	git_submodule *	submodule,
		int	init,
		git_submodule_update_options *	options
	)

inline

◆ submodule_update_options_init()

void submodule_update_options_init	(	git_submodule_update_options *	opts,
		unsigned int	version
	)

inline

◆ submodule_update_strategy()

git_submodule_update_t submodule_update_strategy ( git_submodule * submodule )

inline

◆ submodule_url()

const char* submodule_url ( git_submodule * submodule )

inline

◆ submodule_wd_id()

const git_oid* submodule_wd_id ( git_submodule * submodule )

inline

◆ tag_annotation_create()

void tag_annotation_create	(	git_oid *	oid,
		git_repository *	repo,
		const char *	tag_name,
		const git_object *	target,
		const git_signature *	tagger,
		const char *	message
	)

inline

◆ tag_create()

void tag_create	(	git_oid *	oid,
		git_repository *	repo,
		const char *	tag_name,
		const git_object *	target,
		const git_signature *	tagger,
		const char *	message,
		int	force
	)

inline

◆ tag_create_from_buffer()

void tag_create_from_buffer	(	git_oid *	oid,
		git_repository *	repo,
		const char *	buffer,
		int	force
	)

inline

◆ tag_create_lightweight()

void tag_create_lightweight	(	git_oid *	oid,
		git_repository *	repo,
		const char *	tag_name,
		const git_object *	target,
		int	force
	)

inline

◆ tag_delete()

void tag_delete	(	git_repository *	repo,
		const char *	tag_name
	)

inline

◆ tag_dup()

git_tag* tag_dup ( git_tag * source )

inline

◆ tag_foreach()

void tag_foreach	(	git_repository *	repo,
		git_tag_foreach_cb	callback,
		void *	payload
	)

inline

◆ tag_free()

void tag_free ( git_tag * tag )

inline

◆ tag_id()

const git_oid* tag_id ( const git_tag * tag )

inline

◆ tag_list()

void tag_list	(	git_strarray *	tag_names,
		git_repository *	repo
	)

inline

◆ tag_list_match()

void tag_list_match	(	git_strarray *	tag_names,
		const char *	pattern,
		git_repository *	repo
	)

inline

◆ tag_lookup()

git_tag* tag_lookup	(	git_repository *	repo,
		const git_oid *	id
	)

inline

◆ tag_lookup_prefix()

git_tag* tag_lookup_prefix	(	git_repository *	repo,
		const git_oid *	id,
		size_t	len
	)

inline

◆ tag_message()

const char* tag_message ( const git_tag * tag )

inline

◆ tag_name()

const char* tag_name ( const git_tag * tag )

inline

◆ tag_name_is_valid()

void tag_name_is_valid	(	int *	valid,
		const char *	name
	)

inline

◆ tag_owner()

git_repository* tag_owner ( const git_tag * tag )

inline

◆ tag_peel()

void tag_peel	(	git_object **	tag_target_out,
		const git_tag *	tag
	)

inline

◆ tag_tagger()

const git_signature* tag_tagger ( const git_tag * tag )

inline

◆ tag_target()

void tag_target	(	git_object **	target_out,
		const git_tag *	tag
	)

inline

◆ tag_target_id()

const git_oid* tag_target_id ( const git_tag * tag )

inline

◆ tag_target_type()

git_object_t tag_target_type ( const git_tag * tag )

inline

◆ trace_set()

void trace_set	(	git_trace_level_t	level,
		git_trace_cb	cb
	)

inline

◆ transaction_commit()

void transaction_commit ( git_transaction * tx )

inline

◆ transaction_free()

void transaction_free ( git_transaction * tx )

inline

◆ transaction_lock_ref()

void transaction_lock_ref	(	git_transaction *	tx,
		const char *	refname
	)

inline

◆ transaction_new()

git_transaction* transaction_new ( git_repository * repo )

inline

◆ transaction_remove()

void transaction_remove	(	git_transaction *	tx,
		const char *	refname
	)

inline

◆ transaction_set_reflog()

void transaction_set_reflog	(	git_transaction *	tx,
		const char *	refname,
		const git_reflog *	reflog
	)

inline

◆ transaction_set_symbolic_target()

void transaction_set_symbolic_target	(	git_transaction *	tx,
		const char *	refname,
		const char *	target,
		const git_signature *	sig,
		const char *	msg
	)

inline

◆ transaction_set_target()

void transaction_set_target	(	git_transaction *	tx,
		const char *	refname,
		const git_oid *	target,
		const git_signature *	sig,
		const char *	msg
	)

inline

◆ tree_create_updated()

git_oid tree_create_updated	(	git_repository *	repo,
		git_tree *	baseline,
		size_t	nupdates,
		const git_tree_update *	updates
	)

inline

◆ tree_dup()

git_tree* tree_dup ( git_tree * source )

inline

◆ tree_entry_byid()

const git_tree_entry* tree_entry_byid	(	const git_tree *	tree,
		const git_oid *	id
	)

inline

◆ tree_entry_byindex()

const git_tree_entry* tree_entry_byindex	(	const git_tree *	tree,
		size_t	idx
	)

inline

◆ tree_entry_byname()

const git_tree_entry* tree_entry_byname	(	const git_tree *	tree,
		const char *	filename
	)

inline

◆ tree_entry_bypath()

git_tree_entry* tree_entry_bypath	(	const git_tree *	root,
		const char *	path
	)

inline

◆ tree_entry_cmp()

void tree_entry_cmp	(	const git_tree_entry *	e1,
		const git_tree_entry *	e2
	)

inline

◆ tree_entry_dup()

git_tree_entry* tree_entry_dup ( const git_tree_entry * source )

inline

◆ tree_entry_filemode()

git_filemode_t tree_entry_filemode ( const git_tree_entry * entry )

inline

◆ tree_entry_filemode_raw()

git_filemode_t tree_entry_filemode_raw ( const git_tree_entry * entry )

inline

◆ tree_entry_free()

void tree_entry_free ( git_tree_entry * entry )

inline

◆ tree_entry_id()

const git_oid* tree_entry_id ( const git_tree_entry * entry )

inline

◆ tree_entry_name()

const char* tree_entry_name ( const git_tree_entry * entry )

inline

◆ tree_entry_to_object()

git_object* tree_entry_to_object	(	git_repository *	repo,
		const git_tree_entry *	entry
	)

inline

◆ tree_entry_type()

git_object_t tree_entry_type ( const git_tree_entry * entry )

inline

◆ tree_entrycount()

size_t tree_entrycount ( const git_tree * tree )

inline

◆ tree_free()

void tree_free ( git_tree * tree )

inline

◆ tree_id()

const git_oid* tree_id ( const git_tree * tree )

inline

◆ tree_lookup()

git_tree* tree_lookup	(	git_repository *	repo,
		const git_oid *	id
	)

inline

◆ tree_lookup_prefix()

git_tree* tree_lookup_prefix	(	git_repository *	repo,
		const git_oid *	id,
		size_t	len
	)

inline

◆ tree_owner()

git_repository* tree_owner ( const git_tree * tree )

inline

◆ tree_walk()

void tree_walk	(	const git_tree *	tree,
		git_treewalk_mode	mode,
		git_treewalk_cb	callback,
		void *	payload
	)

inline

◆ treebuilder_clear()

void treebuilder_clear ( git_treebuilder * bld )

inline

◆ treebuilder_entrycount()

size_t treebuilder_entrycount ( git_treebuilder * bld )

inline

◆ treebuilder_filter()

void treebuilder_filter	(	git_treebuilder *	bld,
		git_treebuilder_filter_cb	filter,
		void *	payload
	)

inline

◆ treebuilder_free()

void treebuilder_free ( git_treebuilder * bld )

inline

◆ treebuilder_get()

const git_tree_entry* treebuilder_get	(	git_treebuilder *	bld,
		const char *	filename
	)

inline

◆ treebuilder_insert()

const git_tree_entry* treebuilder_insert	(	git_treebuilder *	bld,
		const char *	filename,
		const git_oid *	id,
		git_filemode_t	filemode
	)

inline

◆ treebuilder_new()

git_treebuilder* treebuilder_new	(	git_repository *	repo,
		const git_tree *	source
	)

inline

◆ treebuilder_remove()

void treebuilder_remove	(	git_treebuilder *	bld,
		const char *	filename
	)

inline

◆ treebuilder_write()

void treebuilder_write	(	git_oid *	id,
		git_treebuilder *	bld
	)

inline

◆ worktree_add()

git_worktree* worktree_add	(	git_repository *	repo,
		const char *	name,
		const char *	path,
		const git_worktree_add_options *	opts
	)

inline

◆ worktree_add_options_init()

void worktree_add_options_init	(	git_worktree_add_options *	opts,
		unsigned int	version
	)

inline

◆ worktree_free()

void worktree_free ( git_worktree * wt )

inline

◆ worktree_is_locked()

void worktree_is_locked	(	git_buf *	reason,
		const git_worktree *	wt
	)

inline

◆ worktree_is_prunable()

void worktree_is_prunable	(	git_worktree *	wt,
		git_worktree_prune_options *	opts
	)

inline

◆ worktree_list()

git_strarray worktree_list ( git_repository * repo )

inline

◆ worktree_lock()

void worktree_lock	(	git_worktree *	wt,
		const char *	reason
	)

inline

◆ worktree_lookup()

git_worktree* worktree_lookup	(	git_repository *	repo,
		const char *	name
	)

inline

◆ worktree_name()

const char* worktree_name ( const git_worktree * wt )

inline

◆ worktree_open_from_repository()

git_worktree* worktree_open_from_repository ( git_repository * repo )

inline

◆ worktree_path()

const char* worktree_path ( const git_worktree * wt )

inline

◆ worktree_prune()

void worktree_prune	(	git_worktree *	wt,
		git_worktree_prune_options *	opts
	)

inline

◆ worktree_prune_options_init()

void worktree_prune_options_init	(	git_worktree_prune_options *	opts,
		unsigned int	version
	)

inline

◆ worktree_unlock()

void worktree_unlock ( git_worktree * wt )

inline

◆ worktree_validate()

void worktree_validate ( const git_worktree * wt )

inline

Functions

Function Documentation

◆ annotated_commit_free()

◆ annotated_commit_from_fetchhead()

◆ annotated_commit_from_ref()

◆ annotated_commit_from_revspec()

◆ annotated_commit_id()

◆ annotated_commit_lookup()

◆ annotated_commit_ref()

◆ apply()

◆ apply_options_init()

◆ apply_to_tree()

◆ attr_add_macro()

◆ attr_cache_flush()

◆ attr_foreach()

◆ attr_foreach_ext()

◆ attr_get()

◆ attr_get_ext()

◆ attr_get_many()

◆ attr_get_many_ext()

◆ attr_value()

◆ blame_buffer()

◆ blame_file()

◆ blame_free()

◆ blame_get_hunk_byindex()

◆ blame_get_hunk_byline()

◆ blame_get_hunk_count()

◆ blame_options_init()

◆ blob_create_from_buffer()

◆ blob_create_from_disk()

◆ blob_create_from_stream()

◆ blob_create_from_stream_commit()

◆ blob_create_from_workdir()

◆ blob_data_is_binary()

◆ blob_dup()

◆ blob_filter()

◆ blob_filter_options_init()

◆ blob_free()

◆ blob_id()

◆ blob_is_binary()

◆ blob_lookup()

◆ blob_lookup_prefix()

◆ blob_owner()

◆ blob_rawcontent()

◆ blob_rawsize()

◆ branch_create()

◆ branch_create_from_annotated()

◆ branch_delete()

◆ branch_is_checked_out()

◆ branch_is_head()

◆ branch_iterator_free()

◆ branch_iterator_new()

◆ branch_lookup()

◆ branch_move()

◆ branch_name()

◆ branch_name_is_valid()

◆ branch_next()

◆ branch_remote_name()

◆ branch_set_upstream()

◆ branch_upstream()

◆ branch_upstream_merge()

◆ branch_upstream_name()

◆ branch_upstream_remote()

◆ buf_dispose()

◆ checkout_head()

◆ checkout_index()

◆ checkout_options_init()

◆ checkout_tree()

◆ cherrypick()

◆ cherrypick_commit()

◆ cherrypick_options_init()

◆ clone()

◆ clone_options_init()

◆ commit_amend()

◆ commit_author()

◆ commit_author_with_mailmap()

◆ commit_body()

◆ commit_committer()

◆ commit_committer_with_mailmap()

◆ commit_create()