Creates a git_annotated_commit from the given reference.\n The resulting git_annotated_commit must be freed with\n git_annotated_commit_free.

Creates a git_annotated_commit from the given fetch head data.\n The resulting git_annotated_commit must be freed with\n git_annotated_commit_free.

Creates a git_annotated_commit from the given commit id.\n The resulting git_annotated_commit must be freed with\n git_annotated_commit_free.

An annotated commit contains information about how it was looked up, which may be useful for functions like merge or rebase to provide context to the operation. For example, conflict files will include the name of the source or target branches being merged. It is therefore preferable to use the most specific function (eg git_annotated_commit_from_ref) instead of this one when that data is known.

Creates a git_annotated_commit from a revision string.

See man gitrevisions, or http://git-scm.com/docs/git-rev-parse.html#_specifying_revisions for information on the syntax accepted.

Gets the commit ID that the given git_annotated_commit refers to.

Get the refname that the given git_annotated_commit refers to.

Frees a git_annotated_commit.

Apply a git_diff to a git_tree, and return the resulting image\n as an index.

Apply a git_diff to the given repository, making changes directly\n in the working directory, the index, or both.

Return the value type for a given attribute.

This can be either TRUE, FALSE, UNSPECIFIED (if the attribute was not set at all), or VALUE, if the attribute was set to an actual string.

If the attribute has a VALUE string, it can be accessed normally as a NULL-terminated C string.

Look up the value of one git attribute for path.

Look up the value of one git attribute for path with extended options.

Look up a list of git attributes for path.

Use this if you have a known list of attributes that you want to look up in a single call. This is somewhat more efficient than calling git_attr_get() multiple times.

For example, you might write:

 const char *attrs[] = { "crlf", "diff", "foo" };     const char **values[3];     git_attr_get_many(values, repo, 0, "my/fun/file.c", 3, attrs);\n

Then you could loop through the 3 values to get the settings for the three attributes you asked about.

Look up a list of git attributes for path with extended options.

Loop over all the git attributes for a path.

Loop over all the git attributes for a path with extended options.

Flush the gitattributes cache.

Call this if you have reason to believe that the attributes files on disk no longer match the cached contents of memory. This will cause the attributes files to be reloaded the next time that an attribute access function is called.

Add a macro definition.

Macros will automatically be loaded from the top level .gitattributes file of the repository (plus the build-in "binary" macro). This function allows you to add others. For example, to add the default macro, you would call:

 git_attr_add_macro(repo, "binary", "-diff -crlf");\n

Initialize git_blame_options structure

Initializes a git_blame_options with default values. Equivalent to creating an instance with GIT_BLAME_OPTIONS_INIT.

Gets the number of hunks that exist in the blame structure.

Gets the blame hunk at the given index.

Gets the hunk that relates to the given line number in the newest commit.

Get the blame for a single file.

Get blame data for a file that has been modified in memory. The reference\n parameter is a pre-calculated blame for the in-odb history of the file. This\n means that once a file blame is completed (which can be expensive), updating\n the buffer blame is very fast.

Lines that differ between the buffer and the committed version are marked as having a zero OID for their final_commit_id.

Free memory allocated by git_blame_file or git_blame_buffer.

Lookup a blob object from a repository.

Lookup a blob object from a repository,\n given a prefix of its identifier (short id).

Close an open blob

This is a wrapper around git_object_free()

IMPORTANT: It is necessary to call this method when you stop using a blob. Failure to do so will cause a memory leak.

Get the id of a blob.

Get the repository that contains the blob.

Get a read-only buffer with the raw content of a blob.

A pointer to the raw content of a blob is returned; this pointer is owned internally by the object and shall not be free'd. The pointer may be invalidated at a later time.

Get the size in bytes of the contents of a blob

Initialize git_blob_filter_options structure

Initializes a git_blob_filter_options with default values. Equivalent to creating an instance with GIT_BLOB_FILTER_OPTIONS_INIT.

Get a buffer with the filtered content of a blob.

This applies filters as if the blob was being checked out to the working directory under the specified filename. This may apply CRLF filtering or other types of changes depending on the file attributes set for the blob and the content detected in it.

The output is written into a git_buf which the caller must free when done (via git_buf_dispose).

If no filters need to be applied, then the out buffer will just be populated with a pointer to the raw content of the blob. In that case, be careful to not free the blob until done with the buffer or copy it into memory you own.

Read a file from the working folder of a repository\n and write it to the Object Database as a loose blob

Read a file from the filesystem and write its content\n to the Object Database as a loose blob

Create a stream to write a new blob into the object db

This function may need to buffer the data on disk and will in general not be the right choice if you know the size of the data to write. If you have data in memory, use git_blob_create_from_buffer(). If you do not, but know the size of the contents (and don't want/need to perform filtering), use git_odb_open_wstream().

Don't close this stream yourself but pass it to git_blob_create_from_stream_commit() to commit the write to the object db and get the object id.

If the hintpath parameter is filled, it will be used to determine what git filters should be applied to the object before it is written to the object database.

Close the stream and write the blob to the object db

The stream will be closed and freed.

Write an in-memory buffer to the ODB as a blob

Determine if the blob content is most certainly binary or not.

The heuristic used to guess if a file is binary is taken from core git: Searching for NUL bytes and looking for a reasonable ratio of printable to non-printable characters among the first 8000 bytes.

Create an in-memory copy of a blob. The copy must be explicitly\n free'd or it will leak.

Create a new branch pointing at a target commit

A new direct reference will be created pointing to this target commit. If force is true and a reference already exists with the given name, it'll be replaced.

The returned reference must be freed by the user.

The branch name will be checked for validity. See git_tag_create() for rules about valid names.

Create a new branch pointing at a target commit

This behaves like git_branch_create() but takes an annotated commit, which lets you specify which extended sha syntax string was specified by a user, allowing for more exact reflog messages.

See the documentation for git_branch_create().

Delete an existing branch reference.

Note that if the deletion succeeds, the reference object will not be valid anymore, and should be freed immediately by the user using git_reference_free().

Create an iterator which loops over the requested branches.

Retrieve the next branch from the iterator

Free a branch iterator

Move/rename an existing local branch reference.

The new branch name will be checked for validity. See git_tag_create() for rules about valid names.

Note that if the move succeeds, the old reference object will not + be valid anymore, and should be freed immediately by the user using + git_reference_free().

Lookup a branch by its name in a repository.

The generated reference must be freed by the user. The branch name will be checked for validity.

Get the branch name

Given a reference object, this will check that it really is a branch (ie. it lives under "refs/heads/" or "refs/remotes/"), and return the branch part of it.

Get the upstream of a branch

Given a reference, this will return a new reference object corresponding to its remote tracking branch. The reference must be a local branch.

Set a branch's upstream branch

This will update the configuration to set the branch named branch_name as the upstream of branch. Pass a NULL name to unset the upstream information.

Get the upstream name of a branch

Given a local branch, this will return its remote-tracking branch information, as a full reference name, ie. "feature/nice" would become "refs/remote/origin/feature/nice", depending on that branch's configuration.

Determine if HEAD points to the given branch

Determine if any HEAD points to the current branch

This will iterate over all known linked repositories (usually in the form of worktrees) and report whether any HEAD is pointing at the current branch.

Find the remote name of a remote-tracking branch

This will return the name of the remote whose fetch refspec is matching the given branch. E.g. given a branch "refs/remotes/test/master", it will extract the "test" part. If refspecs from multiple remotes match, the function will return GIT_EAMBIGUOUS.

Retrieve the upstream remote of a local branch

This will return the currently configured "branch.*.remote" for a given branch. This branch must be local.

Retrieve the upstream merge of a local branch

This will return the currently configured "branch.*.merge" for a given branch. This branch must be local.

Determine whether a branch name is valid, meaning that (when prefixed\n with refs/heads/) that it is a valid reference name, and that any\n additional branch name restrictions are imposed (eg, it cannot start\n with a -).

Free the memory referred to by the git_buf.

Note that this does not free the git_buf itself, just the memory pointed to by buffer->ptr. This will not free the memory if it looks like it was not allocated internally, but it will clear the buffer back to the empty state.

Resize the buffer allocation to make more space.

This will attempt to grow the buffer to accommodate the target size.

If the buffer refers to memory that was not allocated by libgit2 (i.e. the asize field is zero), then ptr will be replaced with a newly allocated block of data. Be careful so that memory allocated by the caller is not lost. As a special variant, if you pass target_size as 0 and the memory is not allocated by libgit2, this will allocate a new buffer of size size and copy the external data into it.

Currently, this will never shrink a buffer, only expand it.

If the allocation fails, this will return an error and the buffer will be marked as invalid for future operations, invaliding the contents.

Set buffer to a copy of some raw data.

Check quickly if buffer looks like it contains binary data

Check quickly if buffer contains a NUL byte

Initialize git_checkout_options structure

Initializes a git_checkout_options with default values. Equivalent to creating an instance with GIT_CHECKOUT_OPTIONS_INIT.