Merge commit 'refs/pull/48/head' of github.com:libgit2/git2go

odb.go

@@ -5,18 +5,49 @@ package git
 #include <git2/errors.h>
 
 extern int _go_git_odb_foreach(git_odb *db, void *payload);
+extern void _go_git_odb_backend_free(git_odb_backend *backend);
 */
 import "C"
 import (
-	"unsafe"
 	"reflect"
 	"runtime"
+	"unsafe"
 )
 
 type Odb struct {
 	ptr *C.git_odb
 }
 
+type OdbBackend struct {
+	ptr *C.git_odb_backend
+}
+
+func NewOdb() (odb *Odb, err error) {
+	odb = new(Odb)
+
+	ret := C.git_odb_new(&odb.ptr)
+	if ret < 0 {
+		return nil, MakeGitError(ret)
+	}
+
+	runtime.SetFinalizer(odb, (*Odb).Free)
+	return odb, nil
+}
+
+func NewOdbBackendFromC(ptr *C.git_odb_backend) (backend *OdbBackend) {
+	backend = &OdbBackend{ptr}
+	return backend
+}
+
+func (v *Odb) AddBackend(backend *OdbBackend, priority int) (err error) {
+	ret := C.git_odb_add_backend(v.ptr, backend.ptr, C.int(priority))
+	if ret < 0 {
+		backend.Free()
+		return MakeGitError(ret)
+	}
+	return nil
+}
+
 func (v *Odb) Exists(oid *Oid) bool {
 	ret := C.git_odb_exists(v.ptr, oid.toC())
 	return ret != 0
@@ -32,10 +63,10 @@ func (v *Odb) Write(data []byte, otype ObjectType) (oid *Oid, err error) {
 	ret := C.git_odb_write(oid.toC(), v.ptr, unsafe.Pointer(hdr.Data), C.size_t(hdr.Len), C.git_otype(otype))
 
 	if ret < 0 {
-		err = MakeGitError(ret)
+		return nil, MakeGitError(ret)
 	}
 
-	return
+	return oid, nil
 }
 
 func (v *Odb) Read(oid *Oid) (obj *OdbObject, err error) {
@@ -50,7 +81,7 @@ func (v *Odb) Read(oid *Oid) (obj *OdbObject, err error) {
 	}
 
 	runtime.SetFinalizer(obj, (*OdbObject).Free)
-	return
+	return obj, nil
 }
 
 //export odbForEachCb
@@ -63,9 +94,9 @@ func odbForEachCb(id *C.git_oid, payload unsafe.Pointer) int {
 	select {
 	case ch <- oid:
 	case <-ch:
-			return -1
+		return -1
 	}
-	return 0;
+	return 0
 }
 
 func (v *Odb) forEachWrap(ch chan *Oid) {
@@ -90,9 +121,9 @@ func (v *Odb) Hash(data []byte, otype ObjectType) (oid *Oid, err error) {
 
 	ret := C.git_odb_hash(oid.toC(), ptr, C.size_t(header.Len), C.git_otype(otype));
 	if ret < 0 {
-		err = MakeGitError(ret)
+		return nil, MakeGitError(ret)
 	}
-	return
+	return oid, nil
 }
 
 // NewReadStream opens a read stream from the ODB. Reading from it will give you the
@@ -122,6 +153,10 @@ func (v *Odb) NewWriteStream(size int, otype ObjectType) (*OdbWriteStream, error
 	return stream, nil
 }
 
+func (v *OdbBackend) Free() {
+	C._go_git_odb_backend_free(v.ptr)
+}
+
 type OdbObject struct {
 	ptr *C.git_odb_object
 }
@@ -185,7 +220,7 @@ func (stream *OdbReadStream) Free() {
 
 type OdbWriteStream struct {
 	ptr *C.git_odb_stream
-	Id Oid
+	Id  Oid
 }
 
 // Write writes to the stream

refdb.go

@@ -0,0 +1,51 @@
+package git
+
+/*
+#include <git2.h>
+#include <git2/errors.h>
+#include <git2/sys/refdb_backend.h>
+
+extern void _go_git_refdb_backend_free(git_refdb_backend *backend);
+*/
+import "C"
+import (
+	"runtime"
+)
+
+type Refdb struct {
+	ptr *C.git_refdb
+}
+
+type RefdbBackend struct {
+	ptr *C.git_refdb_backend
+}
+
+func (v *Repository) NewRefdb() (refdb *Refdb, err error) {
+	refdb = new(Refdb)
+
+	ret := C.git_refdb_new(&refdb.ptr, v.ptr)
+	if ret < 0 {
+		return nil, MakeGitError(ret)
+	}
+
+	runtime.SetFinalizer(refdb, (*Refdb).Free)
+	return refdb, nil
+}
+
+func NewRefdbBackendFromC(ptr *C.git_refdb_backend) (backend *RefdbBackend) {
+	backend = &RefdbBackend{ptr}
+	return backend
+}
+
+func (v *Refdb) SetBackend(backend *RefdbBackend) (err error) {
+	ret := C.git_refdb_set_backend(v.ptr, backend.ptr)
+	if ret < 0 {
+		backend.Free()
+		return MakeGitError(ret)
+	}
+	return nil
+}
+
+func (v *RefdbBackend) Free() {
+	C._go_git_refdb_backend_free(v.ptr)
+}

repository.go

@@ -2,7 +2,7 @@ package git
 
 /*
 #include <git2.h>
-#include <git2/errors.h>
+#include <git2/sys/repository.h>
 */
 import "C"
 import (
@@ -51,6 +51,22 @@ func InitRepository(path string, isbare bool) (*Repository, error) {
 	return repo, nil
 }
 
+func NewRepositoryWrapOdb(odb *Odb) (repo *Repository, err error) {
+	repo = new(Repository)
+
+	ret := C.git_repository_wrap_odb(&repo.ptr, odb.ptr)
+	if ret < 0 {
+		return nil, MakeGitError(ret)
+	}
+
+	runtime.SetFinalizer(repo, (*Repository).Free)
+	return repo, nil
+}
+
+func (v *Repository) SetRefdb(refdb *Refdb) {
+	C.git_repository_set_refdb(v.ptr, refdb.ptr)
+}
+
 func (v *Repository) Free() {
 	runtime.SetFinalizer(v, nil)
 	C.git_repository_free(v.ptr)
@@ -270,6 +286,11 @@ func (v *Odb) Free() {
 	C.git_odb_free(v.ptr)
 }
 
+func (v *Refdb) Free() {
+	runtime.SetFinalizer(v, nil)
+	C.git_refdb_free(v.ptr)
+}
+
 func (v *Repository) Odb() (odb *Odb, err error) {
 	odb = new(Odb)
 
@@ -281,7 +302,7 @@ func (v *Repository) Odb() (odb *Odb, err error) {
 	}
 
 	runtime.SetFinalizer(odb, (*Odb).Free)
-	return
+	return odb, nil
 }
 
 func (repo *Repository) Path() string {

wrapper.c

@@ -1,5 +1,7 @@
 #include "_cgo_export.h"
 #include "git2.h"
+#include "git2/sys/odb_backend.h"
+#include "git2/sys/refdb_backend.h"
 #include "git2/submodule.h"
 #include "git2/pack.h"
 
@@ -25,6 +27,22 @@ int _go_git_odb_foreach(git_odb *db, void *payload)
     return git_odb_foreach(db, (git_odb_foreach_cb)&odbForEachCb, payload);
 }
 
+void _go_git_odb_backend_free(git_odb_backend *backend)
+{
+    if (backend->free)
+      backend->free(backend);
+
+    return;
+}
+
+void _go_git_refdb_backend_free(git_refdb_backend *backend)
+{
+    if (backend->free)
+      backend->free(backend);
+
+    return;
+}
+
 void _go_git_setup_callbacks(git_remote_callbacks *callbacks) {
 	typedef int (*completion_cb)(git_remote_completion_type type, void *data);
 	typedef int (*credentials_cb)(git_cred **cred, const char *url, const char *username_from_url, unsigned int allowed_types,	void *data);