#include <nan.h>

#include <string.h>

extern "C" {

#include <git2.h>

{% each cDependencies as dependency %}

#include <{{ dependency }}>

{% endeach %}

}

#include "../include/lock_master.h"

#include "../include/functions/copy.h"

#include "../include/{{ filename }}.h"

#include "nodegit_wrapper.cc"

#include "../include/async_libgit2_queue_worker.h"

{% each dependencies as dependency %}

#include "{{ dependency }}"

{% endeach %}

#include <iostream>

using namespace std;

using namespace v8;

using namespace node;

{% if cType %}

{{ cppClassName }}::~{{ cppClassName }}() {

// 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.

{% each functions as function %}

{% if not function.ignore %}

{% each function.args as arg %}

{% if arg.saveArg %}

{{ function.cppFunctionName }}_{{ arg.name }}).Reset();

{% endif %}

{% endeach %}

{% endif %}

{% endeach %}

}

void {{ cppClassName }}::InitializeComponent(Local<v8::Object> target) {

Nan::HandleScope scope;

Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction);

tpl->InstanceTemplate()->SetInternalFieldCount(1);

tpl->SetClassName(Nan::New("{{ jsClassName }}").ToLocalChecked());

{% each functions as function %}

{% if not function.ignore %}

{% if function.isPrototypeMethod %}

Nan::SetPrototypeMethod(tpl, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }});

{% else %}

Nan::SetMethod(tpl, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }});

{% endif %}

{% endif %}

{% endeach %}

{% each fields as field %}

{% if not field.ignore %}

Nan::SetPrototypeMethod(tpl, "{{ field.jsFunctionName }}", {{ field.cppFunctionName }});

{% endif %}

{% endeach %}

InitializeTemplate(tpl);

Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();

constructor_template.Reset(_constructor_template);

Nan::Set(target, Nan::New("{{ jsClassName }}").ToLocalChecked(), _constructor_template);

}

{% else %}

void {{ cppClassName }}::InitializeComponent(Local<v8::Object> target) {

Nan::HandleScope scope;

Local<Object> object = Nan::New<Object>();

{% each functions as function %}

{% if not function.ignore %}

Nan::SetMethod(object, "{{ function.jsFunctionName }}", {{ function.cppFunctionName }});

{% endif %}

{% endeach %}

Nan::Set(target, Nan::New<String>("{{ jsClassName }}").ToLocalChecked(), object);

}

{% endif %}

{% each functions as function %}

{% if not function.ignore %}

{% if function.isManual %}

{{= function.implementation =}}

{% elsif function.isAsync %}

{% partial asyncFunction function %}

{% else %}

{% partial syncFunction function %}

{% endif %}

{% endif %}

{% endeach %}

{% partial fields . %}

{%if cType %}

template class NodeGitWrapper<{{ cppClassName }}Traits>;

{% endif %}