/*

Copyright (C) 2016 -2017 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";

}

}

NAN_METHOD(QuantLibXL::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));

// launch worker

RelinkableHandleOptionletVolatilityStructureWorker* worker = new RelinkableHandleOptionletVolatilityStructureWorker(

ObjectIDCpp

, CurrentLinkCpp

);

worker->Execute();

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

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

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

};

v8::Local<v8::Array> results = Nan::New<v8::Array>();

Nan::Set(results, 0, argv[0]);

Nan::Set(results, 1, argv[1]);

info.GetReturnValue().Set(results);

}

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);

// convert input datatypes to QuantLib datatypes

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlConstantOptionletVolatility(

mObjectID,

mNDays,

mCalendar,

mBusinessDayConvention,

mVolatility,

mDayCounter,

mVolatilityType,

mDisplacement,

false

));

// Construct the Object

std::map<std::string, QuantLib::VolatilityType> strEnum;

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

new QuantLibAddin::ConstantOptionletVolatility(

valueObject,

NDaysLib,

CalendarEnum,

BusinessDayConventionEnum,

VolatilityLibObj,

DayCounterEnum,

strEnum[mVolatilityType],

mDisplacement,

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";

}

}

NAN_METHOD(QuantLibXL::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.");

}

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

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

}

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

return Nan::ThrowError("Displacement 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));

// convert js argument to c++ type

String::Utf8Value strVolatilityType(info[6]->ToString());

string VolatilityTypeCpp(strdup(*strVolatilityType));

// convert js argument to c++ type

double DisplacementCpp = Nan::To<double>(info[7]).FromJust();

// launch worker

ConstantOptionletVolatilityWorker* worker = new ConstantOptionletVolatilityWorker(

ObjectIDCpp

, NDaysCpp

, CalendarCpp

, BusinessDayConventionCpp

, VolatilityCpp

, DayCounterCpp

, VolatilityTypeCpp

, DisplacementCpp

);

worker->Execute();

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

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

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

};

v8::Local<v8::Array> results = Nan::New<v8::Array>();

Nan::Set(results, 0, argv[0]);

Nan::Set(results, 1, argv[1]);

info.GetReturnValue().Set(results);

}

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";

}

}

NAN_METHOD(QuantLibXL::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()));

// launch worker

SpreadedOptionletVolatilityWorker* worker = new SpreadedOptionletVolatilityWorker(

ObjectIDCpp

, BaseVolStructureCpp

, SpreadCpp

);

worker->Execute();

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

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

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

};

v8::Local<v8::Array> results = Nan::New<v8::Array>();

Nan::Set(results, 0, argv[0]);

Nan::Set(results, 1, argv[1]);

info.GetReturnValue().Set(results);

}

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";

}

}

NAN_METHOD(QuantLibXL::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));

// launch worker

StrippedOptionletAdapterWorker* worker = new StrippedOptionletAdapterWorker(

ObjectIDCpp

, StrippedOptionletBaseCpp

);

worker->Execute();

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

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

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

};

v8::Local<v8::Array> results = Nan::New<v8::Array>();

Nan::Set(results, 0, argv[0]);

Nan::Set(results, 1, argv[1]);

info.GetReturnValue().Set(results);

}

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);

// convert input datatypes to QuantLib datatypes

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlStrippedOptionlet(

mObjectID,

mSettlementDays,

mCalendar,

mBusinessDayConvention,

mIborIndex,

mOptionletDates,

mStrikes,

mVolatilities,

mDayCounter,

mVolatilityType,

mDisplacement,

false

));

// Construct the Object

std::map<std::string, QuantLib::VolatilityType> strEnum;

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

new QuantLibAddin::StrippedOptionlet(

valueObject,

SettlementDaysLib,

CalendarEnum,

BusinessDayConventionEnum,

IborIndexLibObjPtr,

OptionletDatesLib,

mStrikes,

VolatilitiesLibObj,

DayCounterEnum,

strEnum[mVolatilityType],

mDisplacement,

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";

}

}

NAN_METHOD(QuantLibXL::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.");

}

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

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

}

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

return Nan::ThrowError("Displacement 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));

// convert js argument to c++ type

String::Utf8Value strVolatilityType(info[9]->ToString());

string VolatilityTypeCpp(strdup(*strVolatilityType));

// convert js argument to c++ type

double DisplacementCpp = Nan::To<double>(info[10]).FromJust();

// launch worker

StrippedOptionletWorker* worker = new StrippedOptionletWorker(

ObjectIDCpp

, SettlementDaysCpp

, CalendarCpp

, BusinessDayConventionCpp

, IborIndexCpp

, OptionletDatesCpp

, StrikesCpp

, VolatilitiesCpp

, DayCounterCpp

, VolatilityTypeCpp

, DisplacementCpp

);

worker->Execute();

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

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

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

};

v8::Local<v8::Array> results = Nan::New<v8::Array>();

Nan::Set(results, 0, argv[0]);

Nan::Set(results, 1, argv[1]);

info.GetReturnValue().Set(results);

}

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>());

// convert input datatypes to QuantLib datatypes

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlOptionletStripper1(

mObjectID,

mTermVolSurface,

mIborIndex,

mSwitchStrike,

mAccuracy,

mMaxIter,

mVolatilityType,

mDisplacement,

false

));

// Construct the Object

std::map<std::string, QuantLib::VolatilityType> strEnum;

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

new QuantLibAddin::OptionletStripper1(

valueObject,

TermVolSurfaceLibObjPtr,

IborIndexLibObjPtr,

mSwitchStrike,

mAccuracy,

MaxIterLib,

strEnum[mVolatilityType],

mDisplacement,

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";

}

}

NAN_METHOD(QuantLibXL::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.");

}

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

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

}

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

return Nan::ThrowError("Displacement 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()));

// convert js argument to c++ type

String::Utf8Value strVolatilityType(info[6]->ToString());

string VolatilityTypeCpp(strdup(*strVolatilityType));

// convert js argument to c++ type

double DisplacementCpp = Nan::To<double>(info[7]).FromJust();

// launch worker

OptionletStripper1Worker* worker = new OptionletStripper1Worker(

ObjectIDCpp

, TermVolSurfaceCpp

, IborIndexCpp

, SwitchStrikeCpp

, AccuracyCpp

, MaxIterCpp

, VolatilityTypeCpp

, DisplacementCpp

);

worker->Execute();

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

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

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

};

v8::Local<v8::Array> results = Nan::New<v8::Array>();

Nan::Set(results, 0, argv[0]);

Nan::Set(results, 1, argv[1]);

info.GetReturnValue().Set(results);

}

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";

}

}

NAN_METHOD(QuantLibXL::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()));

// launch worker

OptionletStripper2Worker* worker = new OptionletStripper2Worker(

ObjectIDCpp

, OptionletStripper1Cpp

, TermVolCurveCpp

);

worker->Execute();

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

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

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

};

v8::Local<v8::Array> results = Nan::New<v8::Array>();

Nan::Set(results, 0, argv[0]);

Nan::Set(results, 1, argv[1]);

info.GetReturnValue().Set(results);

}

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";

}

}

NAN_METHOD(QuantLibXL::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()));

OptionTenorsCpp.push_back(tmp);

}

// convert js argument to c++ type

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

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

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

ObjectHandler::property_t tmp =

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

VolatilitiesCpp.push_back(tmp);

}

// convert js argument to c++ type

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

string DayCounterCpp(strdup(*strDayCounter));

// launch worker

CapFloorTermVolCurveWorker* worker = new CapFloorTermVolCurveWorker(

ObjectIDCpp

, SettlementDaysCpp

, CalendarCpp