using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Globalization;

using System.IO;

using System.Linq;

using System.Runtime.InteropServices;

using System.Text;

using LibGit2Sharp.Core.Handles;

using LibGit2Sharp.Handlers;

// ReSharper disable InconsistentNaming

namespace LibGit2Sharp.Core

{

internal class Proxy

{

#region giterr_

public static void giterr_set_str(GitErrorCategory error_class, Exception exception)

{

if (exception is OutOfMemoryException)

{

NativeMethods.giterr_set_oom();

}

else

{

NativeMethods.giterr_set_str(error_class, ErrorMessageFromException(exception));

}

}

public static void giterr_set_str(GitErrorCategory error_class, String errorString)

{

NativeMethods.giterr_set_str(error_class, errorString);

}

/// <summary>

/// This method will take an exception and try to generate an error message

/// that captures the important messages of the error.

/// The formatting is a bit subjective.

/// </summary>

/// <param name="ex"></param>

/// <returns></returns>

public static string ErrorMessageFromException(Exception ex)

{

StringBuilder sb = new StringBuilder();

BuildErrorMessageFromException(sb, 0, ex);

return sb.ToString();

}

private static void BuildErrorMessageFromException(StringBuilder sb, int level, Exception ex)

{

string indent = new string(' ', level * 4);

sb.AppendFormat("{0}{1}", indent, ex.Message);

if (ex is AggregateException)

{

AggregateException aggregateException = ((AggregateException)ex).Flatten();

if (aggregateException.InnerExceptions.Count == 1)

{

sb.AppendLine();

sb.AppendLine();

sb.AppendFormat("{0}Contained Exception:{1}", indent, Environment.NewLine);

BuildErrorMessageFromException(sb, level + 1, aggregateException.InnerException);

}

else

{

sb.AppendLine();

sb.AppendLine();

sb.AppendFormat("{0}Contained Exceptions:{1}", indent, Environment.NewLine);

for (int i = 0; i < aggregateException.InnerExceptions.Count; i++)

{

if (i != 0)

{

sb.AppendLine();

sb.AppendLine();

}

BuildErrorMessageFromException(sb, level + 1, aggregateException.InnerExceptions[i]);

}

}

}

else if (ex.InnerException != null)

{

sb.AppendLine();

sb.AppendLine();

sb.AppendFormat("{0}Inner Exception:{1}", indent, Environment.NewLine);

BuildErrorMessageFromException(sb, level + 1, ex.InnerException);

}

}

#endregion

#region git_blame_

public static unsafe BlameHandle git_blame_file(

RepositoryHandle repo,

string path,

git_blame_options options)

{

git_blame* ptr;

int res = NativeMethods.git_blame_file(out ptr, repo, path, options);

Ensure.ZeroResult(res);

return new BlameHandle(ptr, true);

}

public static unsafe git_blame_hunk* git_blame_get_hunk_byindex(BlameHandle blame, uint idx)

{

return NativeMethods.git_blame_get_hunk_byindex(blame, idx);

}

#endregion

#region git_blob_

public static unsafe IntPtr git_blob_create_fromstream(RepositoryHandle repo, string hintpath)

{

IntPtr writestream_ptr;

Ensure.ZeroResult(NativeMethods.git_blob_create_fromstream(out writestream_ptr, repo, hintpath));

return writestream_ptr;

}

public static unsafe ObjectId git_blob_create_fromstream_commit(IntPtr writestream_ptr)

{

var oid = new GitOid();

Ensure.ZeroResult(NativeMethods.git_blob_create_fromstream_commit(ref oid, writestream_ptr));

return oid;

}

public static unsafe ObjectId git_blob_create_fromdisk(RepositoryHandle repo, FilePath path)

{

var oid = new GitOid();

int res = NativeMethods.git_blob_create_fromdisk(ref oid, repo, path);

Ensure.ZeroResult(res);

return oid;

}

public static unsafe ObjectId git_blob_create_fromfile(RepositoryHandle repo, FilePath path)

{

var oid = new GitOid();

int res = NativeMethods.git_blob_create_fromworkdir(ref oid, repo, path);

Ensure.ZeroResult(res);

return oid;

}

public static unsafe UnmanagedMemoryStream git_blob_filtered_content_stream(RepositoryHandle repo, ObjectId id, string path, bool check_for_binary_data)

{

var buf = new GitBuf();

var handle = new ObjectSafeWrapper(id, repo).ObjectPtr;

return new RawContentStream(handle, h =>

{

Ensure.ZeroResult(NativeMethods.git_blob_filtered_content(buf, h, path, check_for_binary_data));

return buf.ptr;

},

h => (long)buf.size,

new[] { buf });

}

public static unsafe UnmanagedMemoryStream git_blob_rawcontent_stream(RepositoryHandle repo, ObjectId id, Int64 size)

{

var handle = new ObjectSafeWrapper(id, repo).ObjectPtr;

return new RawContentStream(handle, h => NativeMethods.git_blob_rawcontent(h), h => size);

}

public static unsafe long git_blob_rawsize(ObjectHandle obj)

{

return NativeMethods.git_blob_rawsize(obj);

}

public static unsafe bool git_blob_is_binary(ObjectHandle obj)

{

int res = NativeMethods.git_blob_is_binary(obj);

Ensure.BooleanResult(res);

return (res == 1);

}

#endregion

#region git_branch_

public static unsafe ReferenceHandle git_branch_create_from_annotated(RepositoryHandle repo, string branch_name, string targetIdentifier, bool force)

{

git_reference* reference;

using (var annotatedCommit = git_annotated_commit_from_revspec(repo, targetIdentifier))

{

int res = NativeMethods.git_branch_create_from_annotated(out reference, repo, branch_name, annotatedCommit, force);

Ensure.ZeroResult(res);

}

return new ReferenceHandle(reference, true);

}

public static unsafe void git_branch_delete(ReferenceHandle reference)

{

int res = NativeMethods.git_branch_delete(reference);

Ensure.ZeroResult(res);

}

public static IEnumerable<Branch> git_branch_iterator(Repository repo, GitBranchType branchType)

{

IntPtr iter;

var res = NativeMethods.git_branch_iterator_new(out iter, repo.Handle.AsIntPtr(), branchType);

Ensure.ZeroResult(res);

try

{

while (true)

{

IntPtr refPtr = IntPtr.Zero;

GitBranchType _branchType;

res = NativeMethods.git_branch_next(out refPtr, out _branchType, iter);

if (res == (int)GitErrorCode.IterOver)

{

yield break;

}

Ensure.ZeroResult(res);

Reference reference;

using (var refHandle = new ReferenceHandle(refPtr, true))

{

reference = Reference.BuildFromPtr<Reference>(refHandle, repo);

}

yield return new Branch(repo, reference, reference.CanonicalName);

}

}

finally

{

NativeMethods.git_branch_iterator_free(iter);

}

}

public static void git_branch_iterator_free(IntPtr iter)

{

NativeMethods.git_branch_iterator_free(iter);

}

public static unsafe ReferenceHandle git_branch_move(ReferenceHandle reference, string new_branch_name, bool force)

{

git_reference* ref_out;

int res = NativeMethods.git_branch_move(out ref_out, reference, new_branch_name, force);

Ensure.ZeroResult(res);

return new ReferenceHandle(ref_out, true);

}

public static unsafe string git_branch_remote_name(RepositoryHandle repo, string canonical_branch_name, bool shouldThrowIfNotFound)

{

using (var buf = new GitBuf())

{

int res = NativeMethods.git_branch_remote_name(buf, repo, canonical_branch_name);

if (!shouldThrowIfNotFound &&

(res == (int)GitErrorCode.NotFound || res == (int)GitErrorCode.Ambiguous))

{

return null;

}

Ensure.ZeroResult(res);

return LaxUtf8Marshaler.FromNative(buf.ptr);

}

}

public static unsafe string git_branch_upstream_name(RepositoryHandle handle, string canonicalReferenceName)

{

using (var buf = new GitBuf())

{

int res = NativeMethods.git_branch_upstream_name(buf, handle, canonicalReferenceName);

if (res == (int)GitErrorCode.NotFound)

{

return null;

}

Ensure.ZeroResult(res);

return LaxUtf8Marshaler.FromNative(buf.ptr);

}

}

#endregion

#region git_buf_

public static void git_buf_free(GitBuf buf)

{

NativeMethods.git_buf_free(buf);

}

#endregion

#region git_checkout_

public static unsafe void git_checkout_tree(

RepositoryHandle repo,

ObjectId treeId,

ref GitCheckoutOpts opts)

{

using (var osw = new ObjectSafeWrapper(treeId, repo))

{

int res = NativeMethods.git_checkout_tree(repo, osw.ObjectPtr, ref opts);

Ensure.ZeroResult(res);

}

}

public static unsafe void git_checkout_index(RepositoryHandle repo, ObjectHandle treeish, ref GitCheckoutOpts opts)

{

int res = NativeMethods.git_checkout_index(repo, treeish, ref opts);

Ensure.ZeroResult(res);

}

#endregion

#region git_cherry_pick_

internal static unsafe void git_cherrypick(RepositoryHandle repo, ObjectId commit, GitCherryPickOptions options)

{

using (var nativeCommit = git_object_lookup(repo, commit, GitObjectType.Commit))

{

int res = NativeMethods.git_cherrypick(repo, nativeCommit, options);

Ensure.ZeroResult(res);

}

}

internal static unsafe IndexHandle git_cherrypick_commit(RepositoryHandle repo, ObjectHandle cherrypickCommit, ObjectHandle ourCommit, uint mainline, GitMergeOpts opts, out bool earlyStop)

{

git_index* index;

int res = NativeMethods.git_cherrypick_commit(out index, repo, cherrypickCommit, ourCommit, mainline, ref opts);

if (res == (int)GitErrorCode.MergeConflict)

{

earlyStop = true;

}

else

{

earlyStop = false;

Ensure.ZeroResult(res);

}

return new IndexHandle(index, true);

}

#endregion

#region git_clone_

public static unsafe RepositoryHandle git_clone(

string url,

string workdir,

ref GitCloneOptions opts)

{

git_repository *repo;

int res = NativeMethods.git_clone(out repo, url, workdir, ref opts);

Ensure.ZeroResult(res);

return new RepositoryHandle(repo, true);

}

#endregion

#region git_commit_

public static unsafe Signature git_commit_author(ObjectHandle obj)

{

return new Signature(NativeMethods.git_commit_author(obj));

}

public static unsafe Signature git_commit_committer(ObjectHandle obj)

{

return new Signature(NativeMethods.git_commit_committer(obj));

}

public static unsafe ObjectId git_commit_create(

RepositoryHandle repo,

string referenceName,

Signature author,

Signature committer,

string message,

Tree tree,

GitOid[] parentIds)

{

using (SignatureHandle authorHandle = author.BuildHandle())

using (SignatureHandle committerHandle = committer.BuildHandle())

using (var parentPtrs = new ArrayMarshaler<GitOid>(parentIds))

{

GitOid commitOid;

var treeOid = tree.Id.Oid;

int res = NativeMethods.git_commit_create_from_ids(out commitOid,

repo,

referenceName,

authorHandle,

committerHandle,

null,

message,

ref treeOid,

(UIntPtr)parentPtrs.Count,

parentPtrs.ToArray());

Ensure.ZeroResult(res);

return commitOid;

}

}

public static unsafe string git_commit_create_buffer(

RepositoryHandle repo,

Signature author,

Signature committer,

string message,

Tree tree,

Commit[] parents)

{

using (SignatureHandle authorHandle = author.BuildHandle())

using (SignatureHandle committerHandle = committer.BuildHandle())

using (var treeHandle = Proxy.git_object_lookup(tree.repo.Handle, tree.Id, GitObjectType.Tree))

using (var buf = new GitBuf())

{

ObjectHandle[] handles = new ObjectHandle[0];

try

{

handles = parents.Select(c => Proxy.git_object_lookup(c.repo.Handle, c.Id, GitObjectType.Commit)).ToArray();

var ptrs = handles.Select(p => p.AsIntPtr()).ToArray();

int res;

fixed(IntPtr* objs = ptrs)

{

res = NativeMethods.git_commit_create_buffer(buf,

repo,

authorHandle,

committerHandle,

null,

message,

treeHandle,

new UIntPtr((ulong)parents.LongCount()),

objs);

}

Ensure.ZeroResult(res);

}

finally

{

foreach (var handle in handles)

{

handle.Dispose();

}

}

return LaxUtf8Marshaler.FromNative(buf.ptr);

}

}

public static unsafe ObjectId git_commit_create_with_signature(RepositoryHandle repo, string commitContent,

string signature, string field)

{

GitOid id;

int res = NativeMethods.git_commit_create_with_signature(out id, repo, commitContent, signature, field);

Ensure.ZeroResult(res);

return id;

}

public static unsafe string git_commit_message(ObjectHandle obj)

{

return NativeMethods.git_commit_message(obj);

}

public static unsafe string git_commit_summary(ObjectHandle obj)

{

return NativeMethods.git_commit_summary(obj);

}

public static unsafe string git_commit_message_encoding(ObjectHandle obj)

{

return NativeMethods.git_commit_message_encoding(obj);

}

public static unsafe ObjectId git_commit_parent_id(ObjectHandle obj, uint i)

{

return ObjectId.BuildFromPtr(NativeMethods.git_commit_parent_id(obj, i));

}

public static int git_commit_parentcount(RepositoryHandle repo, ObjectId id)

{

using (var obj = new ObjectSafeWrapper(id, repo))

{

return git_commit_parentcount(obj);

}

}

public static unsafe int git_commit_parentcount(ObjectSafeWrapper obj)

{

return (int)NativeMethods.git_commit_parentcount(obj.ObjectPtr);

}

public static unsafe ObjectId git_commit_tree_id(ObjectHandle obj)

{

return ObjectId.BuildFromPtr(NativeMethods.git_commit_tree_id(obj));

}

public static unsafe SignatureInfo git_commit_extract_signature(RepositoryHandle repo, ObjectId id, string field)

{

using (var signature = new GitBuf())

using (var signedData = new GitBuf())

{

var oid = id.Oid;

Ensure.ZeroResult(NativeMethods.git_commit_extract_signature(signature, signedData, repo, ref oid, field));

return new SignatureInfo()

{

Signature = LaxUtf8Marshaler.FromNative(signature.ptr, signature.size.ConvertToInt()),

SignedData = LaxUtf8Marshaler.FromNative(signedData.ptr, signedData.size.ConvertToInt()),

};

}

}

#endregion

#region git_config_

public static unsafe void git_config_add_file_ondisk(ConfigurationHandle config, FilePath path, ConfigurationLevel level, RepositoryHandle repo)

{

// RepositoryHandle does implicit cast voodoo that is not null-safe, thus this explicit check

git_repository* repoHandle = (repo != null) ? (git_repository*)repo : null;

int res = NativeMethods.git_config_add_file_ondisk(config, path, (uint)level, repoHandle, true);

Ensure.ZeroResult(res);

}

public static unsafe bool git_config_delete(ConfigurationHandle config, string name)

{

int res = NativeMethods.git_config_delete_entry(config, name);

if (res == (int)GitErrorCode.NotFound)

{

return false;

}

Ensure.ZeroResult(res);

return true;

}

const string anyValue = ".*";

public static unsafe bool git_config_delete_multivar(ConfigurationHandle config, string name)

{

int res = NativeMethods.git_config_delete_multivar(config, name, anyValue);

if (res == (int)GitErrorCode.NotFound)

{

return false;

}

Ensure.ZeroResult(res);

return true;

}

public static FilePath git_config_find_global()

{

return ConvertPath(NativeMethods.git_config_find_global);

}

public static FilePath git_config_find_system()

{

return ConvertPath(NativeMethods.git_config_find_system);

}

public static FilePath git_config_find_xdg()

{

return ConvertPath(NativeMethods.git_config_find_xdg);

}

public static FilePath git_config_find_programdata()

{

return ConvertPath(NativeMethods.git_config_find_programdata);

}

public static unsafe void git_config_free(git_config *config)

{

NativeMethods.git_config_free(config);

}

public static unsafe ConfigurationEntry<T> git_config_get_entry<T>(ConfigurationHandle config, string key)

{

if (!configurationParser.ContainsKey(typeof(T)))

{

throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Generic Argument of type '{0}' is not supported.", typeof(T).FullName));

}

GitConfigEntry* entry = null;

try

{

var res = NativeMethods.git_config_get_entry(out entry, config, key);

if (res == (int)GitErrorCode.NotFound)

{

return null;

}

Ensure.ZeroResult(res);

return new ConfigurationEntry<T>(LaxUtf8Marshaler.FromNative(entry->namePtr),

(T)configurationParser[typeof(T)](LaxUtf8Marshaler.FromNative(entry->valuePtr)),

(ConfigurationLevel)entry->level);

}

finally

{

NativeMethods.git_config_entry_free(entry);

}

}

public static unsafe ConfigurationHandle git_config_new()

{

git_config* handle;

int res = NativeMethods.git_config_new(out handle);

Ensure.ZeroResult(res);

return new ConfigurationHandle(handle, true);

}

public static unsafe ConfigurationHandle git_config_open_level(ConfigurationHandle parent, ConfigurationLevel level)

{

git_config* handle;

int res = NativeMethods.git_config_open_level(out handle, parent, (uint)level);

if (res == (int)GitErrorCode.NotFound)

{

return null;

}

Ensure.ZeroResult(res);

return new ConfigurationHandle(handle, true);

}

public static bool git_config_parse_bool(string value)

{

bool outVal;

var res = NativeMethods.git_config_parse_bool(out outVal, value);

Ensure.ZeroResult(res);

return outVal;

}

public static int git_config_parse_int32(string value)

{

int outVal;

var res = NativeMethods.git_config_parse_int32(out outVal, value);

Ensure.ZeroResult(res);

return outVal;

}

public static long git_config_parse_int64(string value)

{

long outVal;

var res = NativeMethods.git_config_parse_int64(out outVal, value);

Ensure.ZeroResult(res);

return outVal;

}

public static unsafe void git_config_set_bool(ConfigurationHandle config, string name, bool value)

{

int res = NativeMethods.git_config_set_bool(config, name, value);

Ensure.ZeroResult(res);

}

public static unsafe void git_config_set_int32(ConfigurationHandle config, string name, int value)

{

int res = NativeMethods.git_config_set_int32(config, name, value);

Ensure.ZeroResult(res);

}

public static unsafe void git_config_set_int64(ConfigurationHandle config, string name, long value)

{

int res = NativeMethods.git_config_set_int64(config, name, value);

Ensure.ZeroResult(res);

}

public static unsafe void git_config_set_string(ConfigurationHandle config, string name, string value)

{

int res = NativeMethods.git_config_set_string(config, name, value);

Ensure.ZeroResult(res);

}

public static unsafe ICollection<TResult> git_config_foreach<TResult>(

ConfigurationHandle config,

Func<IntPtr, TResult> resultSelector)

{

return git_foreach(resultSelector, c => NativeMethods.git_config_foreach(config, (e, p) => c(e, p), IntPtr.Zero));

}

public static IEnumerable<ConfigurationEntry<string>> git_config_iterator_glob(

ConfigurationHandle config,

string regexp)

{

IntPtr iter;

var res = NativeMethods.git_config_iterator_glob_new(out iter, config.AsIntPtr(), regexp);

Ensure.ZeroResult(res);

try

{

while (true)

{

IntPtr entry;

res = NativeMethods.git_config_next(out entry, iter);

if (res == (int)GitErrorCode.IterOver)

{

yield break;

}

Ensure.ZeroResult(res);

yield return Configuration.BuildConfigEntry(entry);

}

}

finally

{

NativeMethods.git_config_iterator_free(iter);

}

}

public static unsafe ConfigurationHandle git_config_snapshot(ConfigurationHandle config)

{

git_config* handle;

int res = NativeMethods.git_config_snapshot(out handle, config);

Ensure.ZeroResult(res);

return new ConfigurationHandle(handle, true);

}

public static unsafe IntPtr git_config_lock(git_config* config)

{

IntPtr txn;

int res = NativeMethods.git_config_lock(out txn, config);

Ensure.ZeroResult(res);

return txn;

}

#endregion

#region git_cred_

public static void git_cred_free(IntPtr cred)

{

NativeMethods.git_cred_free(cred);

}

#endregion

#region git_describe_

public static unsafe string git_describe_commit(

RepositoryHandle repo,

ObjectId committishId,

DescribeOptions options)

{

Ensure.ArgumentPositiveInt32(options.MinimumCommitIdAbbreviatedSize, "options.MinimumCommitIdAbbreviatedSize");

using (var osw = new ObjectSafeWrapper(committishId, repo))

{

GitDescribeOptions opts = new GitDescribeOptions

{

Version = 1,

DescribeStrategy = options.Strategy,

MaxCandidatesTags = 10,

OnlyFollowFirstParent = options.OnlyFollowFirstParent,

ShowCommitOidAsFallback = options.UseCommitIdAsFallback,

};

DescribeResultHandle describeHandle = null;

try

{

git_describe_result* result;

int res = NativeMethods.git_describe_commit(out result, osw.ObjectPtr, ref opts);

Ensure.ZeroResult(res);

describeHandle = new DescribeResultHandle(result, true);

using (var buf = new GitBuf())

{

GitDescribeFormatOptions formatOptions = new GitDescribeFormatOptions

{

Version = 1,

MinAbbreviatedSize = (uint)options.MinimumCommitIdAbbreviatedSize,

AlwaysUseLongFormat = options.AlwaysRenderLongFormat,

};

res = NativeMethods.git_describe_format(buf, describeHandle, ref formatOptions);

Ensure.ZeroResult(res);

describeHandle.Dispose();

return LaxUtf8Marshaler.FromNative(buf.ptr);

}

}

finally

{

if (describeHandle != null)

{

describeHandle.Dispose();

}

}

}

}

#endregion

#region git_diff_

public static unsafe void git_diff_blobs(

RepositoryHandle repo,

ObjectId oldBlob,

ObjectId newBlob,

GitDiffOptions options,

NativeMethods.git_diff_file_cb fileCallback,

NativeMethods.git_diff_hunk_cb hunkCallback,

NativeMethods.git_diff_line_cb lineCallback)

{

using (var osw1 = new ObjectSafeWrapper(oldBlob, repo, true))

using (var osw2 = new ObjectSafeWrapper(newBlob, repo, true))

{

int res = NativeMethods.git_diff_blobs(osw1.ObjectPtr,

null,

osw2.ObjectPtr,

null,

options,

fileCallback,

null,

hunkCallback,

lineCallback,

IntPtr.Zero);

Ensure.ZeroResult(res);

}

}

public static unsafe void git_diff_foreach(

git_diff* diff,

NativeMethods.git_diff_file_cb fileCallback,

NativeMethods.git_diff_hunk_cb hunkCallback,

NativeMethods.git_diff_line_cb lineCallback)

{

int res = NativeMethods.git_diff_foreach(diff, fileCallback, null, hunkCallback, lineCallback, IntPtr.Zero);

Ensure.ZeroResult(res);

}

public static unsafe DiffHandle git_diff_tree_to_index(

RepositoryHandle repo,

IndexHandle index,

ObjectId oldTree,

GitDiffOptions options)

{

using (var osw = new ObjectSafeWrapper(oldTree, repo, true))

{

git_diff* diff;

int res = NativeMethods.git_diff_tree_to_index(out diff, repo, osw.ObjectPtr, index, options);

Ensure.ZeroResult(res);

return new DiffHandle(diff, true);

}

}

public static unsafe void git_diff_merge(DiffHandle onto, DiffHandle from)

{

int res = NativeMethods.git_diff_merge(onto, from);

Ensure.ZeroResult(res);

}

public static unsafe DiffHandle git_diff_tree_to_tree(

RepositoryHandle repo,

ObjectId oldTree,

ObjectId newTree,

GitDiffOptions options)

{

using (var osw1 = new ObjectSafeWrapper(oldTree, repo, true))

using (var osw2 = new ObjectSafeWrapper(newTree, repo, true))

{

git_diff* diff;

int res = NativeMethods.git_diff_tree_to_tree(out diff, repo, osw1.ObjectPtr, osw2.ObjectPtr, options);

Ensure.ZeroResult(res);

return new DiffHandle(diff, true);

}

}

public static unsafe DiffHandle git_diff_index_to_workdir(

RepositoryHandle repo,

IndexHandle index,

GitDiffOptions options)

{

git_diff* diff;

int res = NativeMethods.git_diff_index_to_workdir(out diff, repo, index, options);

Ensure.ZeroResult(res);

return new DiffHandle(diff, true);

}

public static unsafe DiffHandle git_diff_tree_to_workdir(

RepositoryHandle repo,

ObjectId oldTree,

GitDiffOptions options)

{

using (var osw = new ObjectSafeWrapper(oldTree, repo, true))

{

git_diff* diff;

int res = NativeMethods.git_diff_tree_to_workdir(out diff, repo, osw.ObjectPtr, options);

Ensure.ZeroResult(res);

return new DiffHandle(diff, true);

}

}

public static unsafe void git_diff_find_similar(DiffHandle diff, GitDiffFindOptions options)

{

int res = NativeMethods.git_diff_find_similar(diff, options);

Ensure.ZeroResult(res);

}

public static unsafe int git_diff_num_deltas(DiffHandle diff)

{

return (int)NativeMethods.git_diff_num_deltas(diff);

}

public static unsafe git_diff_delta* git_diff_get_delta(DiffHandle diff, int idx)

{

return NativeMethods.git_diff_get_delta(diff, (UIntPtr)idx);

}

#endregion

#region git_filter_

public static void git_filter_register(string name, IntPtr filterPtr, int priority)

{

int res = NativeMethods.git_filter_register(name, filterPtr, priority);

if (res == (int)GitErrorCode.Exists)

{

throw new EntryExistsException("A filter with the name '{0}' is already registered", name);

}

Ensure.ZeroResult(res);

}

public static void git_filter_unregister(string name)

{

int res = NativeMethods.git_filter_unregister(name);

Ensure.ZeroResult(res);

}

public static unsafe FilterMode git_filter_source_mode(git_filter_source* filterSource)

{

var res = NativeMethods.git_filter_source_mode(filterSource);

return (FilterMode)res;

}

#endregion

#region git_graph_

public static unsafe Tuple<int?, int?> git_graph_ahead_behind(RepositoryHandle repo, Commit first, Commit second)

{

if (first == null || second == null)

{

return new Tuple<int?, int?>(null, null);

}

GitOid oid1 = first.Id.Oid;

GitOid oid2 = second.Id.Oid;

UIntPtr ahead;

UIntPtr behind;

int res = NativeMethods.git_graph_ahead_behind(out ahead, out behind, repo, ref oid1, ref oid2);

Ensure.ZeroResult(res);

return new Tuple<int?, int?>((int)ahead, (int)behind);

}

public static unsafe bool git_graph_descendant_of(RepositoryHandle repo, ObjectId commitId, ObjectId ancestorId)

{

GitOid oid1 = commitId.Oid;

GitOid oid2 = ancestorId.Oid;

int res = NativeMethods.git_graph_descendant_of(repo, ref oid1, ref oid2);

Ensure.BooleanResult(res);

return (res == 1);

}

#endregion

#region git_ignore_

public static unsafe void git_ignore_add_rule(RepositoryHandle repo, string rules)

{

int res = NativeMethods.git_ignore_add_rule(repo, rules);

Ensure.ZeroResult(res);

}

public static unsafe void git_ignore_clear_internal_rules(RepositoryHandle repo)

{

int res = NativeMethods.git_ignore_clear_internal_rules(repo);

Ensure.ZeroResult(res);

}