Add callback throttle functionality

e8f8de5c9e18b1f623262689545a0157e2885d25
commit e8f8de5c9e18b1f623262689545a0157e2885d25
diff --git a/generate/templates/manual/include/callback_wrapper.h b/generate/templates/manual/include/callback_wrapper.h
@@ -1,21 +1,26 @@
 #ifndef CALLBACK_WRAPPER_H
 #define CALLBACK_WRAPPER_H
 
-#include <v8.h>
-#include <node.h>
-
-#include "nan.h"
+#include <nan.h>
+#include <uv.h>
 
 using namespace v8;
 using namespace node;
 
 class CallbackWrapper {
   Nan::Callback* jsCallback;
 
+  // throttling data, used for callbacks that need to be throttled
+  int throttle; // in milliseconds - if > 0, calls to the JS callback will be throttled
+  uint64_t lastCallTime;
+
 public:
   CallbackWrapper() {
     jsCallback = NULL;
+    lastCallTime = 0;
+    throttle = 0;
   }
+
   ~CallbackWrapper() {
     SetCallback(NULL);
   }
@@ -28,11 +33,27 @@ class CallbackWrapper {
     return jsCallback;
   }
 
-  void SetCallback(Nan::Callback* callback) {
+  void SetCallback(Nan::Callback* callback, int throttle = 0) {
     if(jsCallback) {
       delete jsCallback;
     }
     jsCallback = callback;
+    this->throttle = throttle;
+  }
+
+  bool WillBeThrottled() {
+    if(!throttle) {
+      return false;
+    }
+    // throttle if needed
+    uint64_t now = uv_hrtime();
+    if(lastCallTime > 0 && now < lastCallTime + throttle * 1000000) {
+      // throttled
+      return true;
+    } else {
+      lastCallTime = now;
+      return false;
+    }
   }
 };
 

diff --git a/generate/templates/partials/field_accessors.cc b/generate/templates/partials/field_accessors.cc
@@ -31,6 +31,7 @@
     }
 
     NAN_SETTER({{ cppClassName }}::Set{{ field.cppFunctionName }}) {
+      Nan::HandleScope scope;
 
       {{ cppClassName }} *wrapper = Nan::ObjectWrap::Unwrap<{{ cppClassName }}>(info.This());
 
@@ -47,12 +48,35 @@
         wrapper->raw->{{ field.name }} = {% if not field.cType | isPointer %}*{% endif %}{% if field.cppClassName == 'GitStrarray' %}StrArrayConverter::Convert({{ field.name }}->ToObject()){% else %}Nan::ObjectWrap::Unwrap<{{ field.cppClassName }}>({{ field.name }}->ToObject())->GetValue(){% endif %};
 
       {% elsif field.isCallbackFunction %}
+        Nan::Callback *callback = NULL;
+        int throttle = {%if field.return.throttle %}{{ field.return.throttle }}{%else%}0{%endif%};
+
         if (value->IsFunction()) {
+          callback = new Nan::Callback(value.As<Function>());
+        } else if (value->IsObject()) {
+          Local<Object> object = value.As<Object>();
+          Local<String> callbackKey;
+          Nan::MaybeLocal<Value> maybeObjectCallback = Nan::Get(object, Nan::New("callback").ToLocalChecked());
+          if (!maybeObjectCallback.IsEmpty()) {
+            Local<Value> objectCallback = maybeObjectCallback.ToLocalChecked();
+            if (objectCallback->IsFunction()) {
+              callback = new Nan::Callback(objectCallback.As<Function>());
+              Nan::MaybeLocal<Value> maybeObjectThrottle = Nan::Get(object, Nan::New("throttle").ToLocalChecked());
+              if(!maybeObjectThrottle.IsEmpty()) {
+                Local<Value> objectThrottle = maybeObjectThrottle.ToLocalChecked();
+                if (objectThrottle->IsNumber()) {
+                  throttle = (int)objectThrottle.As<Number>()->Value();
+                }
+              }
+            }
+          }
+        }
+        if (callback) {
           if (!wrapper->raw->{{ field.name }}) {
             wrapper->raw->{{ field.name }} = ({{ field.cType }}){{ field.name }}_cppCallback;
           }
 
-          wrapper->{{ field.name }}.SetCallback(new Nan::Callback(value.As<Function>()));
+          wrapper->{{ field.name }}.SetCallback(callback, throttle);
         }
 
       {% elsif field.payloadFor %}
@@ -78,6 +102,12 @@
     }
 
     {% if field.isCallbackFunction %}
+      {{ cppClassName }}* {{ cppClassName }}::{{ field.name }}_getInstanceFromBaton({{ field.name|titleCase }}Baton* baton) {
+        return static_cast<{{ cppClassName }}*>(baton->{% each field.args|argsInfo as arg %}
+          {% if arg.payload == true %}{{arg.name}}{% elsif arg.lastArg %}{{arg.name}}{% endif %}
+        {% endeach %});
+      }
+
       {{ field.return.type }} {{ cppClassName }}::{{ field.name }}_cppCallback (
         {% each field.args|argsInfo as arg %}
           {{ arg.cType }} {{ arg.name}}{% if not arg.lastArg %},{% endif %}
@@ -90,16 +120,20 @@
           baton->{{ arg.name }} = {{ arg.name }};
         {% endeach %}
 
+        {{ cppClassName }}* instance = {{ field.name }}_getInstanceFromBaton(baton);
+
+        if (instance->{{ field.name }}.WillBeThrottled()) {
+          return baton->defaultResult;
+        }
+
         return baton->ExecuteAsync((uv_async_cb) {{ field.name }}_async);
       }
 
       void {{ cppClassName }}::{{ field.name }}_async(uv_async_t* req, int status) {
         Nan::HandleScope scope;
 
         {{ field.name|titleCase }}Baton* baton = static_cast<{{ field.name|titleCase }}Baton*>(req->data);
-        {{ cppClassName }}* instance = static_cast<{{ cppClassName }}*>(baton->{% each field.args|argsInfo as arg %}
-          {% if arg.payload == true %}{{arg.name}}{% elsif arg.lastArg %}{{arg.name}}{% endif %}
-        {% endeach %});
+        {{ cppClassName }}* instance = {{ field.name }}_getInstanceFromBaton(baton);
 
         if (instance->{{ field.name }}.GetCallback()->IsEmpty()) {
           {% if field.return.type == "int" %}

diff --git a/generate/templates/templates/struct_header.h b/generate/templates/templates/struct_header.h
@@ -58,6 +58,8 @@ class {{ cppClassName }} : public Nan::ObjectWrap {
               : AsyncBatonWithResult<{{ field.return.type }}>(defaultResult) {
               }
           };
+          static {{ cppClassName }} * {{ field.name }}_getInstanceFromBaton (
+            {{ field.name|titleCase }}Baton *baton);
         {% endif %}
       {% endif %}
     {% endeach %}