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, 23 insertions, 253 deletions

diff --git a/src/object.c b/src/object.c
index c432c6da0..0572663eb 100644
--- a/src/object.c
+++ b/src/object.c
@@ -66,153 +66,6 @@ static struct {
 	{ "REF_DELTA", 0, 0	}
 };
 
-/*
- * Object source methods
- *
- * Abstract buffer methods that allow the writeback system
- * to prepare the contents of any git file in-memory before
- * writing them to disk.
- */
-static int source_resize(git_odb_source *src)
-{
-	size_t write_offset, new_size;
-	void *new_data;
-
-	write_offset = (size_t)((char *)src->write_ptr - (char *)src->raw.data);
-
-	new_size = src->raw.len * 2;
-	if ((new_data = git__malloc(new_size)) == NULL)
-		return GIT_ENOMEM;
-
-	memcpy(new_data, src->raw.data, src->written_bytes);
-	free(src->raw.data);
-
-	src->raw.data = new_data;
-	src->raw.len = new_size;
-	src->write_ptr = (char *)new_data + write_offset;
-
-	return GIT_SUCCESS;
-}
-
-int git__source_printf(git_odb_source *source, const char *format, ...)
-{
-	va_list arglist;
-	int len;
-
-	assert(source->open && source->write_ptr);
-
-	va_start(arglist, format);
-
-	len = vsnprintf(source->write_ptr, source->raw.len - source->written_bytes, format, arglist);
-
-	while (source->written_bytes + len >= source->raw.len) {
-		if (source_resize(source) < GIT_SUCCESS)
-			return GIT_ENOMEM;
-
-		len = vsnprintf(source->write_ptr, source->raw.len - source->written_bytes, format, arglist);
-	}
-
-	source->write_ptr = (char *)source->write_ptr + len;
-	source->written_bytes += len;
-
-	return GIT_SUCCESS;
-}
-
-int git__source_write(git_odb_source *source, const void *bytes, size_t len)
-{
-	assert(source);
-
-	assert(source->open && source->write_ptr);
-
-	while (source->written_bytes + len >= source->raw.len) {
-		if (source_resize(source) < GIT_SUCCESS)
-			return GIT_ENOMEM;
-	}
-
-	memcpy(source->write_ptr, bytes, len);
-	source->write_ptr = (char *)source->write_ptr + len;
-	source->written_bytes += len;
-
-	return GIT_SUCCESS;
-}
-
-static void prepare_write(git_object *object)
-{
-	if (object->source.write_ptr != NULL || object->source.open)
-		git_object__source_close(object);
-
-	/* TODO: proper size calculation */
-	object->source.raw.data = git__malloc(OBJECT_BASE_SIZE);
-	object->source.raw.len = OBJECT_BASE_SIZE;
-
-	object->source.write_ptr = object->source.raw.data;
-	object->source.written_bytes = 0;
-
-	object->source.open = 1;
-}
-
-static int write_back(git_object *object)
-{
-	int error;
-	git_oid new_id;
-
-	assert(object);
-
-	assert(object->source.open);
-	assert(object->modified);
-
-	object->source.raw.len = object->source.written_bytes;
-
-	if ((error = git_odb_write(&new_id, object->repo->db, &object->source.raw)) < GIT_SUCCESS)
-		return error;
-
-	if (object->in_memory) {
-		int idx = git_vector_search(&object->repo->memory_objects, object);
-		git_vector_remove(&object->repo->memory_objects, idx);
-	} else {
-		git_hashtable_remove(object->repo->objects, &object->id);
-	}
-
-	git_oid_cpy(&object->id, &new_id);
-	git_hashtable_insert(object->repo->objects, &object->id, object);
-
-	object->source.write_ptr = NULL;
-	object->source.written_bytes = 0;
-
-	object->modified = 0;
-	object->in_memory = 0;
-
-	git_object__source_close(object);
-	return GIT_SUCCESS;
-}
-
-int git_object__source_open(git_object *object)
-{
-	int error;
-
-	assert(object && !object->in_memory);
-
-	if (object->source.open)
-		git_object__source_close(object);
-
-	error = git_odb_read(&object->source.raw, object->repo->db, &object->id);
-	if (error < GIT_SUCCESS)
-		return error;
-
-	object->source.open = 1;
-	return GIT_SUCCESS;
-}
-
-void git_object__source_close(git_object *object)
-{
-	assert(object);
-
-	if (object->source.open) {
-		git_rawobj_close(&object->source.raw);
-		object->source.open = 0;
-	}
-}
-
 static int create_object(git_object **object_out, git_otype type)
 {
 	git_object *object = NULL;
@@ -225,43 +78,19 @@ static int create_object(git_object **object_out, git_otype type)
 	case GIT_OBJ_COMMIT:
 	case GIT_OBJ_TAG:
 	case GIT_OBJ_BLOB:
+	case GIT_OBJ_TREE:
 		object = git__malloc(git_object__size(type));
 		if (object == NULL)
 			return GIT_ENOMEM;
 		memset(object, 0x0, git_object__size(type));
 		break;
-		
-	case GIT_OBJ_TREE:
-		object = (git_object *)git_tree__new();
-		if (object == NULL)
-			return GIT_ENOMEM;
-		break;
 
 	default:
 		return GIT_EINVALIDTYPE;
 	}
 
-	*object_out = object;
-	return GIT_SUCCESS;
-}
-
-int git_object_new(git_object **object_out, git_repository *repo, git_otype type)
-{
-	git_object *object = NULL;
-	int error;
-
-	assert(object_out && repo);
-
-	if ((error = create_object(&object, type)) < GIT_SUCCESS)
-		return error;
-
-	object->repo = repo;
-	object->in_memory = 1;
-	object->modified = 1;
-
-	object->source.raw.type = type;
+	object->type = type;
 
-	object->lru = ++repo->lru_counter;
 	*object_out = object;
 	return GIT_SUCCESS;
 }
@@ -269,126 +98,77 @@ int git_object_new(git_object **object_out, git_repository *repo, git_otype type
 int git_object_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_otype type)
 {
 	git_object *object = NULL;
-	git_rawobj obj_file;
+	git_odb_object *odb_obj;
 	int error = GIT_SUCCESS;
 
 	assert(repo && object_out && id);
 
-	object = git_hashtable_lookup(repo->objects, id);
+	object = git_cache_get(&repo->objects, id);
 	if (object != NULL) {
-		if (type != GIT_OBJ_ANY && type != object->source.raw.type)
+		if (type != GIT_OBJ_ANY && type != object->type)
 			return GIT_EINVALIDTYPE;
 
 		*object_out = object;
-		object->lru = ++repo->lru_counter;
-		object->can_free = 0;
 		return GIT_SUCCESS;
 	}
 
-	error = git_odb_read(&obj_file, repo->db, id);
+	error = git_odb_read(&odb_obj, repo->db, id);
 	if (error < GIT_SUCCESS)
 		return error;
 
-	if (type != GIT_OBJ_ANY && type != obj_file.type) {
-		git_rawobj_close(&obj_file);
+	if (type != GIT_OBJ_ANY && type != odb_obj->raw.type) {
+		git_odb_object_close(odb_obj);
 		return GIT_EINVALIDTYPE;
 	}
 
-	type = obj_file.type;
+	type = odb_obj->raw.type;
 
 	if ((error = create_object(&object, type)) < GIT_SUCCESS)
 		return error;
 
 	/* Initialize parent object */
-	git_oid_cpy(&object->id, id);
+	git_oid_cpy(&object->cached.oid, id);
 	object->repo = repo;
-	memcpy(&object->source.raw, &obj_file, sizeof(git_rawobj));
-	object->source.open = 1;
 
 	switch (type) {
 	case GIT_OBJ_COMMIT:
-		error = git_commit__parse((git_commit *)object);
+		error = git_commit__parse((git_commit *)object, odb_obj);
 		break;
 
 	case GIT_OBJ_TREE:
-		error = git_tree__parse((git_tree *)object);
+		error = git_tree__parse((git_tree *)object, odb_obj);
 		break;
 
 	case GIT_OBJ_TAG:
-		error = git_tag__parse((git_tag *)object);
+		error = git_tag__parse((git_tag *)object, odb_obj);
 		break;
 
 	case GIT_OBJ_BLOB:
-		error = git_blob__parse((git_blob *)object);
+		error = git_blob__parse((git_blob *)object, odb_obj);
 		break;
 
 	default:
 		break;
 	}
 
+	git_odb_object_close(odb_obj);
+
 	if (error < GIT_SUCCESS) {
 		git_object__free(object);
 		return error;
 	}
 
-	git_object__source_close(object);
-	git_hashtable_insert(repo->objects, &object->id, object);
-
-	object->lru = ++repo->lru_counter;
-	*object_out = object;
+	*object_out = git_cache_try_store(&repo->objects, object);
 	return GIT_SUCCESS;
 }
 
-int git_object_write(git_object *object)
+void git_object__free(void *_obj)
 {
-	int error;
-	git_odb_source *source;
+	git_object *object = (git_object *)_obj;
 
 	assert(object);
 
-	if (object->modified == 0)
-		return GIT_SUCCESS;
-
-	prepare_write(object);
-	source = &object->source;
-
-	switch (source->raw.type) {
-	case GIT_OBJ_COMMIT:
-		error = git_commit__writeback((git_commit *)object, source);
-		break;
-
-	case GIT_OBJ_TREE:
-		error = git_tree__writeback((git_tree *)object, source);
-		break;
-
-	case GIT_OBJ_TAG:
-		error = git_tag__writeback((git_tag *)object, source);
-		break;
-
-	case GIT_OBJ_BLOB:
-		error = git_blob__writeback((git_blob *)object, source);
-		break;
-
-	default:
-		error = GIT_ERROR;
-		break;
-	}
-
-	if (error < GIT_SUCCESS) {
-		git_object__source_close(object);
-		return error;
-	}
-
-	return write_back(object);
-}
-
-void git_object__free(git_object *object)
-{
-	assert(object);
-
-	git_object__source_close(object);
-
-	switch (object->source.raw.type) {
+	switch (object->type) {
 	case GIT_OBJ_COMMIT:
 		git_commit__free((git_commit *)object);
 		break;
@@ -416,29 +196,19 @@ void git_object_close(git_object *object)
 	if (object == NULL)
 		return;
 
-	if (object->in_memory) {
-		int idx = git_vector_search(&object->repo->memory_objects, object);
-		git_vector_remove(&object->repo->memory_objects, idx);
-		git_object__free(object);
-	} else {
-		object->can_free = 1;
-	}
+	git_cached_obj_decref((git_cached_obj *)object, git_object__free);
 }
 
 const git_oid *git_object_id(const git_object *obj)
 {
 	assert(obj);
-
-	if (obj->in_memory)
-		return NULL;
-
-	return &obj->id;
+	return &obj->cached.oid;
 }
 
 git_otype git_object_type(const git_object *obj)
 {
 	assert(obj);
-	return obj->source.raw.type;
+	return obj->type;
 }
 
 git_repository *git_object_owner(const git_object *obj)