internal static unsafe T BuildFromPtr <T>(git_reference *handle, Repository repo) where T : Reference
{
GitReferenceType type = Proxy.git_reference_type(handle);
string name = Proxy.git_reference_name(handle);
Reference reference;
switch (type)
{
case GitReferenceType.Symbolic:
string targetIdentifier = Proxy.git_reference_symbolic_target(handle);
var targetRef = repo.Refs[targetIdentifier];
reference = new SymbolicReference(repo, name, targetIdentifier, targetRef);
break;
case GitReferenceType.Oid:
ObjectId targetOid = Proxy.git_reference_target(handle);
reference = new DirectReference(name, repo, targetOid);
break;
default:
throw new GitException("Unable to build a new reference from a type '{0}'.", type);
}
return(reference as T);
}
private unsafe DirectReference(git_reference *nativeReference) : base(nativeReference)
{
target = new LazyNative <ObjectId>(() => {
git_oid *oid = libgit2.git_reference_target(NativeReference);
Ensure.NativePointerNotNull(oid);
return(ObjectId.FromNative(*oid));
}, this);
}
internal unsafe Reference(git_reference *nativeReference)
{
Ensure.ArgumentNotNull(nativeReference, "reference");
NativeReference = nativeReference;
name = new LazyNative <string>(() => {
return(Ensure.NativeObjectNotNull(libgit2.git_reference_name(NativeReference)));
}, this);
}
/// <summary>
/// Lookup and return the reference as specified by the given name.
/// </summary>
/// <param name="name">The reference to lookup</param>
/// <returns>The reference specified by the given name</returns>
public unsafe Reference Lookup(string name)
{
Ensure.ArgumentNotNull(name, "name");
git_reference *reference = null;
Ensure.NativeSuccess(() => libgit2.git_reference_lookup(out reference, repository.NativeRepository, name), repository);
Ensure.NativePointerNotNull(reference);
return(Reference.FromNative(reference));
}
public unsafe bool MoveNext()
{
git_reference *reference = null;
int ret = Ensure.NativeCall(() => libgit2.git_reference_next(out reference, nativeIterator), this);
if (ret == (int)git_error_code.GIT_ITEROVER)
{
return(false);
}
Ensure.NativeSuccess(ret);
current = Reference.FromNative(reference);
return(true);
}
internal unsafe static Reference FromNative(git_reference *nativeReference)
{
switch (libgit2.git_reference_type(nativeReference))
{
case git_reference_t.GIT_REFERENCE_DIRECT:
return(DirectReference.FromNative(nativeReference));
case git_reference_t.GIT_REFERENCE_SYMBOLIC:
return(SymbolicReference.FromNative(nativeReference));
}
libgit2.git_reference_free(nativeReference);
throw new InvalidOperationException("unknown reference type");
}
public static extern unsafe int git_repository_head(
out git_reference *reference, git_repository *repo);
public static extern unsafe int git_reference_lookup(
out git_reference *reference,
git_repository *repo,
[MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = Utf8Marshaler.ToNative, MarshalTypeRef = typeof(Utf8Marshaler))] string name);
internal unsafe static new SymbolicReference FromNative(git_reference *nativeReference)
{
return(new SymbolicReference(nativeReference));
}
internal unsafe static new DirectReference FromNative(git_reference *nativeReference)
{
return(new DirectReference(nativeReference));
}
private unsafe SymbolicReference(git_reference *nativeReference) : base(nativeReference)
{
target = new LazyNative <string>(() => {
return(Ensure.NativeObjectNotNull(libgit2.git_reference_symbolic_target(NativeReference)));
}, this);
}
internal ReferenceHandle(git_reference *ptr, bool owned)
: base((void *)ptr, owned)
{
}
public static extern unsafe string git_reference_name(git_reference *reference);
public static extern unsafe void git_reference_free(git_reference *reference);
public static extern unsafe int git_reference_next(out git_reference *reference, git_reference_iterator *iterator);
public static extern unsafe git_reference_t git_reference_type(git_reference *reference);
public static extern unsafe git_oid *git_reference_target(git_reference *reference);
public static extern unsafe string git_reference_symbolic_target(git_reference *reference);
