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

#include <nan.h>

#include <string.h>

#include "leg.hpp"

#include <qlo/qladdindefines.hpp>

#include <qlo/couponvectors.hpp>

#include <qlo/conundrumpricer.hpp>

#include <qlo/termstructures.hpp>

#include <qlo/capfloor.hpp>

#include <qlo/swap.hpp>

#include <ql/termstructures/yieldtermstructure.hpp>

#include <ql/instruments/swap.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 LegWorker::Execute(){

try{

// convert input datatypes to QuantLib datatypes

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

mDates, "Dates");

// Construct the Value Object

boost::shared_ptr<ObjectHandler::ValueObject> valueObject(

new QuantLibAddin::ValueObjects::qlLeg(

mObjectID,

mAmounts,

mDates,

mToBeSorted,

false

));

// Construct the Object

boost::shared_ptr<ObjectHandler::Object> object(

new QuantLibAddin::Leg(

valueObject,

mAmounts,

DatesLib,

mToBeSorted,

false

));

// Store the Object in the Repository

mReturnValue = ObjectHandler::Repository::instance().storeObject(mObjectID, object, false, valueObject);

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

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void LegWorker::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::Leg) {

// validate js arguments

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

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

}

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

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

}

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

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

}

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

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

}

// convert js argument to c++ type

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

string ObjectIDCpp(strdup(*strObjectID));

// convert js argument to c++ type

std::vector<double>AmountsCpp;

Local<Array> AmountsArray = info[1].As<Array>();

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

AmountsCpp.push_back(Nan::To<double>(Nan::Get(AmountsArray, i).ToLocalChecked()).FromJust());

}

// convert js argument to c++ type

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

Local<Array> DatesArray = info[2].As<Array>();

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

ObjectHandler::property_t tmp =

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

DatesCpp.push_back(tmp);

}

// convert js argument to c++ type

bool ToBeSortedCpp = Nan::To<bool>(info[3]).FromJust();

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new LegWorker(

callback

,ObjectIDCpp

,AmountsCpp

,DatesCpp

,ToBeSortedCpp

));

}

//LegWorker::~LegWorker(){

//

//}

//LegWorker::Destroy(){

//

//}

void LegFromCapFloorWorker::Execute(){

try{

// convert object IDs into library objects

OH_GET_REFERENCE(CapFloorLibObjPtr, mCapFloor,

QuantLibAddin::CapFloor, QuantLib::CapFloor)

// Construct the Value Object

boost::shared_ptr<ObjectHandler::ValueObject> valueObject(

new QuantLibAddin::ValueObjects::qlLegFromCapFloor(

mObjectID,

mCapFloor,

false

));

// Construct the Object

boost::shared_ptr<ObjectHandler::Object> object(

new QuantLibAddin::Leg(

valueObject,

CapFloorLibObjPtr,

false

));

// Store the Object in the Repository

mReturnValue = ObjectHandler::Repository::instance().storeObject(mObjectID, object, false, valueObject);

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

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void LegFromCapFloorWorker::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::LegFromCapFloor) {

// validate js arguments

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

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

}

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

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

}

// convert js argument to c++ type

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

string ObjectIDCpp(strdup(*strObjectID));

// convert js argument to c++ type

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

string CapFloorCpp(strdup(*strCapFloor));

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new LegFromCapFloorWorker(

callback

,ObjectIDCpp

,CapFloorCpp

));

}

//LegFromCapFloorWorker::~LegFromCapFloorWorker(){

//

//}

//LegFromCapFloorWorker::Destroy(){

//

//}

void LegFromSwapWorker::Execute(){

try{

// convert object IDs into library objects

OH_GET_REFERENCE(SwapLibObjPtr, mSwap,

QuantLibAddin::Swap, QuantLib::Swap)

// Construct the Value Object

boost::shared_ptr<ObjectHandler::ValueObject> valueObject(

new QuantLibAddin::ValueObjects::qlLegFromSwap(

mObjectID,

mSwap,

mLegNumber,

false

));

// Construct the Object

boost::shared_ptr<ObjectHandler::Object> object(

new QuantLibAddin::Leg(

valueObject,

SwapLibObjPtr,

mLegNumber,

false

));

// Store the Object in the Repository

mReturnValue = ObjectHandler::Repository::instance().storeObject(mObjectID, object, false, valueObject);

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

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void LegFromSwapWorker::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::LegFromSwap) {

// validate js arguments

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

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

}

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

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

}

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

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

}

// convert js argument to c++ type

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

string ObjectIDCpp(strdup(*strObjectID));

// convert js argument to c++ type

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

string SwapCpp(strdup(*strSwap));

// convert js argument to c++ type

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

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new LegFromSwapWorker(

callback

,ObjectIDCpp

,SwapCpp

,LegNumberCpp

));

}

//LegFromSwapWorker::~LegFromSwapWorker(){

//

//}

//LegFromSwapWorker::Destroy(){

//

//}

void MultiPhaseLegWorker::Execute(){

try{

// convert object IDs into library objects

std::vector< boost::shared_ptr<QuantLibAddin::Leg> > LegIDsObjPtr =

ObjectHandler::getObjectVector<QuantLibAddin::Leg>(mLegIDs);

// Construct the Value Object

boost::shared_ptr<ObjectHandler::ValueObject> valueObject(

new QuantLibAddin::ValueObjects::qlMultiPhaseLeg(

mObjectID,

mLegIDs,

mToBeSorted,

false

));

// Construct the Object

boost::shared_ptr<ObjectHandler::Object> object(

new QuantLibAddin::MultiPhaseLeg(

valueObject,

LegIDsObjPtr,

mToBeSorted,

false

));

// Store the Object in the Repository

mReturnValue = ObjectHandler::Repository::instance().storeObject(mObjectID, object, false, valueObject);

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

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void MultiPhaseLegWorker::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::MultiPhaseLeg) {

// validate js arguments

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

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

}

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

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

}

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

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

}

// convert js argument to c++ type

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

string ObjectIDCpp(strdup(*strObjectID));

// convert js argument to c++ type

std::vector<string>LegIDsCpp;

Local<Array> LegIDsArray = info[1].As<Array>();

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

String::Utf8Value strLegIDs(Nan::Get(LegIDsArray, i).ToLocalChecked()->ToString());

LegIDsCpp.push_back(strdup(*strLegIDs));

}

// convert js argument to c++ type

bool ToBeSortedCpp = Nan::To<bool>(info[2]).FromJust();

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new MultiPhaseLegWorker(

callback

,ObjectIDCpp

,LegIDsCpp

,ToBeSortedCpp

));

}

//MultiPhaseLegWorker::~MultiPhaseLegWorker(){

//

//}

//MultiPhaseLegWorker::Destroy(){

//

//}

void InterestRateWorker::Execute(){

try{

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::DayCounter DayCounterEnum =

ObjectHandler::Create<QuantLib::DayCounter>()(mDayCounter);

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::Compounding CompoundingEnum =

ObjectHandler::Create<QuantLib::Compounding>()(mCompounding);

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::Frequency FrequencyEnum =

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

// Construct the Value Object

boost::shared_ptr<ObjectHandler::ValueObject> valueObject(

new QuantLibAddin::ValueObjects::qlInterestRate(

mObjectID,

mRate,

mDayCounter,

mCompounding,

mFrequency,

false

));

// Construct the Object

boost::shared_ptr<ObjectHandler::Object> object(

new QuantLibAddin::InterestRate(

valueObject,

mRate,

DayCounterEnum,

CompoundingEnum,

FrequencyEnum,

false

));

// Store the Object in the Repository

mReturnValue = ObjectHandler::Repository::instance().storeObject(mObjectID, object, false, valueObject);

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

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void InterestRateWorker::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::InterestRate) {

// validate js arguments

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

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

}

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

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

}

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

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

}

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

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

}

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

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

}

// convert js argument to c++ type

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

string ObjectIDCpp(strdup(*strObjectID));

// convert js argument to c++ type

double RateCpp = Nan::To<double>(info[1]).FromJust();

// convert js argument to c++ type

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

string DayCounterCpp(strdup(*strDayCounter));

// convert js argument to c++ type

String::Utf8Value strCompounding(info[3]->ToString());

string CompoundingCpp(strdup(*strCompounding));

// convert js argument to c++ type

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

string FrequencyCpp(strdup(*strFrequency));

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new InterestRateWorker(

callback

,ObjectIDCpp

,RateCpp

,DayCounterCpp

,CompoundingCpp

,FrequencyCpp

));

}

//InterestRateWorker::~InterestRateWorker(){

//

//}

//InterestRateWorker::Destroy(){

//

//}

void LegFlowAnalysisWorker::Execute(){

try{

// convert input datatypes to QuantLib datatypes

QuantLib::Date AfterDateLib = ObjectHandler::convert2<QuantLib::Date>(

mAfterDate, "AfterDate");

// convert object IDs into library objects

OH_GET_OBJECT(ObjectIDObjPtr, mObjectID, QuantLibAddin::Leg)

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

// invoke the member function

returnValue = ObjectIDObjPtr->flowAnalysis(

AfterDateLib

);

mReturnValue = ObjectHandler::matrix::convert2<string>(returnValue,"returnValue");

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

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void LegFlowAnalysisWorker::HandleOKCallback(){

Nan::HandleScope scope;

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

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

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

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

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

}

Nan::Set(tmpMatrix,i,tmpArray);

}

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

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

tmpMatrix

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::LegFlowAnalysis) {

// validate js arguments

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

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

}

// convert js argument to c++ type

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

string ObjectIDCpp(strdup(*strObjectID));

// convert js argument to c++ type

ObjectHandler::property_t AfterDateCpp =

ObjectHandler::property_t(static_cast<long>(Nan::To<int32_t>(info[1]).FromJust()));

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new LegFlowAnalysisWorker(

callback

,ObjectIDCpp

,AfterDateCpp

));

}

//LegFlowAnalysisWorker::~LegFlowAnalysisWorker(){

//

//}

//LegFlowAnalysisWorker::Destroy(){

//

//}

void LegSetCouponPricersWorker::Execute(){

try{

// convert object IDs into library objects

std::vector< boost::shared_ptr<QuantLibAddin::FloatingRateCouponPricer> > FloatingRateCouponPricerObjPtr =

ObjectHandler::getObjectVector<QuantLibAddin::FloatingRateCouponPricer>(mFloatingRateCouponPricer);

// convert object IDs into library objects

OH_GET_OBJECT(ObjectIDObjPtr, mObjectID, QuantLibAddin::Leg)

// invoke the member function

ObjectIDObjPtr->setCouponPricers(

FloatingRateCouponPricerObjPtr

);

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

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void LegSetCouponPricersWorker::HandleOKCallback(){

Nan::HandleScope scope;

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

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

Nan::Null()

};

callback->Call(2, argv);

}

NAN_METHOD(QuantLibNode::LegSetCouponPricers) {

// validate js arguments

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

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

}

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

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

}

// convert js argument to c++ type

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

string ObjectIDCpp(strdup(*strObjectID));

// convert js argument to c++ type

std::vector<string>FloatingRateCouponPricerCpp;

Local<Array> FloatingRateCouponPricerArray = info[1].As<Array>();

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

String::Utf8Value strFloatingRateCouponPricer(Nan::Get(FloatingRateCouponPricerArray, i).ToLocalChecked()->ToString());

FloatingRateCouponPricerCpp.push_back(strdup(*strFloatingRateCouponPricer));

}

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new LegSetCouponPricersWorker(

callback

,ObjectIDCpp

,FloatingRateCouponPricerCpp

));

}

//LegSetCouponPricersWorker::~LegSetCouponPricersWorker(){

//

//}

//LegSetCouponPricersWorker::Destroy(){

//

//}

void InterestRateRateWorker::Execute(){

try{

// convert object IDs into library objects

OH_GET_REFERENCE(ObjectIDLibObjPtr, mObjectID,

QuantLibAddin::InterestRate, QuantLib::InterestRate)

// invoke the member function

mReturnValue = ObjectIDLibObjPtr->rate(

);

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

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void InterestRateRateWorker::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::InterestRateRate) {

// validate js arguments

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

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

}

// convert js argument to c++ type

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

string ObjectIDCpp(strdup(*strObjectID));

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new InterestRateRateWorker(

callback

,ObjectIDCpp

));

}

//InterestRateRateWorker::~InterestRateRateWorker(){

//

//}

//InterestRateRateWorker::Destroy(){

//

//}

void InterestRateDayCounterWorker::Execute(){

try{

// convert object IDs into library objects

OH_GET_REFERENCE(ObjectIDLibObjPtr, mObjectID,

QuantLibAddin::InterestRate, QuantLib::InterestRate)

// invoke the member function

QuantLib::DayCounter returnValue = ObjectIDLibObjPtr->dayCounter(

);

std::ostringstream os;

os << returnValue;

mReturnValue = os.str();

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

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void InterestRateDayCounterWorker::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::InterestRateDayCounter) {

// validate js arguments

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

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

}

// convert js argument to c++ type

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

string ObjectIDCpp(strdup(*strObjectID));

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new InterestRateDayCounterWorker(

callback

,ObjectIDCpp

));

}

//InterestRateDayCounterWorker::~InterestRateDayCounterWorker(){

//

//}

//InterestRateDayCounterWorker::Destroy(){

//

//}

void InterestRateCompoundingWorker::Execute(){

try{

// convert object IDs into library objects

OH_GET_REFERENCE(ObjectIDLibObjPtr, mObjectID,

QuantLibAddin::InterestRate, QuantLib::InterestRate)

// invoke the member function

QuantLib::Compounding returnValue = ObjectIDLibObjPtr->compounding(

);

std::ostringstream os;

os << returnValue;

mReturnValue = os.str();

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

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void InterestRateCompoundingWorker::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::InterestRateCompounding) {

// validate js arguments

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

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

}

// convert js argument to c++ type

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

string ObjectIDCpp(strdup(*strObjectID));

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new InterestRateCompoundingWorker(

callback

,ObjectIDCpp

));

}

//InterestRateCompoundingWorker::~InterestRateCompoundingWorker(){

//

//}

//InterestRateCompoundingWorker::Destroy(){

//

//}

void InterestRateFrequencyWorker::Execute(){

try{

// convert object IDs into library objects

OH_GET_REFERENCE(ObjectIDLibObjPtr, mObjectID,

QuantLibAddin::InterestRate, QuantLib::InterestRate)

// invoke the member function

QuantLib::Frequency returnValue = ObjectIDLibObjPtr->frequency(

);

std::ostringstream os;

os << returnValue;

mReturnValue = os.str();

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

mError = e.what();

}catch (...){

mError = "unkown error";

}

}

void InterestRateFrequencyWorker::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::InterestRateFrequency) {

// validate js arguments

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

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

}

// convert js argument to c++ type

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

string ObjectIDCpp(strdup(*strObjectID));

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new InterestRateFrequencyWorker(

callback

,ObjectIDCpp

));

}

//InterestRateFrequencyWorker::~InterestRateFrequencyWorker(){

//

//}

//InterestRateFrequencyWorker::Destroy(){

//

//}

void InterestRateDiscountFactorWorker::Execute(){

try{

// convert object IDs into library objects

OH_GET_REFERENCE(ObjectIDLibObjPtr, mObjectID,

QuantLibAddin::InterestRate, QuantLib::InterestRate)

// convert input datatypes to QuantLib datatypes

QuantLib::Date StartDateLib = ObjectHandler::convert2<QuantLib::Date>(

mStartDate, "StartDate");

// convert input datatypes to QuantLib datatypes

QuantLib::Date EndDateLib = ObjectHandler::convert2<QuantLib::Date>(

mEndDate, "EndDate");

// convert input datatypes to QuantLib datatypes

QuantLib::Date RefPeriodStartLib = ObjectHandler::convert2<QuantLib::Date>(

mRefPeriodStart, "RefPeriodStart");

// convert input datatypes to QuantLib datatypes

QuantLib::Date RefPeriodEndLib = ObjectHandler::convert2<QuantLib::Date>(

mRefPeriodEnd, "RefPeriodEnd");

// invoke the member function

QuantLib::Real returnValue = ObjectIDLibObjPtr->discountFactor(

StartDateLib

,

EndDateLib

,

RefPeriodStartLib