/*

Copyright (C) 2016 -2017 Jerry Jin

*/

#ifndef date_h

#define date_h

#include <nan.h>

#include <string>

#include <queue>

#include <utility>

#include "../quantlibnode.hpp"

#include <oh/objecthandler.hpp>

using namespace node;

using namespace v8;

using namespace std;

class PeriodFromFrequencyWorker : public Nan::AsyncWorker {

public:

string mFrequency;

string mReturnValue;

string mError;

PeriodFromFrequencyWorker(

Nan::Callback *callback

,string Frequency

):

Nan::AsyncWorker(callback)

,mFrequency(Frequency)

{

};

//~PeriodFromFrequencyWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class FrequencyFromPeriodWorker : public Nan::AsyncWorker {

public:

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

std::vector<string> mReturnValue;

string mError;

FrequencyFromPeriodWorker(

Nan::Callback *callback

,std::vector<ObjectHandler::property_t> Period

):

Nan::AsyncWorker(callback)

,mPeriod(Period)

{

};

//~FrequencyFromPeriodWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class PeriodLessThanWorker : public Nan::AsyncWorker {

public:

string mPeriod1;

string mPeriod2;

bool mReturnValue;

string mError;

PeriodLessThanWorker(

Nan::Callback *callback

,string Period1

,string Period2

):

Nan::AsyncWorker(callback)

,mPeriod1(Period1)

,mPeriod2(Period2)

{

};

//~PeriodLessThanWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class PeriodEquivalentWorker : public Nan::AsyncWorker {

public:

string mPeriod;

string mReturnValue;

string mError;

PeriodEquivalentWorker(

Nan::Callback *callback

,string Period

):

Nan::AsyncWorker(callback)

,mPeriod(Period)

{

};

//~PeriodEquivalentWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class DateMinDateWorker : public Nan::AsyncWorker {

public:

long mReturnValue;

string mError;

DateMinDateWorker(

Nan::Callback *callback

):

Nan::AsyncWorker(callback)

{

};

//~DateMinDateWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class DateMaxDateWorker : public Nan::AsyncWorker {

public:

long mReturnValue;

string mError;

DateMaxDateWorker(

Nan::Callback *callback

):

Nan::AsyncWorker(callback)

{

};

//~DateMaxDateWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class DateIsLeapWorker : public Nan::AsyncWorker {

public:

std::vector<long> mYear;

std::vector<bool> mReturnValue;

string mError;

DateIsLeapWorker(

Nan::Callback *callback

,std::vector<long> Year

):

Nan::AsyncWorker(callback)

,mYear(Year)

{

};

//~DateIsLeapWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class DateEndOfMonthWorker : public Nan::AsyncWorker {

public:

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

std::vector<long> mReturnValue;

string mError;

DateEndOfMonthWorker(

Nan::Callback *callback

,std::vector<ObjectHandler::property_t> Date

):

Nan::AsyncWorker(callback)

,mDate(Date)

{

};

//~DateEndOfMonthWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class DateIsEndOfMonthWorker : public Nan::AsyncWorker {

public:

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

std::vector<bool> mReturnValue;

string mError;

DateIsEndOfMonthWorker(

Nan::Callback *callback

,std::vector<ObjectHandler::property_t> Date

):

Nan::AsyncWorker(callback)

,mDate(Date)

{

};

//~DateIsEndOfMonthWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class DateNextWeekdayWorker : public Nan::AsyncWorker {

public:

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

string mWeekday;

std::vector<long> mReturnValue;

string mError;

DateNextWeekdayWorker(

Nan::Callback *callback

,std::vector<ObjectHandler::property_t> Date

,string Weekday

):

Nan::AsyncWorker(callback)

,mDate(Date)

,mWeekday(Weekday)

{

};

//~DateNextWeekdayWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class DateNthWeekdayWorker : public Nan::AsyncWorker {

public:

long mNth;

string mWeekday;

string mMonth;

long mYear;

long mReturnValue;

string mError;

DateNthWeekdayWorker(

Nan::Callback *callback

,long Nth

,string Weekday

,string Month

,long Year

):

Nan::AsyncWorker(callback)

,mNth(Nth)

,mWeekday(Weekday)

,mMonth(Month)

,mYear(Year)

{

};

//~DateNthWeekdayWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class IMMIsIMMdateWorker : public Nan::AsyncWorker {

public:

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

bool mMainCycle;

std::vector<bool> mReturnValue;

string mError;

IMMIsIMMdateWorker(

Nan::Callback *callback

,std::vector<ObjectHandler::property_t> Date

,bool MainCycle

):

Nan::AsyncWorker(callback)

,mDate(Date)

,mMainCycle(MainCycle)

{

};

//~IMMIsIMMdateWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class IMMIsIMMcodeWorker : public Nan::AsyncWorker {

public:

std::vector<string> mCode;

bool mMainCycle;

std::vector<bool> mReturnValue;

string mError;

IMMIsIMMcodeWorker(

Nan::Callback *callback

,std::vector<string> Code

,bool MainCycle

):

Nan::AsyncWorker(callback)

,mCode(Code)

,mMainCycle(MainCycle)

{

};

//~IMMIsIMMcodeWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class IMMcodeWorker : public Nan::AsyncWorker {

public:

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

std::vector<string> mReturnValue;

string mError;

IMMcodeWorker(

Nan::Callback *callback

,std::vector<ObjectHandler::property_t> IMMdate

):

Nan::AsyncWorker(callback)

,mIMMdate(IMMdate)

{

};

//~IMMcodeWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class IMMNextCodeWorker : public Nan::AsyncWorker {

public:

ObjectHandler::property_t mRefDate;

bool mMainCycle;

string mReturnValue;

string mError;

IMMNextCodeWorker(

Nan::Callback *callback

,ObjectHandler::property_t RefDate

,bool MainCycle

):

Nan::AsyncWorker(callback)

,mRefDate(RefDate)

,mMainCycle(MainCycle)

{

};

//~IMMNextCodeWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class IMMNextCodesWorker : public Nan::AsyncWorker {

public:

ObjectHandler::property_t mRefDate;

std::vector<bool> mMainCycle;

std::vector<string> mReturnValue;

string mError;

IMMNextCodesWorker(

Nan::Callback *callback

,ObjectHandler::property_t RefDate

,std::vector<bool> MainCycle

):

Nan::AsyncWorker(callback)

,mRefDate(RefDate)

,mMainCycle(MainCycle)

{

};

//~IMMNextCodesWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class IMMdateWorker : public Nan::AsyncWorker {

public:

std::vector<string> mIMMcode;

ObjectHandler::property_t mRefDate;

std::vector<long> mReturnValue;

string mError;

IMMdateWorker(

Nan::Callback *callback

,std::vector<string> IMMcode

,ObjectHandler::property_t RefDate

):

Nan::AsyncWorker(callback)

,mIMMcode(IMMcode)

,mRefDate(RefDate)

{

};

//~IMMdateWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class IMMNextDateWorker : public Nan::AsyncWorker {

public:

ObjectHandler::property_t mRefDate;

bool mMainCycle;

long mReturnValue;

string mError;

IMMNextDateWorker(

Nan::Callback *callback

,ObjectHandler::property_t RefDate

,bool MainCycle

):

Nan::AsyncWorker(callback)

,mRefDate(RefDate)

,mMainCycle(MainCycle)

{

};

//~IMMNextDateWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class IMMNextDatesWorker : public Nan::AsyncWorker {

public:

ObjectHandler::property_t mRefDate;

std::vector<bool> mMainCycle;

std::vector<long> mReturnValue;

string mError;

IMMNextDatesWorker(

Nan::Callback *callback

,ObjectHandler::property_t RefDate

,std::vector<bool> MainCycle

):

Nan::AsyncWorker(callback)

,mRefDate(RefDate)

,mMainCycle(MainCycle)

{

};

//~IMMNextDatesWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ASXIsASXdateWorker : public Nan::AsyncWorker {

public:

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

bool mMainCycle;

std::vector<bool> mReturnValue;

string mError;

ASXIsASXdateWorker(

Nan::Callback *callback

,std::vector<ObjectHandler::property_t> Date

,bool MainCycle

):

Nan::AsyncWorker(callback)

,mDate(Date)

,mMainCycle(MainCycle)

{

};

//~ASXIsASXdateWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ASXIsASXcodeWorker : public Nan::AsyncWorker {

public:

std::vector<string> mCode;

bool mMainCycle;

std::vector<bool> mReturnValue;

string mError;

ASXIsASXcodeWorker(

Nan::Callback *callback

,std::vector<string> Code

,bool MainCycle

):

Nan::AsyncWorker(callback)

,mCode(Code)

,mMainCycle(MainCycle)

{

};

//~ASXIsASXcodeWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ASXcodeWorker : public Nan::AsyncWorker {

public:

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

std::vector<string> mReturnValue;

string mError;

ASXcodeWorker(

Nan::Callback *callback

,std::vector<ObjectHandler::property_t> ASXdate

):

Nan::AsyncWorker(callback)

,mASXdate(ASXdate)

{

};

//~ASXcodeWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ASXNextCodeWorker : public Nan::AsyncWorker {

public:

ObjectHandler::property_t mRefDate;

bool mMainCycle;

string mReturnValue;

string mError;

ASXNextCodeWorker(

Nan::Callback *callback

,ObjectHandler::property_t RefDate

,bool MainCycle

):

Nan::AsyncWorker(callback)

,mRefDate(RefDate)

,mMainCycle(MainCycle)

{

};

//~ASXNextCodeWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ASXNextCodesWorker : public Nan::AsyncWorker {

public:

ObjectHandler::property_t mRefDate;

std::vector<bool> mMainCycle;

std::vector<string> mReturnValue;

string mError;

ASXNextCodesWorker(

Nan::Callback *callback

,ObjectHandler::property_t RefDate

,std::vector<bool> MainCycle

):

Nan::AsyncWorker(callback)

,mRefDate(RefDate)

,mMainCycle(MainCycle)

{

};

//~ASXNextCodesWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ASXdateWorker : public Nan::AsyncWorker {

public:

std::vector<string> mASXcode;

ObjectHandler::property_t mRefDate;

std::vector<long> mReturnValue;

string mError;

ASXdateWorker(

Nan::Callback *callback

,std::vector<string> ASXcode

,ObjectHandler::property_t RefDate

):

Nan::AsyncWorker(callback)

,mASXcode(ASXcode)

,mRefDate(RefDate)

{

};

//~ASXdateWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ASXNextDateWorker : public Nan::AsyncWorker {

public:

ObjectHandler::property_t mRefDate;

bool mMainCycle;

long mReturnValue;

string mError;

ASXNextDateWorker(

Nan::Callback *callback

,ObjectHandler::property_t RefDate

,bool MainCycle

):

Nan::AsyncWorker(callback)

,mRefDate(RefDate)

,mMainCycle(MainCycle)

{

};

//~ASXNextDateWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ASXNextDatesWorker : public Nan::AsyncWorker {

public:

ObjectHandler::property_t mRefDate;

std::vector<bool> mMainCycle;

std::vector<long> mReturnValue;

string mError;

ASXNextDatesWorker(

Nan::Callback *callback

,ObjectHandler::property_t RefDate

,std::vector<bool> MainCycle

):

Nan::AsyncWorker(callback)

,mRefDate(RefDate)

,mMainCycle(MainCycle)

{

};

//~ASXNextDatesWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ECBKnownDatesWorker : public Nan::AsyncWorker {

public:

std::vector<long> mReturnValue;

string mError;

ECBKnownDatesWorker(

Nan::Callback *callback

):

Nan::AsyncWorker(callback)

{

};

//~ECBKnownDatesWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ECBAddDateWorker : public Nan::AsyncWorker {

public:

ObjectHandler::property_t mDate;

string mError;

ECBAddDateWorker(

Nan::Callback *callback

,ObjectHandler::property_t Date

):

Nan::AsyncWorker(callback)

,mDate(Date)

{

};

//~ECBAddDateWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ECBRemoveDateWorker : public Nan::AsyncWorker {

public:

ObjectHandler::property_t mDate;

string mError;

ECBRemoveDateWorker(

Nan::Callback *callback

,ObjectHandler::property_t Date

):

Nan::AsyncWorker(callback)

,mDate(Date)

{

};

//~ECBRemoveDateWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ECBdate2Worker : public Nan::AsyncWorker {

public:

string mMonth;

long mYear;

long mReturnValue;

string mError;

ECBdate2Worker(

Nan::Callback *callback

,string Month

,long Year

):

Nan::AsyncWorker(callback)

,mMonth(Month)

,mYear(Year)

{

};

//~ECBdate2Worker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ECBdateWorker : public Nan::AsyncWorker {

public:

string mECBcode;

ObjectHandler::property_t mRefDate;

long mReturnValue;

string mError;

ECBdateWorker(

Nan::Callback *callback

,string ECBcode

,ObjectHandler::property_t RefDate

):

Nan::AsyncWorker(callback)

,mECBcode(ECBcode)

,mRefDate(RefDate)

{

};

//~ECBdateWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ECBcodeWorker : public Nan::AsyncWorker {

public:

ObjectHandler::property_t mECBdate;

string mReturnValue;

string mError;

ECBcodeWorker(

Nan::Callback *callback

,ObjectHandler::property_t ECBdate

):

Nan::AsyncWorker(callback)

,mECBdate(ECBdate)

{

};

//~ECBcodeWorker();

//void Destroy();

void Execute();

void HandleOKCallback();

};

class ECBNextDateWorker : public Nan::AsyncWorker {

public:

ObjectHandler::property_t mDate;

long mReturnValue;