/*

Copyright (C) 2016 Jerry Jin

*/

#include <nan.h>

#include <string.h>

#include "capletvolstructure.hpp"

#include <qlo/qladdindefines.hpp>

#include <qlo/indexes/iborindex.hpp>

#include <qlo/capletvolstructure.hpp>

#include <qlo/quote.hpp>

#include <qlo/termstructures.hpp>

#include <qlo/handleimpl.hpp>

#include <ql/termstructures/volatility/optionlet/optionletvolatilitystructure.hpp>

#include <ql/termstructures/volatility/optionlet/constantoptionletvol.hpp>

#include <ql/termstructures/volatility/optionlet/optionletstripper1.hpp>

#include <ql/termstructures/volatility/optionlet/optionletstripper2.hpp>

#include <ql/termstructures/volatility/capfloor/capfloortermvolcurve.hpp>

#include <ql/termstructures/volatility/capfloor/capfloortermvolsurface.hpp>

#include <ql/indexes/iborindex.hpp>

#include <qlo/loop/loop_capletvolstructure.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 RelinkableHandleOptionletVolatilityStructureWorker::Execute(){

try{

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlRelinkableHandleOptionletVolatilityStructure(

mObjectID,

mCurrentLink,

false

));

// Construct the Object

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

new QuantLibAddin::RelinkableHandleImpl<QuantLibAddin::OptionletVolatilityStructure, QuantLib::OptionletVolatilityStructure>(

valueObject,

mCurrentLink,

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 RelinkableHandleOptionletVolatilityStructureWorker::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::RelinkableHandleOptionletVolatilityStructure) {

// 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("CurrentLink 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 strCurrentLink(info[1]->ToString());

string CurrentLinkCpp(strdup(*strCurrentLink));

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new RelinkableHandleOptionletVolatilityStructureWorker(

callback

,ObjectIDCpp

,CurrentLinkCpp

));

}

//RelinkableHandleOptionletVolatilityStructureWorker::~RelinkableHandleOptionletVolatilityStructureWorker(){

//

//}

//void RelinkableHandleOptionletVolatilityStructureWorker::Destroy(){

//

//}

void ConstantOptionletVolatilityWorker::Execute(){

try{

// convert input datatypes to QuantLib datatypes

QuantLib::Size NDaysLib;

QuantLibAddin::cppToLibrary(mNDays, NDaysLib);

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::Calendar CalendarEnum =

ObjectHandler::Create<QuantLib::Calendar>()(mCalendar);

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::BusinessDayConvention BusinessDayConventionEnum =

ObjectHandler::Create<QuantLib::BusinessDayConvention>()(mBusinessDayConvention);

// convert object IDs into library objects

QuantLib::Handle<QuantLib::Quote> VolatilityLibObj =

ObjectHandler::convert2< QuantLib::Handle<QuantLib::Quote> >(mVolatility, "Volatility");

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::DayCounter DayCounterEnum =

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

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlConstantOptionletVolatility(

mObjectID,

mNDays,

mCalendar,

mBusinessDayConvention,

mVolatility,

mDayCounter,

false

));

// Construct the Object

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

new QuantLibAddin::ConstantOptionletVolatility(

valueObject,

NDaysLib,

CalendarEnum,

BusinessDayConventionEnum,

VolatilityLibObj,

DayCounterEnum,

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 ConstantOptionletVolatilityWorker::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::ConstantOptionletVolatility) {

// 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("NDays is required.");

}

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

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

}

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

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

}

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

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

}

// convert js argument to c++ type

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

string ObjectIDCpp(strdup(*strObjectID));

// convert js argument to c++ type

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

// convert js argument to c++ type

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

string CalendarCpp(strdup(*strCalendar));

// convert js argument to c++ type

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

string BusinessDayConventionCpp(strdup(*strBusinessDayConvention));

// convert js argument to c++ type

ObjectHandler::property_t VolatilityCpp =

ObjectHandler::property_t(static_cast<double>(Nan::To<double>(info[4]).FromJust()));

// convert js argument to c++ type

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

string DayCounterCpp(strdup(*strDayCounter));

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new ConstantOptionletVolatilityWorker(

callback

,ObjectIDCpp

,NDaysCpp

,CalendarCpp

,BusinessDayConventionCpp

,VolatilityCpp

,DayCounterCpp

));

}

//ConstantOptionletVolatilityWorker::~ConstantOptionletVolatilityWorker(){

//

//}

//void ConstantOptionletVolatilityWorker::Destroy(){

//

//}

void SpreadedOptionletVolatilityWorker::Execute(){

try{

// convert object IDs into library objects

OH_GET_OBJECT(BaseVolStructureCoerce, mBaseVolStructure, ObjectHandler::Object)

QuantLib::Handle<QuantLib::OptionletVolatilityStructure> BaseVolStructureLibObj =

QuantLibAddin::CoerceHandle<

QuantLibAddin::OptionletVolatilityStructure,

QuantLib::OptionletVolatilityStructure>()(

BaseVolStructureCoerce);

// convert object IDs into library objects

QuantLib::Handle<QuantLib::Quote> SpreadLibObj =

ObjectHandler::convert2< QuantLib::Handle<QuantLib::Quote> >(mSpread, "Spread");

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlSpreadedOptionletVolatility(

mObjectID,

mBaseVolStructure,

mSpread,

false

));

// Construct the Object

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

new QuantLibAddin::SpreadedOptionletVolatility(

valueObject,

BaseVolStructureLibObj,

SpreadLibObj,

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 SpreadedOptionletVolatilityWorker::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::SpreadedOptionletVolatility) {

// 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 BaseVolStructureCpp =

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

// convert js argument to c++ type

ObjectHandler::property_t SpreadCpp =

ObjectHandler::property_t(static_cast<double>(Nan::To<double>(info[2]).FromJust()));

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new SpreadedOptionletVolatilityWorker(

callback

,ObjectIDCpp

,BaseVolStructureCpp

,SpreadCpp

));

}

//SpreadedOptionletVolatilityWorker::~SpreadedOptionletVolatilityWorker(){

//

//}

//void SpreadedOptionletVolatilityWorker::Destroy(){

//

//}

void StrippedOptionletAdapterWorker::Execute(){

try{

// convert object IDs into library objects

OH_GET_REFERENCE(StrippedOptionletBaseLibObjPtr, mStrippedOptionletBase,

QuantLibAddin::StrippedOptionletBase, QuantLib::StrippedOptionletBase)

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlStrippedOptionletAdapter(

mObjectID,

mStrippedOptionletBase,

false

));

// Construct the Object

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

new QuantLibAddin::StrippedOptionletAdapter(

valueObject,

StrippedOptionletBaseLibObjPtr,

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 StrippedOptionletAdapterWorker::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::StrippedOptionletAdapter) {

// 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("StrippedOptionletBase 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 strStrippedOptionletBase(info[1]->ToString());

string StrippedOptionletBaseCpp(strdup(*strStrippedOptionletBase));

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new StrippedOptionletAdapterWorker(

callback

,ObjectIDCpp

,StrippedOptionletBaseCpp

));

}

//StrippedOptionletAdapterWorker::~StrippedOptionletAdapterWorker(){

//

//}

//void StrippedOptionletAdapterWorker::Destroy(){

//

//}

void StrippedOptionletWorker::Execute(){

try{

// convert input datatypes to QuantLib datatypes

QuantLib::Size SettlementDaysLib;

QuantLibAddin::cppToLibrary(mSettlementDays, SettlementDaysLib);

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::Calendar CalendarEnum =

ObjectHandler::Create<QuantLib::Calendar>()(mCalendar);

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::BusinessDayConvention BusinessDayConventionEnum =

ObjectHandler::Create<QuantLib::BusinessDayConvention>()(mBusinessDayConvention);

// convert object IDs into library objects

OH_GET_REFERENCE(IborIndexLibObjPtr, mIborIndex,

QuantLibAddin::IborIndex, QuantLib::IborIndex)

// convert input datatypes to QuantLib datatypes

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

mOptionletDates, "OptionletDates");

// convert object IDs into library objects

std::vector< std::vector< QuantLib::Handle<QuantLib::Quote> > > VolatilitiesLibObj =

ObjectHandler::matrix::convert2< QuantLib::Handle<QuantLib::Quote> >(mVolatilities, "Volatilities");

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::DayCounter DayCounterEnum =

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

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlStrippedOptionlet(

mObjectID,

mSettlementDays,

mCalendar,

mBusinessDayConvention,

mIborIndex,

mOptionletDates,

mStrikes,

mVolatilities,

mDayCounter,

false

));

// Construct the Object

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

new QuantLibAddin::StrippedOptionlet(

valueObject,

SettlementDaysLib,

CalendarEnum,

BusinessDayConventionEnum,

IborIndexLibObjPtr,

OptionletDatesLib,

mStrikes,

VolatilitiesLibObj,

DayCounterEnum,

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 StrippedOptionletWorker::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::StrippedOptionlet) {

// 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("SettlementDays is required.");

}

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

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

}

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

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

}

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

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

}

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

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

}

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

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

}

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

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

}

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

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

}

// convert js argument to c++ type

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

string ObjectIDCpp(strdup(*strObjectID));

// convert js argument to c++ type

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

// convert js argument to c++ type

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

string CalendarCpp(strdup(*strCalendar));

// convert js argument to c++ type

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

string BusinessDayConventionCpp(strdup(*strBusinessDayConvention));

// convert js argument to c++ type

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

string IborIndexCpp(strdup(*strIborIndex));

// convert js argument to c++ type

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

Local<Array> OptionletDatesArray = info[5].As<Array>();

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

ObjectHandler::property_t tmp =

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

OptionletDatesCpp.push_back(tmp);

}

// convert js argument to c++ type

std::vector<double>StrikesCpp;

Local<Array> StrikesArray = info[6].As<Array>();

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

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

}

// convert js argument to c++ type

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

Local<Array> VolatilitiesMatrix = info[7].As<Array>();

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

Local<Array> VolatilitiesArray = VolatilitiesMatrix->Get(i).As<Array>();

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

for (unsigned int j = 0; j < VolatilitiesArray->Length(); j++){

ObjectHandler::property_t temp =

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

tmp.push_back(temp);

}

VolatilitiesCpp.push_back(tmp);

}

// convert js argument to c++ type

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

string DayCounterCpp(strdup(*strDayCounter));

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new StrippedOptionletWorker(

callback

,ObjectIDCpp

,SettlementDaysCpp

,CalendarCpp

,BusinessDayConventionCpp

,IborIndexCpp

,OptionletDatesCpp

,StrikesCpp

,VolatilitiesCpp

,DayCounterCpp

));

}

//StrippedOptionletWorker::~StrippedOptionletWorker(){

//

//}

//void StrippedOptionletWorker::Destroy(){

//

//}

void OptionletStripper1Worker::Execute(){

try{

// convert object IDs into library objects

OH_GET_REFERENCE(TermVolSurfaceLibObjPtr, mTermVolSurface,

QuantLibAddin::CapFloorTermVolSurface, QuantLib::CapFloorTermVolSurface)

// convert object IDs into library objects

OH_GET_REFERENCE(IborIndexLibObjPtr, mIborIndex,

QuantLibAddin::IborIndex, QuantLib::IborIndex)

// convert input datatypes to QuantLib datatypes

// convert input datatypes to QuantLib datatypes

QuantLib::Natural MaxIterLib = ObjectHandler::convert2<long>(

mMaxIter, "MaxIter", QuantLib::Null<QuantLib::Natural>());

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlOptionletStripper1(

mObjectID,

mTermVolSurface,

mIborIndex,

mSwitchStrike,

mAccuracy,

mMaxIter,

false

));

// Construct the Object

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

new QuantLibAddin::OptionletStripper1(

valueObject,

TermVolSurfaceLibObjPtr,

IborIndexLibObjPtr,

mSwitchStrike,

mAccuracy,

MaxIterLib,

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 OptionletStripper1Worker::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::OptionletStripper1) {

// 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("TermVolSurface is required.");

}

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

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

}

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

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

}

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

return Nan::ThrowError("Accuracy 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 strTermVolSurface(info[1]->ToString());

string TermVolSurfaceCpp(strdup(*strTermVolSurface));

// convert js argument to c++ type

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

string IborIndexCpp(strdup(*strIborIndex));

// convert js argument to c++ type

double SwitchStrikeCpp = Nan::To<double>(info[3]).FromJust();

// convert js argument to c++ type

double AccuracyCpp = Nan::To<double>(info[4]).FromJust();

// convert js argument to c++ type

ObjectHandler::property_t MaxIterCpp =

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

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new OptionletStripper1Worker(

callback

,ObjectIDCpp

,TermVolSurfaceCpp

,IborIndexCpp

,SwitchStrikeCpp

,AccuracyCpp

,MaxIterCpp

));

}

//OptionletStripper1Worker::~OptionletStripper1Worker(){

//

//}

//void OptionletStripper1Worker::Destroy(){

//

//}

void OptionletStripper2Worker::Execute(){

try{

// convert object IDs into library objects

OH_GET_REFERENCE(OptionletStripper1LibObjPtr, mOptionletStripper1,

QuantLibAddin::OptionletStripper1, QuantLib::OptionletStripper1)

// convert object IDs into library objects

OH_GET_OBJECT(TermVolCurveCoerce, mTermVolCurve, ObjectHandler::Object)

QuantLib::Handle<QuantLib::CapFloorTermVolCurve> TermVolCurveLibObj =

QuantLibAddin::CoerceHandle<

QuantLibAddin::CapFloorTermVolCurve,

QuantLib::CapFloorTermVolCurve>()(

TermVolCurveCoerce);

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlOptionletStripper2(

mObjectID,

mOptionletStripper1,

mTermVolCurve,

false

));

// Construct the Object

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

new QuantLibAddin::OptionletStripper2(

valueObject,

OptionletStripper1LibObjPtr,

TermVolCurveLibObj,

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 OptionletStripper2Worker::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::OptionletStripper2) {

// 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("OptionletStripper1 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 strOptionletStripper1(info[1]->ToString());

string OptionletStripper1Cpp(strdup(*strOptionletStripper1));

// convert js argument to c++ type

ObjectHandler::property_t TermVolCurveCpp =

ObjectHandler::property_t(static_cast<double>(Nan::To<double>(info[2]).FromJust()));

// declare callback

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

// launch Async worker

Nan::AsyncQueueWorker(new OptionletStripper2Worker(

callback

,ObjectIDCpp

,OptionletStripper1Cpp

,TermVolCurveCpp

));

}

//OptionletStripper2Worker::~OptionletStripper2Worker(){

//

//}

//void OptionletStripper2Worker::Destroy(){

//

//}

void CapFloorTermVolCurveWorker::Execute(){

try{

// convert input datatypes to QuantLib datatypes

QuantLib::Size SettlementDaysLib;

QuantLibAddin::cppToLibrary(mSettlementDays, SettlementDaysLib);

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::Calendar CalendarEnum =

ObjectHandler::Create<QuantLib::Calendar>()(mCalendar);

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::BusinessDayConvention BusinessDayConventionEnum =

ObjectHandler::Create<QuantLib::BusinessDayConvention>()(mBusinessDayConvention);

// convert input datatypes to QuantLib datatypes

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

// convert object IDs into library objects

std::vector< QuantLib::Handle<QuantLib::Quote> > VolatilitiesLibObj =

ObjectHandler::vector::convert2< QuantLib::Handle<QuantLib::Quote> >(mVolatilities, "Volatilities");

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::DayCounter DayCounterEnum =

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

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlCapFloorTermVolCurve(

mObjectID,

mSettlementDays,

mCalendar,

mBusinessDayConvention,

mOptionTenors,

mVolatilities,

mDayCounter,

false

));

// Construct the Object

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

new QuantLibAddin::CapFloorTermVolCurve(

valueObject,

SettlementDaysLib,

CalendarEnum,

BusinessDayConventionEnum,

OptionTenorsLib,

VolatilitiesLibObj,

DayCounterEnum,

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 CapFloorTermVolCurveWorker::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::CapFloorTermVolCurve) {

// 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("SettlementDays is required.");

}

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

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

}

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

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

}

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

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

}

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

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

}

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

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

}

// convert js argument to c++ type

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

string ObjectIDCpp(strdup(*strObjectID));

// convert js argument to c++ type

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

// convert js argument to c++ type

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

string CalendarCpp(strdup(*strCalendar));

// convert js argument to c++ type

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

string BusinessDayConventionCpp(strdup(*strBusinessDayConvention));

// convert js argument to c++ type

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

Local<Array> OptionTenorsArray = info[4].As<Array>();

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

ObjectHandler::property_t tmp =

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