/*

Copyright (C) 2016 -2017 Jerry Jin

*/

#include <nan.h>

#include <string.h>

#include "pricingengines.hpp"

#include <qlo/qladdindefines.hpp>

#include <qlo/pricingengines.hpp>

#include <qlo/termstructures.hpp>

#include <qlo/shortratemodels.hpp>

#include <qlo/payoffs.hpp>

#include <qlo/marketmodels.hpp>

#include <qlo/processes.hpp>

#include <ql/pricingengines/blackformula.hpp>

#include <ql/pricingengines/blackscholescalculator.hpp>

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

#include <ql/termstructures/volatility/swaption/swaptionvolstructure.hpp>

#include <ql/pricingengines/swaption/jamshidianswaptionengine.hpp>

#include <ql/pricingengines/swaption/g2swaptionengine.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 BlackCalculator2Worker::Execute(){

try{

// convert object IDs into library objects

OH_GET_REFERENCE(PayoffIDLibObjPtr, mPayoffID,

QuantLibAddin::StrikedTypePayoff, QuantLib::StrikedTypePayoff)

// convert input datatypes to QuantLib datatypes

// convert input datatypes to QuantLib datatypes

// convert input datatypes to QuantLib datatypes

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlBlackCalculator2(

mObjectID,

mPayoffID,

mAtmForwardValue,

mStdDev,

mDeflator,

false

));

// Construct the Object

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

new QuantLibAddin::BlackCalculator(

valueObject,

PayoffIDLibObjPtr,

mAtmForwardValue,

mStdDev,

mDeflator,

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::BlackCalculator2) {

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

}

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

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

}

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

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

}

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

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

string PayoffIDCpp(strdup(*strPayoffID));

// convert js argument to c++ type

double AtmForwardValueCpp = Nan::To<double>(info[2]).FromJust();

// convert js argument to c++ type

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

// convert js argument to c++ type

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

// launch worker

BlackCalculator2Worker* worker = new BlackCalculator2Worker(

ObjectIDCpp

, PayoffIDCpp

, AtmForwardValueCpp

, StdDevCpp

, DeflatorCpp

);

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 BlackCalculatorWorker::Execute(){

try{

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::Option::Type OptionTypeEnum =

ObjectHandler::Create<QuantLib::Option::Type>()(mOptionType);

// convert input datatypes to QuantLib datatypes

// convert input datatypes to QuantLib datatypes

// convert input datatypes to QuantLib datatypes

// convert input datatypes to QuantLib datatypes

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlBlackCalculator(

mObjectID,

mOptionType,

mStrike,

mAtmForwardValue,

mStdDev,

mDeflator,

false

));

// Construct the Object

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

new QuantLibAddin::BlackCalculator(

valueObject,

OptionTypeEnum,

mStrike,

mAtmForwardValue,

mStdDev,

mDeflator,

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::BlackCalculator) {

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

}

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

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

}

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

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

}

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

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

}

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

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

string OptionTypeCpp(strdup(*strOptionType));

// convert js argument to c++ type

double StrikeCpp = Nan::To<double>(info[2]).FromJust();

// convert js argument to c++ type

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

// convert js argument to c++ type

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

// convert js argument to c++ type

double DeflatorCpp = Nan::To<double>(info[5]).FromJust();

// launch worker

BlackCalculatorWorker* worker = new BlackCalculatorWorker(

ObjectIDCpp

, OptionTypeCpp

, StrikeCpp

, AtmForwardValueCpp

, StdDevCpp

, DeflatorCpp

);

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 BlackScholesCalculator2Worker::Execute(){

try{

// convert object IDs into library objects

OH_GET_REFERENCE(PayoffIDLibObjPtr, mPayoffID,

QuantLibAddin::StrikedTypePayoff, QuantLib::StrikedTypePayoff)

// convert input datatypes to QuantLib datatypes

// convert input datatypes to QuantLib datatypes

// convert input datatypes to QuantLib datatypes

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlBlackScholesCalculator2(

mObjectID,

mPayoffID,

mSpot,

mGrowth,

mStdDev,

mDeflator,

false

));

// Construct the Object

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

new QuantLibAddin::BlackScholesCalculator(

valueObject,

PayoffIDLibObjPtr,

mSpot,

mGrowth,

mStdDev,

mDeflator,

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::BlackScholesCalculator2) {

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

}

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

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

}

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

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

}

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

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

}

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

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

string PayoffIDCpp(strdup(*strPayoffID));

// convert js argument to c++ type

double SpotCpp = Nan::To<double>(info[2]).FromJust();

// convert js argument to c++ type

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

// convert js argument to c++ type

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

// convert js argument to c++ type

double DeflatorCpp = Nan::To<double>(info[5]).FromJust();

// launch worker

BlackScholesCalculator2Worker* worker = new BlackScholesCalculator2Worker(

ObjectIDCpp

, PayoffIDCpp

, SpotCpp

, GrowthCpp

, StdDevCpp

, DeflatorCpp

);

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 BlackScholesCalculatorWorker::Execute(){

try{

// convert input datatypes to QuantLib enumerated datatypes

QuantLib::Option::Type OptionTypeEnum =

ObjectHandler::Create<QuantLib::Option::Type>()(mOptionType);

// convert input datatypes to QuantLib datatypes

// convert input datatypes to QuantLib datatypes

// convert input datatypes to QuantLib datatypes

// convert input datatypes to QuantLib datatypes

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlBlackScholesCalculator(

mObjectID,

mOptionType,

mStrike,

mSpot,

mGrowth,

mStdDev,

mDeflator,

false

));

// Construct the Object

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

new QuantLibAddin::BlackScholesCalculator(

valueObject,

OptionTypeEnum,

mStrike,

mSpot,

mGrowth,

mStdDev,

mDeflator,

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::BlackScholesCalculator) {

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

}

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

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

}

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

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

}

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

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

}

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

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

}

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

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

string OptionTypeCpp(strdup(*strOptionType));

// convert js argument to c++ type

double StrikeCpp = Nan::To<double>(info[2]).FromJust();

// convert js argument to c++ type

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

// convert js argument to c++ type

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

// convert js argument to c++ type

double StdDevCpp = Nan::To<double>(info[5]).FromJust();

// convert js argument to c++ type

double DeflatorCpp = Nan::To<double>(info[6]).FromJust();

// launch worker

BlackScholesCalculatorWorker* worker = new BlackScholesCalculatorWorker(

ObjectIDCpp

, OptionTypeCpp

, StrikeCpp

, SpotCpp

, GrowthCpp

, StdDevCpp

, DeflatorCpp

);

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 PricingEngineWorker::Execute(){

try{

// convert object IDs into library objects

OH_GET_REFERENCE(ProcessIDLibObjPtr, mProcessID,

QuantLibAddin::GeneralizedBlackScholesProcess, QuantLib::GeneralizedBlackScholesProcess)

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlPricingEngine(

mObjectID,

mEngineID,

mProcessID,

false

));

// Construct the Object

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

new QuantLibAddin::PricingEngine(

valueObject,

mEngineID,

ProcessIDLibObjPtr,

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::PricingEngine) {

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

}

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

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

string EngineIDCpp(strdup(*strEngineID));

// convert js argument to c++ type

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

string ProcessIDCpp(strdup(*strProcessID));

// launch worker

PricingEngineWorker* worker = new PricingEngineWorker(

ObjectIDCpp

, EngineIDCpp

, ProcessIDCpp

);

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 DiscountingSwapEngineWorker::Execute(){

try{

// convert object IDs into library objects

OH_GET_OBJECT(YieldCurveCoerce, mYieldCurve, ObjectHandler::Object)

QuantLib::Handle<QuantLib::YieldTermStructure> YieldCurveLibObj =

QuantLibAddin::CoerceHandle<

QuantLibAddin::YieldTermStructure,

QuantLib::YieldTermStructure>()(

YieldCurveCoerce);

// convert input datatypes to QuantLib datatypes

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

mSettlementDate, "SettlementDate");

// convert input datatypes to QuantLib datatypes

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

mNpvDate, "NpvDate");

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlDiscountingSwapEngine(

mObjectID,

mYieldCurve,

mIncludeSettlDate,

mSettlementDate,

mNpvDate,

false

));

// Construct the Object

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

new QuantLibAddin::DiscountingSwapEngine(

valueObject,

YieldCurveLibObj,

mIncludeSettlDate,

SettlementDateLib,

NpvDateLib,

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::DiscountingSwapEngine) {

// validate js arguments

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

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

}

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

return Nan::ThrowError("IncludeSettlDate 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 YieldCurveCpp =

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

// convert js argument to c++ type

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

// convert js argument to c++ type

ObjectHandler::property_t SettlementDateCpp =

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

// convert js argument to c++ type

ObjectHandler::property_t NpvDateCpp =

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

// launch worker

DiscountingSwapEngineWorker* worker = new DiscountingSwapEngineWorker(

ObjectIDCpp

, YieldCurveCpp

, IncludeSettlDateCpp

, SettlementDateCpp

, NpvDateCpp

);

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 BinomialPricingEngineWorker::Execute(){

try{

// convert object IDs into library objects

OH_GET_REFERENCE(ProcessIDLibObjPtr, mProcessID,

QuantLibAddin::GeneralizedBlackScholesProcess, QuantLib::GeneralizedBlackScholesProcess)

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlBinomialPricingEngine(

mObjectID,

mEngineID,

mProcessID,

mTimeSteps,

false

));

// Construct the Object

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

new QuantLibAddin::PricingEngine(

valueObject,

mEngineID,

ProcessIDLibObjPtr,

mTimeSteps,

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::BinomialPricingEngine) {

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

}

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

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

}

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

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

string EngineIDCpp(strdup(*strEngineID));

// convert js argument to c++ type

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

string ProcessIDCpp(strdup(*strProcessID));

// convert js argument to c++ type

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

// launch worker

BinomialPricingEngineWorker* worker = new BinomialPricingEngineWorker(

ObjectIDCpp

, EngineIDCpp

, ProcessIDCpp

, TimeStepsCpp

);

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 BlackSwaptionEngineWorker::Execute(){

try{

// convert object IDs into library objects

OH_GET_OBJECT(YieldCurveCoerce, mYieldCurve, ObjectHandler::Object)

QuantLib::Handle<QuantLib::YieldTermStructure> YieldCurveLibObj =

QuantLibAddin::CoerceHandle<

QuantLibAddin::YieldTermStructure,

QuantLib::YieldTermStructure>()(

YieldCurveCoerce);

// convert object IDs into library objects

OH_GET_OBJECT(VolTSCoerce, mVolTS, ObjectHandler::Object)

QuantLib::Handle<QuantLib::SwaptionVolatilityStructure> VolTSLibObj =

QuantLibAddin::CoerceHandle<

QuantLibAddin::SwaptionVolatilityStructure,

QuantLib::SwaptionVolatilityStructure>()(

VolTSCoerce);

// convert input datatypes to QuantLib datatypes

// Construct the Value Object

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

new QuantLibAddin::ValueObjects::qlBlackSwaptionEngine(

mObjectID,

mYieldCurve,

mVolTS,

mDisplacement,

false

));

// Construct the Object

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

new QuantLibAddin::BlackSwaptionEngine(

valueObject,

YieldCurveLibObj,

VolTSLibObj,

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::BlackSwaptionEngine) {

// validate js arguments

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

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

}

if (info.Length() == 3 || !info[3]->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

ObjectHandler::property_t YieldCurveCpp =

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

// convert js argument to c++ type

ObjectHandler::property_t VolTSCpp =

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

// convert js argument to c++ type

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

// launch worker

BlackSwaptionEngineWorker* worker = new BlackSwaptionEngineWorker(

ObjectIDCpp

, YieldCurveCpp

, VolTSCpp

, 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 BlackSwaptionEngine2Worker::Execute(){

try{

// convert object IDs into library objects

OH_GET_OBJECT(YieldCurveCoerce, mYieldCurve, ObjectHandler::Object)

QuantLib::Handle<QuantLib::YieldTermStructure> YieldCurveLibObj =

QuantLibAddin::CoerceHandle<

QuantLibAddin::YieldTermStructure,

QuantLib::YieldTermStructure>()(

YieldCurveCoerce);

// convert object IDs into library objects

QuantLib::Handle<QuantLib::Quote> VolLibObj =

ObjectHandler::convert2< QuantLib::Handle<QuantLib::Quote> >(mVol, "Vol");

// convert input datatypes to QuantLib datatypes

// 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::qlBlackSwaptionEngine2(

mObjectID,

mYieldCurve,

mVol,

mDisplacement,

mDayCounter,

false

));

// Construct the Object

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

new QuantLibAddin::BlackSwaptionEngine(

valueObject,

YieldCurveLibObj,

VolLibObj,

mDisplacement,

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::BlackSwaptionEngine2) {

// validate js arguments

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

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

}

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

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

}

if (info.Length() == 4 || !info[4]->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

ObjectHandler::property_t YieldCurveCpp =

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

// convert js argument to c++ type

ObjectHandler::property_t VolCpp =

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

// convert js argument to c++ type

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

// convert js argument to c++ type

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

string DayCounterCpp(strdup(*strDayCounter));

// launch worker

BlackSwaptionEngine2Worker* worker = new BlackSwaptionEngine2Worker(

ObjectIDCpp

, YieldCurveCpp

, VolCpp

, DisplacementCpp

, DayCounterCpp

);

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 BlackCapFloorEngineWorker::Execute(){

try{