// This is a generated file, modify: generate/templates/class_content.cc

#include <nan.h>

#include <string.h>

#include "date.hpp"

#include <qlo/qladdindefines.hpp>

#include <qlo/date.hpp>

#include <ql/time/date.hpp>

#include <ql/time/imm.hpp>

#include <ql/time/ecb.hpp>

#include <ql/time/asx.hpp>

#include <qlo/loop/loop_date.hpp>

#include <oh/enumerations/typefactory.hpp>

#include <oh/objecthandler.hpp>

#include <oh/conversions/getobjectvector.hpp>

#include <qlo/valueobjects/vo_all.hpp>

#include <qlo/conversions/all.hpp>

#include "../loop.hpp"

void PeriodFromFrequencyWorker::Execute(){

try{

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::Frequency FrequencyEnum =

ObjectHandler::Create<QuantLib::Frequency>()(mFrequency);

// invoke the utility function

QuantLib::Period returnValue = QuantLibAddin::periodFromFrequency(

FrequencyEnum

);

mReturnValue = QuantLibAddin::libraryToScalar(returnValue);

}catch(const std::exception &e){

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void PeriodFromFrequencyWorker::HandleOKCallback(){

Nan::HandleScope scope;

Local<v8::Value> argv[2] = {

Nan::New<String>(mError).ToLocalChecked(),

Nan::New<String>(mReturnValue).ToLocalChecked()

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::PeriodFromFrequency) {

// validate js arguments

if (info.Length() == 0 || !info[0]->IsString()) {

return Nan::ThrowError("Frequency is required.");

}

// convert js argument to c++ type

String::Utf8Value strFrequency(info[0]->ToString());

string FrequencyCpp(strdup(*strFrequency));

// declare callback

Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());

// launch Async worker

Nan::AsyncQueueWorker(new PeriodFromFrequencyWorker(

callback

,FrequencyCpp

));

}

//PeriodFromFrequencyWorker::~PeriodFromFrequencyWorker(){

//

//}

//PeriodFromFrequencyWorker::Destroy(){

//

//}

void FrequencyFromPeriodWorker::Execute(){

try{

// convert input datatypes to QuantLib datatypes

std::vector<QuantLib::Period> PeriodLib;

std::vector<QuantLib::Frequency> returnValue;

// loop on the input parameter and populate the return vector

QuantLibAddin::qlFrequencyFromPeriodBind bindObject =

boost::bind(

&QuantLibAddin::frequencyFromPeriod

,_1

);

ObjectHandler::loop

<QuantLibAddin::qlFrequencyFromPeriodBind, QuantLib::Period, QuantLib::Frequency>

(bindObject,

PeriodLib,

returnValue

);

for(unsigned int i = 0; i< returnValue.size(); i++){

std::ostringstream os;

os << returnValue[i];

mReturnValue.push_back(os.str());

}

}catch(const std::exception &e){

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void FrequencyFromPeriodWorker::HandleOKCallback(){

Nan::HandleScope scope;

Local<Array> tmpArray = Nan::New<Array>(mReturnValue.size());

for (unsigned int i = 0; i < mReturnValue.size(); i++) {

Nan::Set(tmpArray,i,Nan::New<String>(mReturnValue[i]).ToLocalChecked());

}

Local<v8::Value> argv[2] = {

Nan::New<String>(mError).ToLocalChecked(),

tmpArray

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::FrequencyFromPeriod) {

// validate js arguments

if (info.Length() == 0 || !info[0]->IsArray()) {

return Nan::ThrowError("Period is required.");

}

// convert js argument to c++ type

std::vector<ObjectHandler::property_t>PeriodCpp;

Local<Array> PeriodArray = info[0].As<Array>();

for (unsigned int i = 0; i < PeriodArray->Length(); i++){

ObjectHandler::property_t tmp =

ObjectHandler::property_t(static_cast<double>(Nan::To<double>(Nan::Get(PeriodArray, i).ToLocalChecked()).FromJust()));

PeriodCpp.push_back(tmp);

}

// declare callback

Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());

// launch Async worker

Nan::AsyncQueueWorker(new FrequencyFromPeriodWorker(

callback

,PeriodCpp

));

}

//FrequencyFromPeriodWorker::~FrequencyFromPeriodWorker(){

//

//}

//FrequencyFromPeriodWorker::Destroy(){

//

//}

void PeriodLessThanWorker::Execute(){

try{

// convert input datatypes to QuantLib datatypes

QuantLib::Period Period1Lib;

QuantLibAddin::cppToLibrary(mPeriod1, Period1Lib);

// convert input datatypes to QuantLib datatypes

QuantLib::Period Period2Lib;

QuantLibAddin::cppToLibrary(mPeriod2, Period2Lib);

// invoke the utility function

mReturnValue = QuantLib::operator<(

Period1Lib

,

Period2Lib

);

}catch(const std::exception &e){

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void PeriodLessThanWorker::HandleOKCallback(){

Nan::HandleScope scope;

Local<v8::Value> argv[2] = {

Nan::New<String>(mError).ToLocalChecked(),

Nan::New<Boolean>(mReturnValue)

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::PeriodLessThan) {

// validate js arguments

if (info.Length() == 0 || !info[0]->IsString()) {

return Nan::ThrowError("Period1 is required.");

}

if (info.Length() == 1 || !info[1]->IsString()) {

return Nan::ThrowError("Period2 is required.");

}

// convert js argument to c++ type

String::Utf8Value strPeriod1(info[0]->ToString());

string Period1Cpp(strdup(*strPeriod1));

// convert js argument to c++ type

String::Utf8Value strPeriod2(info[1]->ToString());

string Period2Cpp(strdup(*strPeriod2));

// declare callback

Nan::Callback *callback = new Nan::Callback(info[2].As<Function>());

// launch Async worker

Nan::AsyncQueueWorker(new PeriodLessThanWorker(

callback

,Period1Cpp

,Period2Cpp

));

}

//PeriodLessThanWorker::~PeriodLessThanWorker(){

//

//}

//PeriodLessThanWorker::Destroy(){

//

//}

void PeriodEquivalentWorker::Execute(){

try{

// convert input datatypes to QuantLib datatypes

QuantLib::Period PeriodLib;

QuantLibAddin::cppToLibrary(mPeriod, PeriodLib);

// invoke the utility function

QuantLib::Period returnValue = QuantLibAddin::periodEquivalent(

PeriodLib

);

mReturnValue = QuantLibAddin::libraryToScalar(returnValue);

}catch(const std::exception &e){

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void PeriodEquivalentWorker::HandleOKCallback(){

Nan::HandleScope scope;

Local<v8::Value> argv[2] = {

Nan::New<String>(mError).ToLocalChecked(),

Nan::New<String>(mReturnValue).ToLocalChecked()

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::PeriodEquivalent) {

// validate js arguments

if (info.Length() == 0 || !info[0]->IsString()) {

return Nan::ThrowError("Period is required.");

}

// convert js argument to c++ type

String::Utf8Value strPeriod(info[0]->ToString());

string PeriodCpp(strdup(*strPeriod));

// declare callback

Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());

// launch Async worker

Nan::AsyncQueueWorker(new PeriodEquivalentWorker(

callback

,PeriodCpp

));

}

//PeriodEquivalentWorker::~PeriodEquivalentWorker(){

//

//}

//PeriodEquivalentWorker::Destroy(){

//

//}

void DateMinDateWorker::Execute(){

try{

// invoke the utility function

QuantLib::Date returnValue = QuantLib::Date::minDate(

);

mReturnValue = QuantLibAddin::libraryToScalar(returnValue);

}catch(const std::exception &e){

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void DateMinDateWorker::HandleOKCallback(){

Nan::HandleScope scope;

Local<v8::Value> argv[2] = {

Nan::New<String>(mError).ToLocalChecked(),

Nan::New<Number>(mReturnValue)

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::DateMinDate) {

// validate js arguments

// declare callback

Nan::Callback *callback = new Nan::Callback(info[0].As<Function>());

// launch Async worker

Nan::AsyncQueueWorker(new DateMinDateWorker(

callback

));

}

//DateMinDateWorker::~DateMinDateWorker(){

//

//}

//DateMinDateWorker::Destroy(){

//

//}

void DateMaxDateWorker::Execute(){

try{

// invoke the utility function

QuantLib::Date returnValue = QuantLib::Date::maxDate(

);

mReturnValue = QuantLibAddin::libraryToScalar(returnValue);

}catch(const std::exception &e){

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void DateMaxDateWorker::HandleOKCallback(){

Nan::HandleScope scope;

Local<v8::Value> argv[2] = {

Nan::New<String>(mError).ToLocalChecked(),

Nan::New<Number>(mReturnValue)

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::DateMaxDate) {

// validate js arguments

// declare callback

Nan::Callback *callback = new Nan::Callback(info[0].As<Function>());

// launch Async worker

Nan::AsyncQueueWorker(new DateMaxDateWorker(

callback

));

}

//DateMaxDateWorker::~DateMaxDateWorker(){

//

//}

//DateMaxDateWorker::Destroy(){

//

//}

void DateIsLeapWorker::Execute(){

try{

// loop on the input parameter and populate the return vector

QuantLibAddin::qlDateIsLeapBind bindObject =

boost::bind(

&QuantLib::Date::isLeap

,_1

);

ObjectHandler::loop

<QuantLibAddin::qlDateIsLeapBind, long, bool>

(bindObject,

mYear,

mReturnValue

);

}catch(const std::exception &e){

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void DateIsLeapWorker::HandleOKCallback(){

Nan::HandleScope scope;

Local<Array> tmpArray = Nan::New<Array>(mReturnValue.size());

for (unsigned int i = 0; i < mReturnValue.size(); i++) {

Nan::Set(tmpArray,i,Nan::New<Boolean>(mReturnValue[i]));

}

Local<v8::Value> argv[2] = {

Nan::New<String>(mError).ToLocalChecked(),

tmpArray

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::DateIsLeap) {

// validate js arguments

if (info.Length() == 0 || !info[0]->IsArray()) {

return Nan::ThrowError("Year is required.");

}

// convert js argument to c++ type

std::vector<long>YearCpp;

Local<Array> YearArray = info[0].As<Array>();

for (unsigned int i = 0; i < YearArray->Length(); i++){

YearCpp.push_back(Nan::To<int32_t>(Nan::Get(YearArray, i).ToLocalChecked()).FromJust());

}

// declare callback

Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());

// launch Async worker

Nan::AsyncQueueWorker(new DateIsLeapWorker(

callback

,YearCpp

));

}

//DateIsLeapWorker::~DateIsLeapWorker(){

//

//}

//DateIsLeapWorker::Destroy(){

//

//}

void DateEndOfMonthWorker::Execute(){

try{

// convert input datatypes to QuantLib datatypes

std::vector<QuantLib::Date> DateLib = ObjectHandler::vector::convert2<QuantLib::Date>(

mDate, "Date");

std::vector<QuantLib::Date> returnValue;

// loop on the input parameter and populate the return vector

QuantLibAddin::qlDateEndOfMonthBind bindObject =

boost::bind(

&QuantLib::Date::endOfMonth

,_1

);

ObjectHandler::loop

<QuantLibAddin::qlDateEndOfMonthBind, QuantLib::Date, QuantLib::Date>

(bindObject,

DateLib,

returnValue

);

mReturnValue = QuantLibAddin::libraryToVector(returnValue);

}catch(const std::exception &e){

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void DateEndOfMonthWorker::HandleOKCallback(){

Nan::HandleScope scope;

Local<Array> tmpArray = Nan::New<Array>(mReturnValue.size());

for (unsigned int i = 0; i < mReturnValue.size(); i++) {

Nan::Set(tmpArray,i,Nan::New<Number>(mReturnValue[i]));

}

Local<v8::Value> argv[2] = {

Nan::New<String>(mError).ToLocalChecked(),

tmpArray

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::DateEndOfMonth) {

// validate js arguments

if (info.Length() == 0 || !info[0]->IsArray()) {

return Nan::ThrowError("Date is required.");

}

// convert js argument to c++ type

std::vector<ObjectHandler::property_t>DateCpp;

Local<Array> DateArray = info[0].As<Array>();

for (unsigned int i = 0; i < DateArray->Length(); i++){

ObjectHandler::property_t tmp =

ObjectHandler::property_t(static_cast<long>(Nan::To<int32_t>(Nan::Get(DateArray, i).ToLocalChecked()).FromJust()));

DateCpp.push_back(tmp);

}

// declare callback

Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());

// launch Async worker

Nan::AsyncQueueWorker(new DateEndOfMonthWorker(

callback

,DateCpp

));

}

//DateEndOfMonthWorker::~DateEndOfMonthWorker(){

//

//}

//DateEndOfMonthWorker::Destroy(){

//

//}

void DateIsEndOfMonthWorker::Execute(){

try{

// convert input datatypes to QuantLib datatypes

std::vector<QuantLib::Date> DateLib = ObjectHandler::vector::convert2<QuantLib::Date>(

mDate, "Date");

// loop on the input parameter and populate the return vector

QuantLibAddin::qlDateIsEndOfMonthBind bindObject =

boost::bind(

&QuantLib::Date::isEndOfMonth

,_1

);

ObjectHandler::loop

<QuantLibAddin::qlDateIsEndOfMonthBind, QuantLib::Date, bool>

(bindObject,

DateLib,

mReturnValue

);

}catch(const std::exception &e){

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void DateIsEndOfMonthWorker::HandleOKCallback(){

Nan::HandleScope scope;

Local<Array> tmpArray = Nan::New<Array>(mReturnValue.size());

for (unsigned int i = 0; i < mReturnValue.size(); i++) {

Nan::Set(tmpArray,i,Nan::New<Boolean>(mReturnValue[i]));

}

Local<v8::Value> argv[2] = {

Nan::New<String>(mError).ToLocalChecked(),

tmpArray

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::DateIsEndOfMonth) {

// validate js arguments

if (info.Length() == 0 || !info[0]->IsArray()) {

return Nan::ThrowError("Date is required.");

}

// convert js argument to c++ type

std::vector<ObjectHandler::property_t>DateCpp;

Local<Array> DateArray = info[0].As<Array>();

for (unsigned int i = 0; i < DateArray->Length(); i++){

ObjectHandler::property_t tmp =

ObjectHandler::property_t(static_cast<long>(Nan::To<int32_t>(Nan::Get(DateArray, i).ToLocalChecked()).FromJust()));

DateCpp.push_back(tmp);

}

// declare callback

Nan::Callback *callback = new Nan::Callback(info[1].As<Function>());

// launch Async worker

Nan::AsyncQueueWorker(new DateIsEndOfMonthWorker(

callback

,DateCpp

));

}

//DateIsEndOfMonthWorker::~DateIsEndOfMonthWorker(){

//

//}

//DateIsEndOfMonthWorker::Destroy(){

//

//}

void DateNextWeekdayWorker::Execute(){

try{

// convert input datatypes to QuantLib datatypes

std::vector<QuantLib::Date> DateLib = ObjectHandler::vector::convert2<QuantLib::Date>(

mDate, "Date");

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::Weekday WeekdayEnum =

ObjectHandler::Create<QuantLib::Weekday>()(mWeekday);

std::vector<QuantLib::Date> returnValue;

// loop on the input parameter and populate the return vector

QuantLibAddin::qlDateNextWeekdayBind bindObject =

boost::bind(

&QuantLib::Date::nextWeekday

,_1

,WeekdayEnum

);

ObjectHandler::loop

<QuantLibAddin::qlDateNextWeekdayBind, QuantLib::Date, QuantLib::Date>

(bindObject,

DateLib,

returnValue

);

mReturnValue = QuantLibAddin::libraryToVector(returnValue);

}catch(const std::exception &e){

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void DateNextWeekdayWorker::HandleOKCallback(){

Nan::HandleScope scope;

Local<Array> tmpArray = Nan::New<Array>(mReturnValue.size());

for (unsigned int i = 0; i < mReturnValue.size(); i++) {

Nan::Set(tmpArray,i,Nan::New<Number>(mReturnValue[i]));

}

Local<v8::Value> argv[2] = {

Nan::New<String>(mError).ToLocalChecked(),

tmpArray

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::DateNextWeekday) {

// validate js arguments

if (info.Length() == 0 || !info[0]->IsArray()) {

return Nan::ThrowError("Date is required.");

}

if (info.Length() == 1 || !info[1]->IsString()) {

return Nan::ThrowError("Weekday is required.");

}

// convert js argument to c++ type

std::vector<ObjectHandler::property_t>DateCpp;

Local<Array> DateArray = info[0].As<Array>();

for (unsigned int i = 0; i < DateArray->Length(); i++){

ObjectHandler::property_t tmp =

ObjectHandler::property_t(static_cast<long>(Nan::To<int32_t>(Nan::Get(DateArray, i).ToLocalChecked()).FromJust()));

DateCpp.push_back(tmp);

}

// convert js argument to c++ type

String::Utf8Value strWeekday(info[1]->ToString());

string WeekdayCpp(strdup(*strWeekday));

// declare callback

Nan::Callback *callback = new Nan::Callback(info[2].As<Function>());

// launch Async worker

Nan::AsyncQueueWorker(new DateNextWeekdayWorker(

callback

,DateCpp

,WeekdayCpp

));

}

//DateNextWeekdayWorker::~DateNextWeekdayWorker(){

//

//}

//DateNextWeekdayWorker::Destroy(){

//

//}

void DateNthWeekdayWorker::Execute(){

try{

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::Weekday WeekdayEnum =

ObjectHandler::Create<QuantLib::Weekday>()(mWeekday);

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::Month MonthEnum =

ObjectHandler::Create<QuantLib::Month>()(mMonth);

// invoke the utility function

QuantLib::Date returnValue = QuantLib::Date::nthWeekday(

mNth

,

WeekdayEnum

,

MonthEnum

,

mYear

);

mReturnValue = QuantLibAddin::libraryToScalar(returnValue);

}catch(const std::exception &e){

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void DateNthWeekdayWorker::HandleOKCallback(){

Nan::HandleScope scope;

Local<v8::Value> argv[2] = {

Nan::New<String>(mError).ToLocalChecked(),

Nan::New<Number>(mReturnValue)

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::DateNthWeekday) {

// validate js arguments

if (info.Length() == 0 || !info[0]->IsNumber()) {

return Nan::ThrowError("Nth is required.");

}

if (info.Length() == 1 || !info[1]->IsString()) {

return Nan::ThrowError("Weekday is required.");

}

if (info.Length() == 2 || !info[2]->IsString()) {

return Nan::ThrowError("Month is required.");

}

if (info.Length() == 3 || !info[3]->IsNumber()) {

return Nan::ThrowError("Year is required.");

}

// convert js argument to c++ type

long NthCpp = Nan::To<int32_t>(info[0]).FromJust();

// convert js argument to c++ type

String::Utf8Value strWeekday(info[1]->ToString());

string WeekdayCpp(strdup(*strWeekday));

// convert js argument to c++ type

String::Utf8Value strMonth(info[2]->ToString());

string MonthCpp(strdup(*strMonth));

// convert js argument to c++ type

long YearCpp = Nan::To<int32_t>(info[3]).FromJust();

// declare callback

Nan::Callback *callback = new Nan::Callback(info[4].As<Function>());

// launch Async worker

Nan::AsyncQueueWorker(new DateNthWeekdayWorker(

callback

,NthCpp

,WeekdayCpp

,MonthCpp

,YearCpp

));

}

//DateNthWeekdayWorker::~DateNthWeekdayWorker(){

//

//}

//DateNthWeekdayWorker::Destroy(){

//

//}

void IMMIsIMMdateWorker::Execute(){

try{

// convert input datatypes to QuantLib datatypes

std::vector<QuantLib::Date> DateLib = ObjectHandler::vector::convert2<QuantLib::Date>(

mDate, "Date");

// loop on the input parameter and populate the return vector

QuantLibAddin::qlIMMIsIMMdateBind bindObject =

boost::bind(

&QuantLib::IMM::isIMMdate

,_1

,mMainCycle

);

ObjectHandler::loop

<QuantLibAddin::qlIMMIsIMMdateBind, QuantLib::Date, bool>

(bindObject,

DateLib,

mReturnValue

);

}catch(const std::exception &e){

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void IMMIsIMMdateWorker::HandleOKCallback(){

Nan::HandleScope scope;

Local<Array> tmpArray = Nan::New<Array>(mReturnValue.size());

for (unsigned int i = 0; i < mReturnValue.size(); i++) {

Nan::Set(tmpArray,i,Nan::New<Boolean>(mReturnValue[i]));

}

Local<v8::Value> argv[2] = {

Nan::New<String>(mError).ToLocalChecked(),

tmpArray

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::IMMIsIMMdate) {

// validate js arguments

if (info.Length() == 0 || !info[0]->IsArray()) {

return Nan::ThrowError("Date is required.");

}

if (info.Length() == 1 || !info[1]->IsBoolean()) {

return Nan::ThrowError("MainCycle is required.");

}

// convert js argument to c++ type

std::vector<ObjectHandler::property_t>DateCpp;

Local<Array> DateArray = info[0].As<Array>();

for (unsigned int i = 0; i < DateArray->Length(); i++){

ObjectHandler::property_t tmp =

ObjectHandler::property_t(static_cast<long>(Nan::To<int32_t>(Nan::Get(DateArray, i).ToLocalChecked()).FromJust()));

DateCpp.push_back(tmp);

}

// convert js argument to c++ type

bool MainCycleCpp = Nan::To<bool>(info[1]).FromJust();

// declare callback

Nan::Callback *callback = new Nan::Callback(info[2].As<Function>());

// launch Async worker

Nan::AsyncQueueWorker(new IMMIsIMMdateWorker(

callback

,DateCpp

,MainCycleCpp

));

}

//IMMIsIMMdateWorker::~IMMIsIMMdateWorker(){

//

//}

//IMMIsIMMdateWorker::Destroy(){

//

//}

void IMMIsIMMcodeWorker::Execute(){

try{

// loop on the input parameter and populate the return vector

QuantLibAddin::qlIMMIsIMMcodeBind bindObject =

boost::bind(

&QuantLib::IMM::isIMMcode

,_1

,mMainCycle

);

ObjectHandler::loop

<QuantLibAddin::qlIMMIsIMMcodeBind, string, bool>

(bindObject,

mCode,

mReturnValue

);

}catch(const std::exception &e){

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void IMMIsIMMcodeWorker::HandleOKCallback(){

Nan::HandleScope scope;

Local<Array> tmpArray = Nan::New<Array>(mReturnValue.size());

for (unsigned int i = 0; i < mReturnValue.size(); i++) {

Nan::Set(tmpArray,i,Nan::New<Boolean>(mReturnValue[i]));

}

Local<v8::Value> argv[2] = {

Nan::New<String>(mError).ToLocalChecked(),

tmpArray

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::IMMIsIMMcode) {

// validate js arguments

if (info.Length() == 0 || !info[0]->IsArray()) {

return Nan::ThrowError("Code is required.");

}

if (info.Length() == 1 || !info[1]->IsBoolean()) {

return Nan::ThrowError("MainCycle is required.");

}

// convert js argument to c++ type

std::vector<string>CodeCpp;

Local<Array> CodeArray = info[0].As<Array>();

for (unsigned int i = 0; i < CodeArray->Length(); i++){

String::Utf8Value strCode(Nan::Get(CodeArray, i).ToLocalChecked()->ToString());

CodeCpp.push_back(strdup(*strCode));