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_comit 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.

Frees a git_annotated_commit.

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 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.

Loop over all the git attributes for a path.

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

Initializes a git_blame_options with default values. Equivalent to\n 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

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_free).

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_frombuffer(). 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_fromstream_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.

If the branch is successfully deleted, the passed reference object will be invalidated. The reference must be freed manually by the user.

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.

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. See git_tag_create() for rules about valid names.

Return the name of the given local or remote branch.

The name of the branch matches the definition of the name for git_branch_lookup. That is, if the returned name is given to git_branch_lookup() then the reference is returned that was given to this function.

Return the name of the given remote branch.

Return the reference supporting the remote tracking branch,\n given a local branch reference.

Set the upstream configuration for a given local branch

Determine if the current local branch is pointed at by HEAD.

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

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