pj-nodegit 0.27.1 → 0.28.2

package/src/tag.cc

@@ -12,7 +12,6 @@ extern "C" {
 #include "../include/functions/copy.h"
 #include "../include/tag.h"
 #include "nodegit_wrapper.cc"
-#include "../include/async_libgit2_queue_worker.h"
 
   #include "../include/str_array_converter.h"
   #include "../include/oid.h"
@@ -31,41 +30,43 @@ using namespace node;
     // this will cause an error if you have a non-self-freeing object that also needs
     // to save values. Since the object that will eventually free the object has no
     // way of knowing to free these values.
-                                                                                          }
+                                                                                              }
 
-  void GitTag::InitializeComponent(v8::Local<v8::Object> target) {
+  void GitTag::InitializeComponent(v8::Local<v8::Object> target, nodegit::Context *nodegitContext) {
     Nan::HandleScope scope;
 
-    v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction);
+    v8::Local<v8::External> nodegitExternal = Nan::New<v8::External>(nodegitContext);
+    v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction, nodegitExternal);
 
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
     tpl->SetClassName(Nan::New("Tag").ToLocalChecked());
 
-           Nan::SetMethod(tpl, "annotationCreate", AnnotationCreate);
-             Nan::SetMethod(tpl, "create", Create);
-             Nan::SetMethod(tpl, "createFromBuffer", CreateFromBuffer);
-             Nan::SetMethod(tpl, "createLightweight", CreateLightweight);
-             Nan::SetMethod(tpl, "delete", Delete);
-            Nan::SetPrototypeMethod(tpl, "dup", Dup);
-            Nan::SetPrototypeMethod(tpl, "id", Id);
-             Nan::SetMethod(tpl, "list", List);
-             Nan::SetMethod(tpl, "listMatch", ListMatch);
-             Nan::SetMethod(tpl, "lookup", Lookup);
-             Nan::SetMethod(tpl, "lookupPrefix", LookupPrefix);
-            Nan::SetPrototypeMethod(tpl, "message", Message);
-            Nan::SetPrototypeMethod(tpl, "name", Name);
-            Nan::SetPrototypeMethod(tpl, "owner", Owner);
-            Nan::SetPrototypeMethod(tpl, "peel", Peel);
-            Nan::SetPrototypeMethod(tpl, "tagger", Tagger);
-            Nan::SetPrototypeMethod(tpl, "target", Target);
-            Nan::SetPrototypeMethod(tpl, "targetId", TargetId);
-            Nan::SetPrototypeMethod(tpl, "targetType", TargetType);
+           Nan::SetMethod(tpl, "annotationCreate", AnnotationCreate, nodegitExternal);
+             Nan::SetMethod(tpl, "create", Create, nodegitExternal);
+             Nan::SetMethod(tpl, "createFromBuffer", CreateFromBuffer, nodegitExternal);
+             Nan::SetMethod(tpl, "createLightweight", CreateLightweight, nodegitExternal);
+             Nan::SetMethod(tpl, "delete", Delete, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "dup", Dup, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "id", Id, nodegitExternal);
+             Nan::SetMethod(tpl, "list", List, nodegitExternal);
+             Nan::SetMethod(tpl, "listMatch", ListMatch, nodegitExternal);
+             Nan::SetMethod(tpl, "lookup", Lookup, nodegitExternal);
+             Nan::SetMethod(tpl, "lookupPrefix", LookupPrefix, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "message", Message, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "name", Name, nodegitExternal);
+             Nan::SetMethod(tpl, "nameIsValid", NameIsValid, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "owner", Owner, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "peel", Peel, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "tagger", Tagger, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "target", Target, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "targetId", TargetId, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "targetType", TargetType, nodegitExternal);
     
     InitializeTemplate(tpl);
 
-    v8::Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
-    constructor_template.Reset(_constructor_template);
-    Nan::Set(target, Nan::New("Tag").ToLocalChecked(), _constructor_template);
+    v8::Local<Function> constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
+    nodegitContext->SaveToPersistent("GitTag::Template", constructor_template);
+    Nan::Set(target, Nan::New("Tag").ToLocalChecked(), constructor_template);
   }
 
  
@@ -99,15 +100,19 @@ NAN_METHOD(GitTag::AnnotationCreate) {
     return Nan::ThrowError("String message is required.");
   }
 
-  if (info.Length() == 5 || !info[5]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  AnnotationCreateBaton* baton = new AnnotationCreateBaton;
+  AnnotationCreateBaton* baton = new AnnotationCreateBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->oid = (git_oid *)malloc(sizeof(git_oid ));
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
@@ -153,38 +158,36 @@ from_tagger = Nan::ObjectWrap::Unwrap<GitSignature>(Nan::To<v8::Object>(info[3])
 // end convert_from_v8 block
           baton->message = from_message;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[5]));
-  AnnotationCreateWorker *worker = new AnnotationCreateWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("tag_name", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("target", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("tagger", Nan::To<v8::Object>(info[3]).ToLocalChecked());
-        if (!info[4]->IsUndefined() && !info[4]->IsNull())
-          worker->SaveToPersistent("message", Nan::To<v8::Object>(info[4]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  AnnotationCreateWorker *worker = new AnnotationCreateWorker(baton, callback, cleanupHandles);
+
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("tag_name", info[1]);
+              worker->Reference<GitObject>("target", info[2]);
+               worker->Reference<GitSignature>("tagger", info[3]);
+             worker->Reference("message", info[4]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitTag::AnnotationCreateWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->oid
+          ,baton->repo
+          ,baton->tag_name
+          ,baton->target
+          ,baton->tagger
+          ,baton->message
+  );
+
+  return lockMaster;
+}
+
 void GitTag::AnnotationCreateWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->oid
-            ,baton->repo
-            ,baton->tag_name
-            ,baton->target
-            ,baton->tagger
-            ,baton->message
-    );
-
     int result = git_tag_annotation_create(
 baton->oid,baton->repo,baton->tag_name,baton->target,baton->tagger,baton->message  );
 
@@ -194,25 +197,46 @@ baton->oid,baton->repo,baton->tag_name,baton->target,baton->tagger,baton->messag
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitTag::AnnotationCreateWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Tag.annotationCreate").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+
+  delete baton;
 }
 
 void GitTag::AnnotationCreateWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->oid != NULL) {
-        to = GitOid::New(
+        v8ConversionSlot = GitOid::New(
         baton->oid,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+             
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -236,49 +260,15 @@ void GitTag::AnnotationCreateWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("tag_name"));
-              workerArguments.push(GetFromPersistent("target"));
-              workerArguments.push(GetFromPersistent("tagger"));
-              workerArguments.push(GetFromPersistent("message"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -337,15 +327,19 @@ NAN_METHOD(GitTag::Create) {
     return Nan::ThrowError("Number force is required.");
   }
 
-  if (info.Length() == 6 || !info[6]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  CreateBaton* baton = new CreateBaton;
+  CreateBaton* baton = new CreateBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->oid = (git_oid *)malloc(sizeof(git_oid ));
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
@@ -396,40 +390,37 @@ from_tagger = Nan::ObjectWrap::Unwrap<GitSignature>(Nan::To<v8::Object>(info[3])
 // end convert_from_v8 block
           baton->force = from_force;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[6]));
-  CreateWorker *worker = new CreateWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("tag_name", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("target", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("tagger", Nan::To<v8::Object>(info[3]).ToLocalChecked());
-        if (!info[4]->IsUndefined() && !info[4]->IsNull())
-          worker->SaveToPersistent("message", Nan::To<v8::Object>(info[4]).ToLocalChecked());
-        if (!info[5]->IsUndefined() && !info[5]->IsNull())
-          worker->SaveToPersistent("force", Nan::To<v8::Object>(info[5]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  CreateWorker *worker = new CreateWorker(baton, callback, cleanupHandles);
+
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("tag_name", info[1]);
+              worker->Reference<GitObject>("target", info[2]);
+               worker->Reference<GitSignature>("tagger", info[3]);
+             worker->Reference("message", info[4]);
+            worker->Reference("force", info[5]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitTag::CreateWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->oid
+          ,baton->repo
+          ,baton->tag_name
+          ,baton->target
+          ,baton->tagger
+          ,baton->message
+  );
+
+  return lockMaster;
+}
+
 void GitTag::CreateWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->oid
-            ,baton->repo
-            ,baton->tag_name
-            ,baton->target
-            ,baton->tagger
-            ,baton->message
-    );
-
     int result = git_tag_create(
 baton->oid,baton->repo,baton->tag_name,baton->target,baton->tagger,baton->message,baton->force  );
 
@@ -439,25 +430,46 @@ baton->oid,baton->repo,baton->tag_name,baton->target,baton->tagger,baton->messag
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitTag::CreateWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Tag.create").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitTag::CreateWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->oid != NULL) {
-        to = GitOid::New(
+        v8ConversionSlot = GitOid::New(
         baton->oid,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+               
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -481,50 +493,15 @@ void GitTag::CreateWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("tag_name"));
-              workerArguments.push(GetFromPersistent("target"));
-              workerArguments.push(GetFromPersistent("tagger"));
-              workerArguments.push(GetFromPersistent("message"));
-              workerArguments.push(GetFromPersistent("force"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -568,15 +545,19 @@ NAN_METHOD(GitTag::CreateFromBuffer) {
     return Nan::ThrowError("Number force is required.");
   }
 
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  CreateFromBufferBaton* baton = new CreateFromBufferBaton;
+  CreateFromBufferBaton* baton = new CreateFromBufferBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->oid = (git_oid *)malloc(sizeof(git_oid ));
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
@@ -603,31 +584,31 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->force = from_force;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  CreateFromBufferWorker *worker = new CreateFromBufferWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("buffer", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("force", Nan::To<v8::Object>(info[2]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  CreateFromBufferWorker *worker = new CreateFromBufferWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("buffer", info[1]);
+            worker->Reference("force", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitTag::CreateFromBufferWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->oid
+          ,baton->repo
+          ,baton->buffer
+  );
+
+  return lockMaster;
+}
+
 void GitTag::CreateFromBufferWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->oid
-            ,baton->repo
-            ,baton->buffer
-    );
-
     int result = git_tag_create_from_buffer(
 baton->oid,baton->repo,baton->buffer,baton->force  );
 
@@ -637,25 +618,46 @@ baton->oid,baton->repo,baton->buffer,baton->force  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitTag::CreateFromBufferWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Tag.createFromBuffer").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitTag::CreateFromBufferWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->oid != NULL) {
-        to = GitOid::New(
+        v8ConversionSlot = GitOid::New(
         baton->oid,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+         
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -679,47 +681,15 @@ void GitTag::CreateFromBufferWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("buffer"));
-              workerArguments.push(GetFromPersistent("force"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -768,15 +738,19 @@ NAN_METHOD(GitTag::CreateLightweight) {
     return Nan::ThrowError("Number force is required.");
   }
 
-  if (info.Length() == 4 || !info[4]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  CreateLightweightBaton* baton = new CreateLightweightBaton;
+  CreateLightweightBaton* baton = new CreateLightweightBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->oid = (git_oid *)malloc(sizeof(git_oid ));
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
@@ -808,34 +782,33 @@ from_target = Nan::ObjectWrap::Unwrap<GitObject>(Nan::To<v8::Object>(info[2]).To
 // end convert_from_v8 block
           baton->force = from_force;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[4]));
-  CreateLightweightWorker *worker = new CreateLightweightWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("tag_name", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("target", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("force", Nan::To<v8::Object>(info[3]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  CreateLightweightWorker *worker = new CreateLightweightWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("tag_name", info[1]);
+              worker->Reference<GitObject>("target", info[2]);
+             worker->Reference("force", info[3]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitTag::CreateLightweightWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->oid
+          ,baton->repo
+          ,baton->tag_name
+          ,baton->target
+  );
+
+  return lockMaster;
+}
+
 void GitTag::CreateLightweightWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->oid
-            ,baton->repo
-            ,baton->tag_name
-            ,baton->target
-    );
-
     int result = git_tag_create_lightweight(
 baton->oid,baton->repo,baton->tag_name,baton->target,baton->force  );
 
@@ -845,25 +818,46 @@ baton->oid,baton->repo,baton->tag_name,baton->target,baton->force  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitTag::CreateLightweightWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Tag.createLightweight").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitTag::CreateLightweightWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->oid != NULL) {
-        to = GitOid::New(
+        v8ConversionSlot = GitOid::New(
         baton->oid,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+           
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -887,48 +881,15 @@ void GitTag::CreateLightweightWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("tag_name"));
-              workerArguments.push(GetFromPersistent("target"));
-              workerArguments.push(GetFromPersistent("force"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -966,15 +927,19 @@ NAN_METHOD(GitTag::Delete) {
     return Nan::ThrowError("String tag_name is required.");
   }
 
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  DeleteBaton* baton = new DeleteBaton;
+  DeleteBaton* baton = new DeleteBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -995,28 +960,29 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->tag_name = from_tag_name;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  DeleteWorker *worker = new DeleteWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  DeleteWorker *worker = new DeleteWorker(baton, callback, cleanupHandles);
 
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("tag_name", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("tag_name", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitTag::DeleteWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->tag_name
+  );
+
+  return lockMaster;
+}
+
 void GitTag::DeleteWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->tag_name
-    );
-
     int result = git_tag_delete(
 baton->repo,baton->tag_name  );
 
@@ -1026,13 +992,34 @@ baton->repo,baton->tag_name  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitTag::DeleteWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Tag.delete").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+
+  delete baton;
 }
 
 void GitTag::DeleteWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1056,46 +1043,15 @@ void GitTag::DeleteWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("tag_name"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1124,35 +1080,42 @@ void GitTag::DeleteWorker::HandleOKCallback() {
    */
 NAN_METHOD(GitTag::Dup) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  DupBaton* baton = new DupBaton;
+  DupBaton* baton = new DupBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->source = Nan::ObjectWrap::Unwrap<GitTag>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  DupWorker *worker = new DupWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  DupWorker *worker = new DupWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("source", info.This());
+        worker->Reference<GitTag>("source", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitTag::DupWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->source
+  );
+
+  return lockMaster;
+}
+
 void GitTag::DupWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->source
-    );
-
     int result = git_tag_dup(
 &baton->out,baton->source  );
 
@@ -1162,12 +1125,34 @@ void GitTag::DupWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitTag::DupWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Tag.dup").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      free(baton->out);
+
+  delete baton;
 }
 
 void GitTag::DupWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -1179,18 +1164,18 @@ void GitTag::DupWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitTag::New(
+         v8ConversionSlot = GitTag::New(
         baton->out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1214,44 +1199,15 @@ void GitTag::DupWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1268,6 +1224,7 @@ void GitTag::DupWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        free(baton->out);
   }
 
 
@@ -1284,7 +1241,7 @@ NAN_METHOD(GitTag::Id) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitTag>(info.This())->GetValue()
@@ -1299,22 +1256,22 @@ NAN_METHOD(GitTag::Id) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, owners->Length(), info.This());
-          to = GitOid::New(
+          v8ConversionSlot = GitOid::New(
         result,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -1328,15 +1285,19 @@ NAN_METHOD(GitTag::List) {
     return Nan::ThrowError("Repository repo is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ListBaton* baton = new ListBaton;
+  ListBaton* baton = new ListBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->tag_names = (git_strarray *)malloc(sizeof(git_strarray ));
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
@@ -1344,26 +1305,28 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->repo = from_repo;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  ListWorker *worker = new ListWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ListWorker *worker = new ListWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+  
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitTag::ListWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->tag_names
+          ,baton->repo
+  );
+
+  return lockMaster;
+}
+
 void GitTag::ListWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->tag_names
-            ,baton->repo
-    );
-
     int result = git_tag_list(
 baton->tag_names,baton->repo  );
 
@@ -1373,22 +1336,44 @@ baton->tag_names,baton->repo  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitTag::ListWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Tag.list").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+        free((void*)baton->tag_names);
+
+  delete baton;
 }
 
 void GitTag::ListWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     v8::Local<Array> tmpArray = Nan::New<Array>(baton->tag_names->count);
     for (unsigned int i = 0; i < baton->tag_names->count; i++) {
       Nan::Set(tmpArray, Nan::New<Number>(i), Nan::New<v8::String>(baton->tag_names->strings[i]).ToLocalChecked());
     }
  
-  to = tmpArray;
+  v8ConversionSlot = tmpArray;
  // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1412,45 +1397,15 @@ void GitTag::ListWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1470,7 +1425,6 @@ void GitTag::ListWorker::HandleOKCallback() {
           free((void*)baton->tag_names);
   }
 
-        free((void *)baton->tag_names);
 
   delete baton;
 }
@@ -1491,15 +1445,19 @@ NAN_METHOD(GitTag::ListMatch) {
     return Nan::ThrowError("Repository repo is required.");
   }
 
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ListMatchBaton* baton = new ListMatchBaton;
+  ListMatchBaton* baton = new ListMatchBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->tag_names = (git_strarray *)malloc(sizeof(git_strarray ));
 // start convert_from_v8 block
   const char * from_pattern = NULL;
@@ -1521,29 +1479,30 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[1]).
 // end convert_from_v8 block
           baton->repo = from_repo;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  ListMatchWorker *worker = new ListMatchWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("pattern", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ListMatchWorker *worker = new ListMatchWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+           worker->Reference("pattern", info[0]);
+              worker->Reference<GitRepository>("repo", info[1]);
+  
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitTag::ListMatchWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->tag_names
+          ,baton->pattern
+          ,baton->repo
+  );
+
+  return lockMaster;
+}
+
 void GitTag::ListMatchWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->tag_names
-            ,baton->pattern
-            ,baton->repo
-    );
-
     int result = git_tag_list_match(
 baton->tag_names,baton->pattern,baton->repo  );
 
@@ -1553,22 +1512,44 @@ baton->tag_names,baton->pattern,baton->repo  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitTag::ListMatchWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Tag.listMatch").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+        free((void*)baton->tag_names);
+
+  delete baton;
 }
 
 void GitTag::ListMatchWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     v8::Local<Array> tmpArray = Nan::New<Array>(baton->tag_names->count);
     for (unsigned int i = 0; i < baton->tag_names->count; i++) {
       Nan::Set(tmpArray, Nan::New<Number>(i), Nan::New<v8::String>(baton->tag_names->strings[i]).ToLocalChecked());
     }
  
-  to = tmpArray;
+  v8ConversionSlot = tmpArray;
  // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1592,46 +1573,15 @@ void GitTag::ListMatchWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("pattern"));
-              workerArguments.push(GetFromPersistent("repo"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1651,7 +1601,6 @@ void GitTag::ListMatchWorker::HandleOKCallback() {
           free((void*)baton->tag_names);
   }
 
-        free((void *)baton->tag_names);
 
   delete baton;
 }
@@ -1672,15 +1621,19 @@ NAN_METHOD(GitTag::Lookup) {
     || (!info[1]->IsObject() && !info[1]->IsString())) {
     return Nan::ThrowError("Oid id is required.");
   }
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  LookupBaton* baton = new LookupBaton;
+  LookupBaton* baton = new LookupBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -1712,28 +1665,29 @@ from_id = Nan::ObjectWrap::Unwrap<GitOid>(Nan::To<v8::Object>(info[1]).ToLocalCh
           baton->id = from_id;
             baton->idNeedsFree = info[1]->IsString();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  LookupWorker *worker = new LookupWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  LookupWorker *worker = new LookupWorker(baton, callback, cleanupHandles);
 
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("id", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+               worker->Reference<GitOid>("id", info[1]);
+  
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitTag::LookupWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->id
+  );
+
+  return lockMaster;
+}
+
 void GitTag::LookupWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->id
-    );
-
     int result = git_tag_lookup(
 &baton->out,baton->repo,baton->id  );
 
@@ -1743,12 +1697,38 @@ void GitTag::LookupWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitTag::LookupWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Tag.lookup").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      git_tag_free(baton->out);
+      if (baton->idNeedsFree) {
+        baton->idNeedsFree = false;
+        free((void *)baton->id);
+      }
+
+  delete baton;
 }
 
 void GitTag::LookupWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -1760,18 +1740,18 @@ void GitTag::LookupWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitTag::New(
+         v8ConversionSlot = GitTag::New(
         baton->out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1795,46 +1775,15 @@ void GitTag::LookupWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("id"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1851,6 +1800,7 @@ void GitTag::LookupWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_tag_free(baton->out);
   }
 
       if (baton->idNeedsFree) {
@@ -1882,15 +1832,19 @@ NAN_METHOD(GitTag::LookupPrefix) {
     return Nan::ThrowError("Number len is required.");
   }
 
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  LookupPrefixBaton* baton = new LookupPrefixBaton;
+  LookupPrefixBaton* baton = new LookupPrefixBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -1927,30 +1881,30 @@ from_id = Nan::ObjectWrap::Unwrap<GitOid>(Nan::To<v8::Object>(info[1]).ToLocalCh
 // end convert_from_v8 block
           baton->len = from_len;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  LookupPrefixWorker *worker = new LookupPrefixWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("id", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("len", Nan::To<v8::Object>(info[2]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  LookupPrefixWorker *worker = new LookupPrefixWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+               worker->Reference<GitOid>("id", info[1]);
+             worker->Reference("len", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitTag::LookupPrefixWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->id
+  );
+
+  return lockMaster;
+}
+
 void GitTag::LookupPrefixWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->id
-    );
-
     int result = git_tag_lookup_prefix(
 &baton->out,baton->repo,baton->id,baton->len  );
 
@@ -1960,12 +1914,38 @@ void GitTag::LookupPrefixWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitTag::LookupPrefixWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Tag.lookupPrefix").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+      git_tag_free(baton->out);
+      if (baton->idNeedsFree) {
+        baton->idNeedsFree = false;
+        free((void *)baton->id);
+      }
+
+  delete baton;
 }
 
 void GitTag::LookupPrefixWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -1977,18 +1957,18 @@ void GitTag::LookupPrefixWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitTag::New(
+         v8ConversionSlot = GitTag::New(
         baton->out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+         
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2012,47 +1992,15 @@ void GitTag::LookupPrefixWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("id"));
-              workerArguments.push(GetFromPersistent("len"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2069,6 +2017,7 @@ void GitTag::LookupPrefixWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_tag_free(baton->out);
   }
 
       if (baton->idNeedsFree) {
@@ -2089,7 +2038,7 @@ NAN_METHOD(GitTag::Message) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitTag>(info.This())->GetValue()
@@ -2104,17 +2053,17 @@ NAN_METHOD(GitTag::Message) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
   if (result){
-       to = Nan::New<v8::String>(result).ToLocalChecked();
+       v8ConversionSlot = Nan::New<v8::String>(result).ToLocalChecked();
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
 
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -2127,7 +2076,7 @@ NAN_METHOD(GitTag::Name) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitTag>(info.This())->GetValue()
@@ -2142,17 +2091,75 @@ NAN_METHOD(GitTag::Name) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
   if (result){
-       to = Nan::New<v8::String>(result).ToLocalChecked();
+       v8ConversionSlot = Nan::New<v8::String>(result).ToLocalChecked();
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
+  }
+
+  // end convert_to_v8 block
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
+}
+   
+/*
+ * @param Number valid
+   * @param String name
+     * @return Number  result    */
+NAN_METHOD(GitTag::NameIsValid) {
+  Nan::EscapableHandleScope scope;
+
+  if (info.Length() == 0 || !info[0]->IsNumber()) {
+    return Nan::ThrowError("Number valid is required.");
+  }
+
+  if (info.Length() == 1 || !info[1]->IsString()) {
+    return Nan::ThrowError("String name is required.");
+  }
+
+// start convert_from_v8 block
+  int * from_valid = NULL;
+      *from_valid = (int)   info[0].As<v8::Number>()->Value();
+// end convert_from_v8 block
+// start convert_from_v8 block
+  const char * from_name = NULL;
+
+  Nan::Utf8String name(Nan::To<v8::String>(info[1]).ToLocalChecked());
+  // malloc with one extra byte so we can add the terminating null character C-strings expect:
+  from_name = (const char *) malloc(name.length() + 1);
+  // copy the characters from the nodejs string into our C-string (used instead of strdup or strcpy because nulls in
+  // the middle of strings are valid coming from nodejs):
+  memcpy((void *)from_name, *name, name.length());
+  // ensure the final byte of our new string is null, extra casts added to ensure compatibility with various C types
+  // used in the nodejs binding generation:
+  memset((void *)(((char *)from_name) + name.length()), 0, 1);
+// end convert_from_v8 block
 
+  git_error_clear();
+
+  { // lock master scope start
+    nodegit::LockMaster lockMaster(
+      /*asyncAction: */false
+            ,
+              from_valid
+            ,
+              from_name
+    );
+
+ int result =     git_tag_name_is_valid(
+          from_valid
+,          from_name
+    );
+
+
+      v8::Local<v8::Value> v8ConversionSlot;
+// start convert_to_v8 block
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -2165,7 +2172,7 @@ NAN_METHOD(GitTag::Owner) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitTag>(info.This())->GetValue()
@@ -2180,19 +2187,19 @@ NAN_METHOD(GitTag::Owner) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
-        to = GitRepository::New(
+        v8ConversionSlot = GitRepository::New(
         result,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -2201,35 +2208,42 @@ NAN_METHOD(GitTag::Owner) {
    */
 NAN_METHOD(GitTag::Peel) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  PeelBaton* baton = new PeelBaton;
+  PeelBaton* baton = new PeelBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->tag = Nan::ObjectWrap::Unwrap<GitTag>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  PeelWorker *worker = new PeelWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  PeelWorker *worker = new PeelWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("tag", info.This());
+        worker->Reference<GitTag>("tag", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitTag::PeelWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->tag
+  );
+
+  return lockMaster;
+}
+
 void GitTag::PeelWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->tag
-    );
-
     int result = git_tag_peel(
 &baton->tag_target_out,baton->tag  );
 
@@ -2239,12 +2253,34 @@ void GitTag::PeelWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitTag::PeelWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Tag.peel").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+      git_object_free(baton->tag_target_out);
+
+  delete baton;
 }
 
 void GitTag::PeelWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->tag_target_out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -2256,18 +2292,18 @@ void GitTag::PeelWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitObject::New(
+         v8ConversionSlot = GitObject::New(
         baton->tag_target_out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2291,44 +2327,15 @@ void GitTag::PeelWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2345,6 +2352,7 @@ void GitTag::PeelWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_object_free(baton->tag_target_out);
   }
 
 
@@ -2361,7 +2369,7 @@ NAN_METHOD(GitTag::Tagger) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitTag>(info.This())->GetValue()
@@ -2376,22 +2384,22 @@ NAN_METHOD(GitTag::Tagger) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, owners->Length(), info.This());
-          to = GitSignature::New(
+          v8ConversionSlot = GitSignature::New(
         result,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -2400,35 +2408,42 @@ NAN_METHOD(GitTag::Tagger) {
    */
 NAN_METHOD(GitTag::Target) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  TargetBaton* baton = new TargetBaton;
+  TargetBaton* baton = new TargetBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->tag = Nan::ObjectWrap::Unwrap<GitTag>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  TargetWorker *worker = new TargetWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  TargetWorker *worker = new TargetWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("tag", info.This());
+        worker->Reference<GitTag>("tag", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitTag::TargetWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->tag
+  );
+
+  return lockMaster;
+}
+
 void GitTag::TargetWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->tag
-    );
-
     int result = git_tag_target(
 &baton->target_out,baton->tag  );
 
@@ -2438,12 +2453,34 @@ void GitTag::TargetWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitTag::TargetWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Tag.target").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+      git_object_free(baton->target_out);
+
+  delete baton;
 }
 
 void GitTag::TargetWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->target_out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -2455,18 +2492,18 @@ void GitTag::TargetWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitObject::New(
+         v8ConversionSlot = GitObject::New(
         baton->target_out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2490,44 +2527,15 @@ void GitTag::TargetWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2544,6 +2552,7 @@ void GitTag::TargetWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_object_free(baton->target_out);
   }
 
 
@@ -2560,7 +2569,7 @@ NAN_METHOD(GitTag::TargetId) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitTag>(info.This())->GetValue()
@@ -2575,22 +2584,22 @@ NAN_METHOD(GitTag::TargetId) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, owners->Length(), info.This());
-          to = GitOid::New(
+          v8ConversionSlot = GitOid::New(
         result,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -2603,7 +2612,7 @@ NAN_METHOD(GitTag::TargetType) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitTag>(info.This())->GetValue()
@@ -2614,11 +2623,11 @@ NAN_METHOD(GitTag::TargetType) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
     // force base class template instantiation, to make sure we get all the