I broke your bindings

Hey. Apologies in advance -- I broke your bindings.

This is a major commit that includes a long-overdue redesign of the
whole object-database structure. This is expected to be the last major
external API redesign of the library until the first non-alpha release.

Please get your bindings up to date with these changes. They will be
included in the next minor release. Sorry again!

Major features include:

	- Real caching and refcounting on parsed objects
	- Real caching and refcounting on objects read from the ODB
	- Streaming writes & reads from the ODB
	- Single-method writes for all object types
	- The external API is now partially thread-safe

The speed increases are significant in all aspects, specially when
reading an object several times from the ODB (revwalking) and when
writing big objects to the ODB.

Here's a full changelog for the external API:

blob.h
------

	- Remove `git_blob_new`
	- Remove `git_blob_set_rawcontent`
	- Remove `git_blob_set_rawcontent_fromfile`
	- Rename `git_blob_writefile` -> `git_blob_create_fromfile`
	- Change `git_blob_create_fromfile`:
		The `path` argument is now relative to the repository's working dir
	- Add `git_blob_create_frombuffer`

commit.h
--------

	- Remove `git_commit_new`
	- Remove `git_commit_add_parent`
	- Remove `git_commit_set_message`
	- Remove `git_commit_set_committer`
	- Remove `git_commit_set_author`
	- Remove `git_commit_set_tree`

	- Add `git_commit_create`
	- Add `git_commit_create_v`
	- Add `git_commit_create_o`
	- Add `git_commit_create_ov`

tag.h
-----

	- Remove `git_tag_new`
	- Remove `git_tag_set_target`
	- Remove `git_tag_set_name`
	- Remove `git_tag_set_tagger`
	- Remove `git_tag_set_message`

	- Add `git_tag_create`
	- Add `git_tag_create_o`

tree.h
------

	- Change `git_tree_entry_2object`:
		New signature is `(git_object **object_out, git_repository *repo, git_tree_entry *entry)`

	- Remove `git_tree_new`
	- Remove `git_tree_add_entry`
	- Remove `git_tree_remove_entry_byindex`
	- Remove `git_tree_remove_entry_byname`
	- Remove `git_tree_clearentries`
	- Remove `git_tree_entry_set_id`
	- Remove `git_tree_entry_set_name`
	- Remove `git_tree_entry_set_attributes`

object.h
------------

	- Remove `git_object_new
	- Remove `git_object_write`

	- Change `git_object_close`:
		This method is now *mandatory*. Not closing an object causes a
		memory leak.

odb.h
-----

	- Remove type `git_rawobj`
	- Remove `git_rawobj_close`
	- Rename `git_rawobj_hash` -> `git_odb_hash`
	- Change `git_odb_hash`:
		New signature is `(git_oid *id, const void *data, size_t len, git_otype type)`

	- Add type `git_odb_object`
	- Add `git_odb_object_close`

	- Change `git_odb_read`:
		New signature is `(git_odb_object **out, git_odb *db, const git_oid *id)`
	- Change `git_odb_read_header`:
		New signature is `(size_t *len_p, git_otype *type_p, git_odb *db, const git_oid *id)`
	- Remove `git_odb_write`
	- Add `git_odb_open_wstream`
	- Add `git_odb_open_rstream`

odb_backend.h
-------------

	- Change type `git_odb_backend`:
		New internal signatures are as follows

			int (* read)(void **, size_t *, git_otype *, struct git_odb_backend *, const git_oid *)
			int (* read_header)(size_t *, git_otype *, struct git_odb_backend *, const git_oid *)
			int (* writestream)(struct git_odb_stream **, struct git_odb_backend *, size_t, git_otype)
			int (* readstream)( struct git_odb_stream **, struct git_odb_backend *, const git_oid *)

	- Add type `git_odb_stream`
	- Add enum `git_odb_streammode`

Signed-off-by: Vicent Marti <tanoku@gmail.com>

1 files changed, 45 insertions, 28 deletions

diff --git a/tests/t03-objwrite.c b/tests/t03-objwrite.c
index 10c6c7f1a..773887397 100644
--- a/tests/t03-objwrite.c
+++ b/tests/t03-objwrite.c
@@ -24,6 +24,7 @@
  */
 #include "test_lib.h"
 #include "fileops.h"
+#include "odb.h"
 
 static char *odb_dir = "test-objects";
 #include "t03-data.h"
@@ -80,23 +81,39 @@ static int remove_object_files(object_data *d)
 	return 0;
 }
 
+static int streaming_write(git_oid *oid, git_odb *odb, git_rawobj *raw)
+{
+	git_odb_stream *stream;
+	int error;
+
+	if ((error = git_odb_open_wstream(&stream, odb, raw->len, raw->type)) < GIT_SUCCESS)
+		return error;
+
+	stream->write(stream, raw->data, raw->len);
+
+	error = stream->finalize_write(oid, stream);
+	stream->free(stream);
+
+	return error;
+}
+
 BEGIN_TEST(write0, "write loose commit object")
     git_odb *db;
     git_oid id1, id2;
-    git_rawobj obj;
+    git_odb_object *obj;
 
     must_pass(make_odb_dir());
     must_pass(git_odb_open(&db, odb_dir));
     must_pass(git_oid_mkstr(&id1, commit.id));
 
-    must_pass(git_odb_write(&id2, db, &commit_obj));
+    must_pass(streaming_write(&id2, db, &commit_obj));
     must_be_true(git_oid_cmp(&id1, &id2) == 0);
     must_pass(check_object_files(&commit));
 
     must_pass(git_odb_read(&obj, db, &id1));
-    must_pass(cmp_objects(&obj, &commit_obj));
+    must_pass(cmp_objects(&obj->raw, &commit_obj));
 
-    git_rawobj_close(&obj);
+    git_odb_object_close(obj);
     git_odb_close(db);
     must_pass(remove_object_files(&commit));
 END_TEST
@@ -104,20 +121,20 @@ END_TEST
 BEGIN_TEST(write1, "write loose tree object")
     git_odb *db;
     git_oid id1, id2;
-    git_rawobj obj;
+    git_odb_object *obj;
 
     must_pass(make_odb_dir());
     must_pass(git_odb_open(&db, odb_dir));
     must_pass(git_oid_mkstr(&id1, tree.id));
 
-    must_pass(git_odb_write(&id2, db, &tree_obj));
+    must_pass(streaming_write(&id2, db, &tree_obj));
     must_be_true(git_oid_cmp(&id1, &id2) == 0);
     must_pass(check_object_files(&tree));
 
     must_pass(git_odb_read(&obj, db, &id1));
-    must_pass(cmp_objects(&obj, &tree_obj));
+    must_pass(cmp_objects(&obj->raw, &tree_obj));
 
-    git_rawobj_close(&obj);
+    git_odb_object_close(obj);
     git_odb_close(db);
     must_pass(remove_object_files(&tree));
 END_TEST
@@ -125,20 +142,20 @@ END_TEST
 BEGIN_TEST(write2, "write loose tag object")
     git_odb *db;
     git_oid id1, id2;
-    git_rawobj obj;
+    git_odb_object *obj;
 
     must_pass(make_odb_dir());
     must_pass(git_odb_open(&db, odb_dir));
     must_pass(git_oid_mkstr(&id1, tag.id));
 
-    must_pass(git_odb_write(&id2, db, &tag_obj));
+    must_pass(streaming_write(&id2, db, &tag_obj));
     must_be_true(git_oid_cmp(&id1, &id2) == 0);
     must_pass(check_object_files(&tag));
 
     must_pass(git_odb_read(&obj, db, &id1));
-    must_pass(cmp_objects(&obj, &tag_obj));
+    must_pass(cmp_objects(&obj->raw, &tag_obj));
 
-    git_rawobj_close(&obj);
+    git_odb_object_close(obj);
     git_odb_close(db);
     must_pass(remove_object_files(&tag));
 END_TEST
@@ -146,20 +163,20 @@ END_TEST
 BEGIN_TEST(write3, "write zero-length object")
     git_odb *db;
     git_oid id1, id2;
-    git_rawobj obj;
+    git_odb_object *obj;
 
     must_pass(make_odb_dir());
     must_pass(git_odb_open(&db, odb_dir));
     must_pass(git_oid_mkstr(&id1, zero.id));
 
-    must_pass(git_odb_write(&id2, db, &zero_obj));
+    must_pass(streaming_write(&id2, db, &zero_obj));
     must_be_true(git_oid_cmp(&id1, &id2) == 0);
     must_pass(check_object_files(&zero));
 
     must_pass(git_odb_read(&obj, db, &id1));
-    must_pass(cmp_objects(&obj, &zero_obj));
+    must_pass(cmp_objects(&obj->raw, &zero_obj));
 
-    git_rawobj_close(&obj);
+    git_odb_object_close(obj);
     git_odb_close(db);
     must_pass(remove_object_files(&zero));
 END_TEST
@@ -167,20 +184,20 @@ END_TEST
 BEGIN_TEST(write4, "write one-byte long object")
     git_odb *db;
     git_oid id1, id2;
-    git_rawobj obj;
+    git_odb_object *obj;
 
     must_pass(make_odb_dir());
     must_pass(git_odb_open(&db, odb_dir));
     must_pass(git_oid_mkstr(&id1, one.id));
 
-    must_pass(git_odb_write(&id2, db, &one_obj));
+    must_pass(streaming_write(&id2, db, &one_obj));
     must_be_true(git_oid_cmp(&id1, &id2) == 0);
     must_pass(check_object_files(&one));
 
     must_pass(git_odb_read(&obj, db, &id1));
-    must_pass(cmp_objects(&obj, &one_obj));
+    must_pass(cmp_objects(&obj->raw, &one_obj));
 
-    git_rawobj_close(&obj);
+    git_odb_object_close(obj);
     git_odb_close(db);
     must_pass(remove_object_files(&one));
 END_TEST
@@ -188,20 +205,20 @@ END_TEST
 BEGIN_TEST(write5, "write two-byte long object")
     git_odb *db;
     git_oid id1, id2;
-    git_rawobj obj;
+    git_odb_object *obj;
 
     must_pass(make_odb_dir());
     must_pass(git_odb_open(&db, odb_dir));
     must_pass(git_oid_mkstr(&id1, two.id));
 
-    must_pass(git_odb_write(&id2, db, &two_obj));
+    must_pass(streaming_write(&id2, db, &two_obj));
     must_be_true(git_oid_cmp(&id1, &id2) == 0);
     must_pass(check_object_files(&two));
 
     must_pass(git_odb_read(&obj, db, &id1));
-    must_pass(cmp_objects(&obj, &two_obj));
+    must_pass(cmp_objects(&obj->raw, &two_obj));
 
-    git_rawobj_close(&obj);
+    git_odb_object_close(obj);
     git_odb_close(db);
     must_pass(remove_object_files(&two));
 END_TEST
@@ -209,20 +226,20 @@ END_TEST
 BEGIN_TEST(write6, "write an object which is several bytes long")
     git_odb *db;
     git_oid id1, id2;
-    git_rawobj obj;
+    git_odb_object *obj;
 
     must_pass(make_odb_dir());
     must_pass(git_odb_open(&db, odb_dir));
     must_pass(git_oid_mkstr(&id1, some.id));
 
-    must_pass(git_odb_write(&id2, db, &some_obj));
+    must_pass(streaming_write(&id2, db, &some_obj));
     must_be_true(git_oid_cmp(&id1, &id2) == 0);
     must_pass(check_object_files(&some));
 
     must_pass(git_odb_read(&obj, db, &id1));
-    must_pass(cmp_objects(&obj, &some_obj));
+    must_pass(cmp_objects(&obj->raw, &some_obj));
 
-    git_rawobj_close(&obj);
+    git_odb_object_close(obj);
     git_odb_close(db);
     must_pass(remove_object_files(&some));
 END_TEST