pj-nodegit 0.27.0 → 0.28.1

package/include/submodule.h

@@ -4,15 +4,21 @@
 #define GITSUBMODULE_H
 #include <nan.h>
 #include <string>
-#include <queue>
 #include <utility>
-#include <unordered_map>
+#include <algorithm>
+#include <set>
+#include <unordered_set>
 #include <sstream>
 
 #include "async_baton.h"
+#include "async_worker.h"
+#include "cleanup_handle.h"
+#include "context.h"
+#include "lock_master.h"
 #include "nodegit_wrapper.h"
 #include "promise_completion.h"
 #include "reference_counter.h"
+#include "worker_pool.h"
 
 extern "C" {
 #include <git2.h>
@@ -32,16 +38,17 @@ using namespace node;
 using namespace v8;
 
 class GitSubmodule;
-
+ 
 struct GitSubmoduleTraits {
   typedef GitSubmodule cppClass;
   typedef git_submodule cType;
-
+ 
   static const bool isDuplicable = false;
   static void duplicate(git_submodule **dest, git_submodule *src) {
      Nan::ThrowError("duplicate called on GitSubmodule which cannot be duplicated");
    }
 
+  static std::string className() { return "GitSubmodule"; };
   static const bool isSingleton = false;
   static const bool isFreeable = true;
   static void free(git_submodule *raw) {
@@ -58,7 +65,12 @@ class GitSubmodule : public
     // grant full access to base class
     friend class NodeGitWrapper<GitSubmoduleTraits>;
    public:
-    static void InitializeComponent (v8::Local<v8::Object> target);
+    GitSubmodule(const GitSubmodule &) = delete;
+    GitSubmodule(GitSubmodule &&) = delete;
+    GitSubmodule &operator=(const GitSubmodule &) = delete;
+    GitSubmodule &operator=(GitSubmodule &&) = delete;
+
+    static void InitializeComponent (v8::Local<v8::Object> target, nodegit::Context *nodegitContext);
 
                               static int Foreach_callback_cppCallback (
       git_submodule * sm
@@ -68,15 +80,18 @@ class GitSubmodule : public
        void * payload
       );
 
+    static void Foreach_callback_cancelAsync(void *baton);
     static void Foreach_callback_async(void *baton);
-    static void Foreach_callback_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result);
-    struct Foreach_CallbackBaton : public AsyncBatonWithResult<int> {
+    static void Foreach_callback_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result);
+    class Foreach_CallbackBaton : public nodegit::AsyncBatonWithResult<int> {
+    public:
       git_submodule * sm;
       const char * name;
       void * payload;
  
+
       Foreach_CallbackBaton(const int &defaultResult)
-        : AsyncBatonWithResult<int>(defaultResult) {
+        : nodegit::AsyncBatonWithResult<int>(defaultResult) {
         }
     };
                                                                                                       
@@ -91,22 +106,29 @@ class GitSubmodule : public
       : NodeGitWrapper<GitSubmoduleTraits>(raw, selfFreeing, owner)
     {}
     ~GitSubmodule();
-                                                                                                                                
+
     struct AddFinalizeBaton {
       int error_code;
       const git_error* error;
       git_submodule * submodule;
-    };
-    class AddFinalizeWorker : public Nan::AsyncWorker {
+     };
+    class AddFinalizeWorker : public nodegit::AsyncWorker {
       public:
         AddFinalizeWorker(
             AddFinalizeBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:AddFinalize", cleanupHandles)
           , baton(_baton) {};
+        AddFinalizeWorker(const AddFinalizeWorker &) = delete;
+        AddFinalizeWorker(AddFinalizeWorker &&) = delete;
+        AddFinalizeWorker &operator=(const AddFinalizeWorker &) = delete;
+        AddFinalizeWorker &operator=(AddFinalizeWorker &&) = delete;
         ~AddFinalizeWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         AddFinalizeBaton *baton;
@@ -122,17 +144,24 @@ class GitSubmodule : public
       const char * url;
       const char * path;
       int use_gitlink;
-    };
-    class AddSetupWorker : public Nan::AsyncWorker {
+     };
+    class AddSetupWorker : public nodegit::AsyncWorker {
       public:
         AddSetupWorker(
             AddSetupBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:AddSetup", cleanupHandles)
           , baton(_baton) {};
+        AddSetupWorker(const AddSetupWorker &) = delete;
+        AddSetupWorker(AddSetupWorker &&) = delete;
+        AddSetupWorker &operator=(const AddSetupWorker &) = delete;
+        AddSetupWorker &operator=(AddSetupWorker &&) = delete;
         ~AddSetupWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         AddSetupBaton *baton;
@@ -145,17 +174,24 @@ class GitSubmodule : public
       const git_error* error;
       git_submodule * submodule;
       int write_index;
-    };
-    class AddToIndexWorker : public Nan::AsyncWorker {
+     };
+    class AddToIndexWorker : public nodegit::AsyncWorker {
       public:
         AddToIndexWorker(
             AddToIndexBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:AddToIndex", cleanupHandles)
           , baton(_baton) {};
+        AddToIndexWorker(const AddToIndexWorker &) = delete;
+        AddToIndexWorker(AddToIndexWorker &&) = delete;
+        AddToIndexWorker &operator=(const AddToIndexWorker &) = delete;
+        AddToIndexWorker &operator=(AddToIndexWorker &&) = delete;
         ~AddToIndexWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         AddToIndexBaton *baton;
@@ -171,17 +207,24 @@ class GitSubmodule : public
       git_repository * out;
       git_submodule * submodule;
       const git_submodule_update_options * opts;
-    };
-    class CloneWorker : public Nan::AsyncWorker {
+     };
+    class CloneWorker : public nodegit::AsyncWorker {
       public:
         CloneWorker(
             CloneBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:Clone", cleanupHandles)
           , baton(_baton) {};
+        CloneWorker(const CloneWorker &) = delete;
+        CloneWorker(CloneWorker &&) = delete;
+        CloneWorker &operator=(const CloneWorker &) = delete;
+        CloneWorker &operator=(CloneWorker &&) = delete;
         ~CloneWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         CloneBaton *baton;
@@ -197,17 +240,24 @@ class GitSubmodule : public
       git_repository * repo;
       git_submodule_cb callback;
       void * payload;
-    };
-    class ForeachWorker : public Nan::AsyncWorker {
+     };
+    class ForeachWorker : public nodegit::AsyncWorker {
       public:
         ForeachWorker(
             ForeachBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:Foreach", cleanupHandles)
           , baton(_baton) {};
+        ForeachWorker(const ForeachWorker &) = delete;
+        ForeachWorker(ForeachWorker &&) = delete;
+        ForeachWorker &operator=(const ForeachWorker &) = delete;
+        ForeachWorker &operator=(ForeachWorker &&) = delete;
         ~ForeachWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         ForeachBaton *baton;
@@ -226,17 +276,24 @@ class GitSubmodule : public
       const git_error* error;
       git_submodule * submodule;
       int overwrite;
-    };
-    class InitWorker : public Nan::AsyncWorker {
+     };
+    class InitWorker : public nodegit::AsyncWorker {
       public:
         InitWorker(
             InitBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:Init", cleanupHandles)
           , baton(_baton) {};
+        InitWorker(const InitWorker &) = delete;
+        InitWorker(InitWorker &&) = delete;
+        InitWorker &operator=(const InitWorker &) = delete;
+        InitWorker &operator=(InitWorker &&) = delete;
         ~InitWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         InitBaton *baton;
@@ -249,17 +306,24 @@ class GitSubmodule : public
       const git_error* error;
       unsigned int * location_status;
       git_submodule * submodule;
-    };
-    class LocationWorker : public Nan::AsyncWorker {
+     };
+    class LocationWorker : public nodegit::AsyncWorker {
       public:
         LocationWorker(
             LocationBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:Location", cleanupHandles)
           , baton(_baton) {};
+        LocationWorker(const LocationWorker &) = delete;
+        LocationWorker(LocationWorker &&) = delete;
+        LocationWorker &operator=(const LocationWorker &) = delete;
+        LocationWorker &operator=(LocationWorker &&) = delete;
         ~LocationWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         LocationBaton *baton;
@@ -273,17 +337,24 @@ class GitSubmodule : public
       git_submodule * out;
       git_repository * repo;
       const char * name;
-    };
-    class LookupWorker : public Nan::AsyncWorker {
+     };
+    class LookupWorker : public nodegit::AsyncWorker {
       public:
         LookupWorker(
             LookupBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:Lookup", cleanupHandles)
           , baton(_baton) {};
+        LookupWorker(const LookupWorker &) = delete;
+        LookupWorker(LookupWorker &&) = delete;
+        LookupWorker &operator=(const LookupWorker &) = delete;
+        LookupWorker &operator=(LookupWorker &&) = delete;
         ~LookupWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         LookupBaton *baton;
@@ -298,17 +369,24 @@ class GitSubmodule : public
       const git_error* error;
       git_repository * repo;
       git_submodule * submodule;
-    };
-    class OpenWorker : public Nan::AsyncWorker {
+     };
+    class OpenWorker : public nodegit::AsyncWorker {
       public:
         OpenWorker(
             OpenBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:Open", cleanupHandles)
           , baton(_baton) {};
+        OpenWorker(const OpenWorker &) = delete;
+        OpenWorker(OpenWorker &&) = delete;
+        OpenWorker &operator=(const OpenWorker &) = delete;
+        OpenWorker &operator=(OpenWorker &&) = delete;
         ~OpenWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         OpenBaton *baton;
@@ -328,17 +406,24 @@ class GitSubmodule : public
       git_repository * out;
       const git_submodule * sm;
       int use_gitlink;
-    };
-    class RepoInitWorker : public Nan::AsyncWorker {
+     };
+    class RepoInitWorker : public nodegit::AsyncWorker {
       public:
         RepoInitWorker(
             RepoInitBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:RepoInit", cleanupHandles)
           , baton(_baton) {};
+        RepoInitWorker(const RepoInitWorker &) = delete;
+        RepoInitWorker(RepoInitWorker &&) = delete;
+        RepoInitWorker &operator=(const RepoInitWorker &) = delete;
+        RepoInitWorker &operator=(RepoInitWorker &&) = delete;
         ~RepoInitWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         RepoInitBaton *baton;
@@ -352,17 +437,24 @@ class GitSubmodule : public
       git_buf * out;
       git_repository * repo;
       const char * url;
-    };
-    class ResolveUrlWorker : public Nan::AsyncWorker {
+     };
+    class ResolveUrlWorker : public nodegit::AsyncWorker {
       public:
         ResolveUrlWorker(
             ResolveUrlBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:ResolveUrl", cleanupHandles)
           , baton(_baton) {};
+        ResolveUrlWorker(const ResolveUrlWorker &) = delete;
+        ResolveUrlWorker(ResolveUrlWorker &&) = delete;
+        ResolveUrlWorker &operator=(const ResolveUrlWorker &) = delete;
+        ResolveUrlWorker &operator=(ResolveUrlWorker &&) = delete;
         ~ResolveUrlWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         ResolveUrlBaton *baton;
@@ -380,17 +472,24 @@ class GitSubmodule : public
       git_repository * repo;
       const char * name;
       git_submodule_ignore_t ignore;
-    };
-    class SetIgnoreWorker : public Nan::AsyncWorker {
+     };
+    class SetIgnoreWorker : public nodegit::AsyncWorker {
       public:
         SetIgnoreWorker(
             SetIgnoreBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:SetIgnore", cleanupHandles)
           , baton(_baton) {};
+        SetIgnoreWorker(const SetIgnoreWorker &) = delete;
+        SetIgnoreWorker(SetIgnoreWorker &&) = delete;
+        SetIgnoreWorker &operator=(const SetIgnoreWorker &) = delete;
+        SetIgnoreWorker &operator=(SetIgnoreWorker &&) = delete;
         ~SetIgnoreWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         SetIgnoreBaton *baton;
@@ -404,17 +503,24 @@ class GitSubmodule : public
       git_repository * repo;
       const char * name;
       git_submodule_update_t update;
-    };
-    class SetUpdateWorker : public Nan::AsyncWorker {
+     };
+    class SetUpdateWorker : public nodegit::AsyncWorker {
       public:
         SetUpdateWorker(
             SetUpdateBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:SetUpdate", cleanupHandles)
           , baton(_baton) {};
+        SetUpdateWorker(const SetUpdateWorker &) = delete;
+        SetUpdateWorker(SetUpdateWorker &&) = delete;
+        SetUpdateWorker &operator=(const SetUpdateWorker &) = delete;
+        SetUpdateWorker &operator=(SetUpdateWorker &&) = delete;
         ~SetUpdateWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         SetUpdateBaton *baton;
@@ -428,17 +534,24 @@ class GitSubmodule : public
       git_repository * repo;
       const char * name;
       const char * url;
-    };
-    class SetUrlWorker : public Nan::AsyncWorker {
+     };
+    class SetUrlWorker : public nodegit::AsyncWorker {
       public:
         SetUrlWorker(
             SetUrlBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:SetUrl", cleanupHandles)
           , baton(_baton) {};
+        SetUrlWorker(const SetUrlWorker &) = delete;
+        SetUrlWorker(SetUrlWorker &&) = delete;
+        SetUrlWorker &operator=(const SetUrlWorker &) = delete;
+        SetUrlWorker &operator=(SetUrlWorker &&) = delete;
         ~SetUrlWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         SetUrlBaton *baton;
@@ -453,17 +566,24 @@ class GitSubmodule : public
       git_repository * repo;
       const char * name;
       git_submodule_ignore_t ignore;
-    };
-    class StatusWorker : public Nan::AsyncWorker {
+     };
+    class StatusWorker : public nodegit::AsyncWorker {
       public:
         StatusWorker(
             StatusBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:Status", cleanupHandles)
           , baton(_baton) {};
+        StatusWorker(const StatusWorker &) = delete;
+        StatusWorker(StatusWorker &&) = delete;
+        StatusWorker &operator=(const StatusWorker &) = delete;
+        StatusWorker &operator=(StatusWorker &&) = delete;
         ~StatusWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         StatusBaton *baton;
@@ -475,17 +595,24 @@ class GitSubmodule : public
       int error_code;
       const git_error* error;
       git_submodule * submodule;
-    };
-    class SyncWorker : public Nan::AsyncWorker {
+     };
+    class SyncWorker : public nodegit::AsyncWorker {
       public:
         SyncWorker(
             SyncBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:Sync", cleanupHandles)
           , baton(_baton) {};
+        SyncWorker(const SyncWorker &) = delete;
+        SyncWorker(SyncWorker &&) = delete;
+        SyncWorker &operator=(const SyncWorker &) = delete;
+        SyncWorker &operator=(SyncWorker &&) = delete;
         ~SyncWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         SyncBaton *baton;
@@ -499,17 +626,24 @@ class GitSubmodule : public
       git_submodule * submodule;
       int init;
       git_submodule_update_options * options;
-    };
-    class UpdateWorker : public Nan::AsyncWorker {
+     };
+    class UpdateWorker : public nodegit::AsyncWorker {
       public:
         UpdateWorker(
             UpdateBaton *_baton,
-            Nan::Callback *callback
-        ) : Nan::AsyncWorker(callback)
+            Nan::Callback *callback,
+            std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> &cleanupHandles
+        ) : nodegit::AsyncWorker(callback, "nodegit:AsyncWorker:GitSubmodule:Update", cleanupHandles)
           , baton(_baton) {};
+        UpdateWorker(const UpdateWorker &) = delete;
+        UpdateWorker(UpdateWorker &&) = delete;
+        UpdateWorker &operator=(const UpdateWorker &) = delete;
+        UpdateWorker &operator=(UpdateWorker &&) = delete;
         ~UpdateWorker() {};
         void Execute();
+        void HandleErrorCallback();
         void HandleOKCallback();
+        nodegit::LockMaster AcquireLocks();
 
       private:
         UpdateBaton *baton;
@@ -530,6 +664,11 @@ class GitSubmodule : public
         callback = NULL;
       }
 
+      Foreach_globalPayload(const Foreach_globalPayload &) = delete;
+      Foreach_globalPayload(Foreach_globalPayload &&) = delete;
+      Foreach_globalPayload &operator=(const Foreach_globalPayload &) = delete;
+      Foreach_globalPayload &operator=(Foreach_globalPayload &&) = delete;
+
       ~Foreach_globalPayload() {
         if (callback != NULL) {
           delete callback;

package/include/submodule_update_options.h

@@ -1,17 +1,20 @@
 // This is a generated file, modify: generate/templates/templates/struct_header.h
 
+// generated from struct_header.h
 #ifndef GITSUBMODULEUPDATEOPTIONS_H
 #define GITSUBMODULEUPDATEOPTIONS_H
 #include <nan.h>
 #include <string>
-#include <queue>
 #include <utility>
-#include <unordered_map>
 
 #include "async_baton.h"
+#include "async_worker.h"
 #include "callback_wrapper.h"
+#include "context.h"
 #include "reference_counter.h"
 #include "nodegit_wrapper.h"
+#include "configurable_class_wrapper.h"
+#include "v8_helpers.h"
 
 extern "C" {
   #include <git2.h>
@@ -24,16 +27,19 @@ using namespace node;
 using namespace v8;
 
 class GitSubmoduleUpdateOptions;
-
+class ConfigurableGitSubmoduleUpdateOptions;
+ 
 struct GitSubmoduleUpdateOptionsTraits {
   typedef GitSubmoduleUpdateOptions cppClass;
   typedef git_submodule_update_options cType;
-
+  typedef ConfigurableGitSubmoduleUpdateOptions configurableCppClass;
+ 
   static const bool isDuplicable = false;
   static void duplicate(git_submodule_update_options **dest, git_submodule_update_options *src) {
      Nan::ThrowError("duplicate called on GitSubmoduleUpdateOptions which cannot be duplicated");
    }
 
+  static std::string className() { return "GitSubmoduleUpdateOptions"; };
   static const bool isSingleton = false;
   static const bool isFreeable = true;
   static void free(git_submodule_update_options *raw) {
@@ -43,38 +49,26 @@ struct GitSubmoduleUpdateOptionsTraits {
     }
    }
 };
- class GitSubmoduleUpdateOptions : public NodeGitWrapper<GitSubmoduleUpdateOptionsTraits> {
-    // grant full access to base class
-    friend class NodeGitWrapper<GitSubmoduleUpdateOptionsTraits>;
-  public:
-    GitSubmoduleUpdateOptions(git_submodule_update_options* raw, bool selfFreeing, v8::Local<v8::Object> owner = v8::Local<v8::Object>());
-    static void InitializeComponent (v8::Local<v8::Object> target);
-
-         
-  private:
-    GitSubmoduleUpdateOptions();
-    ~GitSubmoduleUpdateOptions();
-
-    void ConstructFields();
-
   
-        static NAN_GETTER(GetVersion);
-        static NAN_SETTER(SetVersion);
+class ConfigurableGitSubmoduleUpdateOptions : public nodegit::ConfigurableClassWrapper<GitSubmoduleUpdateOptionsTraits> {
+  friend class nodegit::ConfigurableClassWrapper<GitSubmoduleUpdateOptionsTraits>;
 
-             Nan::Persistent<Object> checkout_opts;
-  
-        static NAN_GETTER(GetCheckoutOpts);
-        static NAN_SETTER(SetCheckoutOpts);
+public:
+  static v8ConversionResult fromJavascript(nodegit::Context *nodegitContext, v8::Local<v8::Value> input);
+  ~ConfigurableGitSubmoduleUpdateOptions();
 
-             Nan::Persistent<Object> fetch_opts;
-  
-        static NAN_GETTER(GetFetchOpts);
-        static NAN_SETTER(SetFetchOpts);
+  ConfigurableGitSubmoduleUpdateOptions(const ConfigurableGitSubmoduleUpdateOptions &) = delete;
+  ConfigurableGitSubmoduleUpdateOptions(ConfigurableGitSubmoduleUpdateOptions &&) = delete;
+  ConfigurableGitSubmoduleUpdateOptions &operator=(const ConfigurableGitSubmoduleUpdateOptions &) = delete;
+  ConfigurableGitSubmoduleUpdateOptions &operator=(ConfigurableGitSubmoduleUpdateOptions &&) = delete;
 
-   
-        static NAN_GETTER(GetAllowFetch);
-        static NAN_SETTER(SetAllowFetch);
+         
+private:
+  ConfigurableGitSubmoduleUpdateOptions(nodegit::Context *nodegitContext);
+  ConfigurableGitSubmoduleUpdateOptions() = delete;
+  Nan::Global<Value> promiseError;
 
-  };
+             
+};
 
 #endif