自学教程：C++ valueObject函数代码示例

    std::string qlZeroCouponBond(            const std::string &ObjectId,            const ObjectHandler::property_t &Description,            const std::string &Currency,            const long &SettlementDays,            const std::string &Calendar,            const ObjectHandler::property_t &FaceAmount,            const ObjectHandler::property_t &Maturity,            const ObjectHandler::property_t &PaymentBDC,            const ObjectHandler::property_t &Redemption,            const ObjectHandler::property_t &IssueDate,            const ObjectHandler::property_t &Permanent,            const ObjectHandler::property_t &Trigger,            const bool &Overwrite) {        try {        // convert input datatypes to C++ datatypes        std::string DescriptionCpp = ObjectHandler::convert2<std::string>(            Description, "Description", std::string());        double FaceAmountCpp = ObjectHandler::convert2<double>(            FaceAmount, "FaceAmount", 100.0);        std::string PaymentBDCCpp = ObjectHandler::convert2<std::string>(            PaymentBDC, "PaymentBDC", "Following");        double RedemptionCpp = ObjectHandler::convert2<double>(            Redemption, "Redemption", 100);        bool PermanentCpp = ObjectHandler::convert2<bool>(            Permanent, "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Size SettlementDaysLib;        QuantLibAddin::cppToLibrary(SettlementDays, SettlementDaysLib);        QuantLib::Real FaceAmountLib = ObjectHandler::convert2<QuantLib::Real>(            FaceAmount, "FaceAmount", 100.0);        QuantLib::Date MaturityLib = ObjectHandler::convert2<QuantLib::Date>(            Maturity, "Maturity");        QuantLib::Real RedemptionLib = ObjectHandler::convert2<QuantLib::Real>(            Redemption, "Redemption", 100);        QuantLib::Date IssueDateLib = ObjectHandler::convert2<QuantLib::Date>(            IssueDate, "IssueDate", QuantLib::Date());        // convert input datatypes to QuantLib enumerated datatypes        QuantLib::Currency CurrencyEnum =            ObjectHandler::Create<QuantLib::Currency>()(Currency);        QuantLib::Calendar CalendarEnum =            ObjectHandler::Create<QuantLib::Calendar>()(Calendar);        QuantLib::BusinessDayConvention PaymentBDCEnum =            ObjectHandler::Create<QuantLib::BusinessDayConvention>()(PaymentBDCCpp);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlZeroCouponBond(                ObjectId,                DescriptionCpp,                Currency,                SettlementDays,                Calendar,                FaceAmountCpp,                Maturity,                PaymentBDCCpp,                RedemptionCpp,                IssueDate,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::ZeroCouponBond(                valueObject,                DescriptionCpp,                CurrencyEnum,                SettlementDaysLib,                CalendarEnum,                FaceAmountLib,                MaturityLib,                PaymentBDCEnum,                RedemptionLib,                IssueDateLib,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::Repository::instance().storeObject(ObjectId, object, Overwrite, valueObject);        // Convert and return the return value//.........这里部分代码省略.........

XLL_DEC char *qlPiecewiseConstantAbcdVariance(        char *ObjectId,        OPER *A,        OPER *B,        OPER *C,        OPER *D,        long *ResetIndex,        OPER *RateTimes,        OPER *Permanent,        OPER *Trigger,        bool *Overwrite) {    // declare a shared pointer to the Function Call object    boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;    try {        // instantiate the Function Call object        functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(            new ObjectHandler::FunctionCall("qlPiecewiseConstantAbcdVariance"));        ObjectHandler::validateRange(Trigger, "Trigger");        // initialize the session ID (if enabled)        SET_SESSION_ID        // convert input datatypes to C++ datatypes        double ACpp = ObjectHandler::convert2<double>(            ObjectHandler::ConvertOper(*A), "A", -0.06);        double BCpp = ObjectHandler::convert2<double>(            ObjectHandler::ConvertOper(*B), "B", 0.17);        double CCpp = ObjectHandler::convert2<double>(            ObjectHandler::ConvertOper(*C), "C", 0.54);        double DCpp = ObjectHandler::convert2<double>(            ObjectHandler::ConvertOper(*D), "D", 0.17);        std::vector<double> RateTimesCpp =            ObjectHandler::operToVector<double>(*RateTimes, "RateTimes");        bool PermanentCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*Permanent), "Permanent", false);        // Strip the Excel cell update counter suffix from Object IDs                std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlPiecewiseConstantAbcdVariance(                ObjectIdStrip,                ACpp,                BCpp,                CCpp,                DCpp,                *ResetIndex,                RateTimesCpp,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::PiecewiseConstantAbcdVariance(                valueObject,                ACpp,                BCpp,                CCpp,                DCpp,                *ResetIndex,                RateTimesCpp,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, *Overwrite, valueObject);        // Convert and return the return value        static char ret[XL_MAX_STR_LEN];        ObjectHandler::stringToChar(returnValue, ret);        return ret;    } catch (const std::exception &e) {        ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);        return 0;    } catch (...) {        ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);        return 0;    }}

    std::string qlFlatHazardRate(            const std::string &ObjectId,            const ObjectHandler::property_t &NDays,            const ObjectHandler::property_t &Calendar,            const ObjectHandler::property_t &Rate,            const ObjectHandler::property_t &DayCounter,            const ObjectHandler::property_t &Permanent,            const ObjectHandler::property_t &Trigger,            const bool &Overwrite) {        try {        // convert input datatypes to C++ datatypes        long NDaysCpp = ObjectHandler::convert2<long>(            NDays, "NDays", 0);        std::string CalendarCpp = ObjectHandler::convert2<std::string>(            Calendar, "Calendar", "NullCalendar");        std::string DayCounterCpp = ObjectHandler::convert2<std::string>(            DayCounter, "DayCounter", "Actual/365 (Fixed)");        bool PermanentCpp = ObjectHandler::convert2<bool>(            Permanent, "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Size NDaysLib = ObjectHandler::convert2<QuantLib::Size>(            NDays, "NDays", 0);        // convert input datatypes to QuantLib enumerated datatypes        QuantLib::Calendar CalendarEnum =            ObjectHandler::Create<QuantLib::Calendar>()(CalendarCpp);        QuantLib::DayCounter DayCounterEnum =            ObjectHandler::Create<QuantLib::DayCounter>()(DayCounterCpp);        // convert object IDs into library objects        QuantLib::Handle<QuantLib::Quote> RateLibObj =             ObjectHandler::convert2<QuantLib::Handle<QuantLib::Quote> >(                Rate, "Rate");        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlFlatHazardRate(                ObjectId,                NDaysCpp,                CalendarCpp,                Rate,                DayCounterCpp,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::FlatHazardRate(                valueObject,                NDaysLib,                CalendarEnum,                RateLibObj,                DayCounterEnum,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::Repository::instance().storeObject(ObjectId, object, Overwrite, valueObject);        // Convert and return the return value        return returnValue;        } catch (const std::exception &e) {            OH_FAIL("Error in function qlFlatHazardRate : " << e.what());        }    }

SEQSEQ(ANY) SAL_CALL CalcAddins_impl::qlMakeCapFloor(        const ANY &ObjectId,        const ANY &OptionType,        const ANY &Length,        const ANY &IborIndex,        const ANY &Strike,        const ANY &ForwardStart,        const ANY &PricingEngineID,        const sal_Int32 Permanent,        const ANY &Trigger,        const sal_Int32 Overwrite) throw(RuntimeException) {    try {        // convert input datatypes to C++ datatypes        std::string ObjectIdCpp;        calcToScalar(ObjectIdCpp, ObjectId);        std::string OptionTypeCpp;        calcToScalar(OptionTypeCpp, OptionType);        std::string LengthCpp;        calcToScalar(LengthCpp, Length);        std::string IborIndexCpp;        calcToScalar(IborIndexCpp, IborIndex);        double StrikeCpp;        if(Strike.hasValue())             calcToScalar(StrikeCpp, Strike);        else            StrikeCpp = QuantLib::Null<QuantLib::Rate>();        std::string ForwardStartCpp;        calcToScalar(ForwardStartCpp, ForwardStart);        std::string PricingEngineIDCpp;        calcToScalar(PricingEngineIDCpp, PricingEngineID);        bool PermanentCpp;        calcToScalar(PermanentCpp, Permanent);        // convert input datatypes to QuantLib datatypes        QuantLib::Period LengthLib;        calcToScalar(LengthLib, Length);        QuantLib::Period ForwardStartLib;        calcToScalar(ForwardStartLib, ForwardStart);        // convert object IDs into library objects        OH_GET_REFERENCE(IborIndexLibObjPtr, IborIndexCpp,            QuantLibAddin::IborIndex, QuantLib::IborIndex)        OH_GET_REFERENCE(PricingEngineIDLibObjPtr, PricingEngineIDCpp,            QuantLibAddin::PricingEngine, QuantLib::PricingEngine)        // convert input datatypes to QuantLib enumerated datatypes        QuantLib::CapFloor::Type OptionTypeEnum =            ObjectHandler::Create<QuantLib::CapFloor::Type>()(OptionTypeCpp);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlMakeCapFloor(                ObjectIdCpp,                OptionTypeCpp,                LengthCpp,                IborIndexCpp,                StrikeCpp,                ForwardStartCpp,                PricingEngineIDCpp,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::CapFloor(                valueObject,                OptionTypeEnum,                LengthLib,                IborIndexLibObjPtr,                StrikeCpp,                ForwardStartLib,                PricingEngineIDLibObjPtr,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::Repository::instance().storeObject(ObjectIdCpp, object, Overwrite, valueObject);        // Convert and return the return value        ANY returnValueCalc;        scalarToCalc(returnValueCalc, returnValue);//.........这里部分代码省略.........

SEQSEQ(ANY) SAL_CALL CalcAddins_impl::qlIborIndex(        const ANY &ObjectId,        const ANY &FamilyName,        const ANY &Tenor,        const ANY &FixingDays,        const ANY &Currency,        const ANY &Calendar,        const ANY &BDayConvention,        const sal_Int32 EndOfMonth,        const ANY &DayCounter,        const ANY &FwdCurve,        const sal_Int32 Permanent,        const ANY &Trigger,        const sal_Int32 Overwrite) throw(RuntimeException) {    try {        // convert input datatypes to C++ datatypes        std::string ObjectIdCpp;        calcToScalar(ObjectIdCpp, ObjectId);        std::string FamilyNameCpp;        calcToScalar(FamilyNameCpp, FamilyName);        std::string TenorCpp;        calcToScalar(TenorCpp, Tenor);        long FixingDaysCpp;        calcToScalar(FixingDaysCpp, FixingDays);        std::string CurrencyCpp;        calcToScalar(CurrencyCpp, Currency);        std::string CalendarCpp;        calcToScalar(CalendarCpp, Calendar);        std::string BDayConventionCpp;        calcToScalar(BDayConventionCpp, BDayConvention);        bool EndOfMonthCpp;        calcToScalar(EndOfMonthCpp, EndOfMonth);        std::string DayCounterCpp;        calcToScalar(DayCounterCpp, DayCounter);        std::string FwdCurveCpp;        if(FwdCurve.hasValue())             calcToScalar(FwdCurveCpp, FwdCurve);        else            FwdCurveCpp = "";        bool PermanentCpp;        calcToScalar(PermanentCpp, Permanent);        // convert input datatypes to QuantLib datatypes        QuantLib::Period TenorLib;        calcToScalar(TenorLib, Tenor);        QuantLib::Natural FixingDaysLib;        calcToScalar(FixingDaysLib, FixingDays);        // convert object IDs into library objects        OH_GET_OBJECT_DEFAULT(FwdCurveCoerce, FwdCurveCpp, ObjectHandler::Object)        QuantLib::Handle<QuantLib::YieldTermStructure> FwdCurveLibObj =            QuantLibAddin::CoerceHandle<                QuantLibAddin::YieldTermStructure,                QuantLib::YieldTermStructure>()(                    FwdCurveCoerce, QuantLib::Handle<QuantLib::YieldTermStructure>());        // convert input datatypes to QuantLib enumerated datatypes        QuantLib::Currency CurrencyEnum =            ObjectHandler::Create<QuantLib::Currency>()(CurrencyCpp);        QuantLib::Calendar CalendarEnum =            ObjectHandler::Create<QuantLib::Calendar>()(CalendarCpp);        QuantLib::BusinessDayConvention BDayConventionEnum =            ObjectHandler::Create<QuantLib::BusinessDayConvention>()(BDayConventionCpp);        QuantLib::DayCounter DayCounterEnum =            ObjectHandler::Create<QuantLib::DayCounter>()(DayCounterCpp);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlIborIndex(                ObjectIdCpp,                FamilyNameCpp,                TenorCpp,                FixingDaysCpp,                CurrencyCpp,                CalendarCpp,                BDayConventionCpp,                EndOfMonthCpp,                DayCounterCpp,                FwdCurveCpp,                PermanentCpp));//.........这里部分代码省略.........

    std::string CALForwardRateIpc(            const std::string &ObjectId,            const std::string &MarketModel,            const std::string &BrownianGeneratorFactory,            const std::vector<long>& Numeraires,            const ObjectHandler::property_t &Permanent,            const ObjectHandler::property_t &Trigger,            const bool &Overwrite) {        try {        // convert input datatypes to C++ datatypes        bool PermanentCpp = ObjectHandler::convert2<bool>(            Permanent, "Permanent", false);        // convert input datatypes to QuantLib datatypes        std::vector<QuantLib::Size> NumerairesLib =             QuantLibAddin::convertVector<long, QuantLib::Size>(Numeraires);        // convert object IDs into library objects        OH_GET_REFERENCE(MarketModelLibObjPtr, MarketModel,            QuantLibAddin::MarketModel, QuantLib::MarketModel)        OH_GET_UNDERLYING(BrownianGeneratorFactoryLibObj, BrownianGeneratorFactory,            QuantLibAddin::BrownianGeneratorFactory, QuantLib::BrownianGeneratorFactory)        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::CALForwardRateIpc(                ObjectId,                MarketModel,                BrownianGeneratorFactory,                Numeraires,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::LogNormalFwdRateIpc(                valueObject,                MarketModelLibObjPtr,                BrownianGeneratorFactoryLibObj,                NumerairesLib,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::Repository::instance().storeObject(ObjectId, object, Overwrite);        // Convert and return the return value        return returnValue;        } catch (const std::exception &e) {            OH_FAIL("Error in function CALForwardRateIpc : " << e.what());        }    }

XLL_DEC char *qlMakeDatedOIS(        char *ObjectId,        OPER *StartDate,        OPER *EndDate,        char *OvernightIndex,        OPER *FixedRate,        OPER *FixDayCounter,        OPER *Spread,        OPER *Permanent,        OPER *Trigger,        bool *Overwrite) {    // declare a shared pointer to the Function Call object    boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;    try {        // instantiate the Function Call object        functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(            new ObjectHandler::FunctionCall("qlMakeDatedOIS"));        ObjectHandler::validateRange(Trigger, "Trigger");        // initialize the session ID (if enabled)        SET_SESSION_ID        // convert input datatypes to C++ datatypes        ObjectHandler::property_t StartDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(            ObjectHandler::ConvertOper(*StartDate));        ObjectHandler::property_t EndDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(            ObjectHandler::ConvertOper(*EndDate));        double FixedRateCpp = ObjectHandler::convert2<double>(            ObjectHandler::ConvertOper(*FixedRate), "FixedRate", QuantLib::Null<QuantLib::Rate>());        std::string FixDayCounterCpp = ObjectHandler::convert2<std::string>(            ObjectHandler::ConvertOper(*FixDayCounter), "FixDayCounter", "Actual/360");        double SpreadCpp = ObjectHandler::convert2<double>(            ObjectHandler::ConvertOper(*Spread), "Spread", 0.0);        bool PermanentCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*Permanent), "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Date StartDateLib = ObjectHandler::convert2<QuantLib::Date>(            ObjectHandler::ConvertOper(*StartDate), "StartDate", QuantLib::Date());        QuantLib::Date EndDateLib = ObjectHandler::convert2<QuantLib::Date>(            ObjectHandler::ConvertOper(*EndDate), "EndDate", QuantLib::Date());        // convert input datatypes to QuantLib enumerated datatypes        QuantLib::DayCounter FixDayCounterEnum =            ObjectHandler::Create<QuantLib::DayCounter>()(FixDayCounterCpp);        // convert object IDs into library objects        OH_GET_REFERENCE(OvernightIndexLibObjPtr, OvernightIndex,            QuantLibAddin::OvernightIndex, QuantLib::OvernightIndex)        // Strip the Excel cell update counter suffix from Object IDs                std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);        std::string OvernightIndexStrip = ObjectHandler::CallingRange::getStub(OvernightIndex);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlMakeDatedOIS(                ObjectIdStrip,                StartDateCpp,                EndDateCpp,                OvernightIndexStrip,                FixedRateCpp,                FixDayCounterCpp,                SpreadCpp,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::OvernightIndexedSwap(                valueObject,                StartDateLib,                EndDateLib,                OvernightIndexLibObjPtr,                FixedRateCpp,                FixDayCounterEnum,                SpreadCpp,                PermanentCpp));        // Store the Object in the Repository//.........这里部分代码省略.........

XLL_DEC char *qlRangeAccrualPricerByBgm(        char *ObjectId,        double *Correlation,        char *SmileOnStartDateID,        char *SmileOnEndDateID,        bool *WithSmile,        bool *ByCallSpread,        OPER *Permanent,        OPER *Trigger,        bool *Overwrite) {    // declare a shared pointer to the Function Call object    boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;    try {        // instantiate the Function Call object        functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(            new ObjectHandler::FunctionCall("qlRangeAccrualPricerByBgm"));        ObjectHandler::validateRange(Trigger, "Trigger");        // initialize the session ID (if enabled)        SET_SESSION_ID        // convert input datatypes to C++ datatypes        bool PermanentCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*Permanent), "Permanent", false);        // convert object IDs into library objects        OH_GET_REFERENCE(SmileOnStartDateIDLibObjPtr, SmileOnStartDateID,            QuantLibAddin::SmileSection, QuantLib::SmileSection)        OH_GET_REFERENCE(SmileOnEndDateIDLibObjPtr, SmileOnEndDateID,            QuantLibAddin::SmileSection, QuantLib::SmileSection)        // Strip the Excel cell update counter suffix from Object IDs                std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);        std::string SmileOnStartDateIDStrip = ObjectHandler::CallingRange::getStub(SmileOnStartDateID);        std::string SmileOnEndDateIDStrip = ObjectHandler::CallingRange::getStub(SmileOnEndDateID);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlRangeAccrualPricerByBgm(                ObjectIdStrip,                *Correlation,                SmileOnStartDateIDStrip,                SmileOnEndDateIDStrip,                *WithSmile,                *ByCallSpread,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::RangeAccrualPricerByBgm(                valueObject,                *Correlation,                SmileOnStartDateIDLibObjPtr,                SmileOnEndDateIDLibObjPtr,                *WithSmile,                *ByCallSpread,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, *Overwrite, valueObject);        // Convert and return the return value        static char ret[XL_MAX_STR_LEN];        ObjectHandler::stringToChar(returnValue, ret);        return ret;    } catch (const std::exception &e) {        ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);        return 0;    } catch (...) {        ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);        return 0;    }}

XLL_DEC char *qlSMMDriftCalculator(        char *ObjectId,        FP *Pseudo_square_root,        OPER *Displacements,        OPER *Taus,        long *Numeraire,        long *Alive,        OPER *Permanent,        OPER *Trigger,        bool *Overwrite) {    // declare a shared pointer to the Function Call object    boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;    try {        // instantiate the Function Call object        functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(            new ObjectHandler::FunctionCall("qlSMMDriftCalculator"));        ObjectHandler::validateRange(Trigger, "Trigger");        // initialize the session ID (if enabled)        SET_SESSION_ID        // convert input datatypes to C++ datatypes        std::vector<std::vector<double> > Pseudo_square_rootCpp =            ObjectHandler::fpToMatrix<double>(*Pseudo_square_root);        std::vector<double> DisplacementsCpp =            ObjectHandler::operToVector<double>(*Displacements, "Displacements");        std::vector<double> TausCpp =            ObjectHandler::operToVector<double>(*Taus, "Taus");        bool PermanentCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*Permanent), "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Matrix Pseudo_square_rootLib =            QuantLibXL::operToQlMatrix(*Pseudo_square_root);        QuantLib::Size NumeraireLib;        QuantLibAddin::cppToLibrary(*Numeraire, NumeraireLib);        QuantLib::Size AliveLib;        QuantLibAddin::cppToLibrary(*Alive, AliveLib);        // Strip the Excel cell update counter suffix from Object IDs                std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlSMMDriftCalculator(                ObjectIdStrip,                Pseudo_square_rootCpp,                DisplacementsCpp,                TausCpp,                *Numeraire,                *Alive,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::SMMDriftCalculator(                valueObject,                Pseudo_square_rootLib,                DisplacementsCpp,                TausCpp,                NumeraireLib,                AliveLib,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, *Overwrite, valueObject);        // Convert and return the return value        static char ret[XL_MAX_STR_LEN];        ObjectHandler::stringToChar(returnValue, ret);        return ret;    } catch (const std::exception &e) {        ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);        return 0;    } catch (...) {        ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);        return 0;    }//.........这里部分代码省略.........

XLL_DEC char *qlRangeAccrualFloatersCouponFromLeg(        char *ObjectId,        char *RangeAccrualLeg,        long *Position,        OPER *Permanent,        OPER *Trigger,        bool *Overwrite) {    // declare a shared pointer to the Function Call object    boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;    try {        // instantiate the Function Call object        functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(            new ObjectHandler::FunctionCall("qlRangeAccrualFloatersCouponFromLeg"));        ObjectHandler::validateRange(Trigger, "Trigger");        // initialize the session ID (if enabled)        SET_SESSION_ID        // convert input datatypes to C++ datatypes        bool PermanentCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*Permanent), "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Size PositionLib;        QuantLibAddin::cppToLibrary(*Position, PositionLib);        // convert object IDs into library objects        OH_GET_UNDERLYING(RangeAccrualLegLibObj, RangeAccrualLeg,            QuantLibAddin::Leg, QuantLib::Leg)        // Strip the Excel cell update counter suffix from Object IDs                std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);        std::string RangeAccrualLegStrip = ObjectHandler::CallingRange::getStub(RangeAccrualLeg);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlRangeAccrualFloatersCouponFromLeg(                ObjectIdStrip,                RangeAccrualLegStrip,                *Position,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::RangeAccrualFloatersCoupon(                valueObject,                RangeAccrualLegLibObj,                PositionLib,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, *Overwrite, valueObject);        // Convert and return the return value        static char ret[XL_MAX_STR_LEN];        ObjectHandler::stringToChar(returnValue, ret);        return ret;    } catch (const std::exception &e) {        ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);        return 0;    } catch (...) {        ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);        return 0;    }}

//.........这里部分代码省略.........        bool RhoIsFixedCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*RhoIsFixed), "RhoIsFixed", false);        bool VegaWeightedCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*VegaWeighted), "VegaWeighted", false);        std::string EndCriteriaCpp = ObjectHandler::convert2<std::string>(            ObjectHandler::ConvertOper(*EndCriteria), "EndCriteria", "");        std::string MethodCpp = ObjectHandler::convert2<std::string>(            ObjectHandler::ConvertOper(*Method), "Method", "");        bool PermanentCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*Permanent), "Permanent", false);        // convert object IDs into library objects        std::vector<QuantLib::Handle<QuantLib::Quote> > StdDevsLibObj =            ObjectHandler::operToVector<QuantLib::Handle<QuantLib::Quote> >(*StdDevs, "StdDevs");        QuantLib::Handle<QuantLib::Quote> ForwardLibObj =             ObjectHandler::convert2<QuantLib::Handle<QuantLib::Quote> >(                ObjectHandler::ConvertOper(*Forward), "Forward");        OH_GET_REFERENCE_DEFAULT(EndCriteriaLibObjPtr, EndCriteriaCpp,            QuantLibAddin::EndCriteria, QuantLib::EndCriteria)        OH_GET_REFERENCE_DEFAULT(MethodLibObjPtr, MethodCpp,            QuantLibAddin::OptimizationMethod, QuantLib::OptimizationMethod)        // Strip the Excel cell update counter suffix from Object IDs                std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);        std::string EndCriteriaStrip = ObjectHandler::CallingRange::getStub(EndCriteriaCpp);        std::string MethodStrip = ObjectHandler::CallingRange::getStub(MethodCpp);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlSabrSmileSection(                ObjectIdStrip,                *OptionTime,                StrikesCpp,                StdDevsCpp,                ForwardCpp,                AlphaCpp,                BetaCpp,                NuCpp,                RhoCpp,                AlphaIsFixedCpp,                BetaIsFixedCpp,                NuIsFixedCpp,                RhoIsFixedCpp,                VegaWeightedCpp,                EndCriteriaCpp,                MethodCpp,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::SabrSmileSection(                valueObject,                *OptionTime,                StrikesCpp,                StdDevsLibObj,                ForwardLibObj,                AlphaCpp,                BetaCpp,                NuCpp,                RhoCpp,                AlphaIsFixedCpp,                BetaIsFixedCpp,                NuIsFixedCpp,                RhoIsFixedCpp,                VegaWeightedCpp,                EndCriteriaLibObjPtr,                MethodLibObjPtr,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, *Overwrite, valueObject);        // Convert and return the return value        static char ret[XL_MAX_STR_LEN];        ObjectHandler::stringToChar(returnValue, ret);        return ret;    } catch (const std::exception &e) {        ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);        return 0;    } catch (...) {        ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);        return 0;    }}

XLL_DEC char *qlFlatSmileSection(        char *ObjectId,        OPER *OptionDate,        double *Volatility,        OPER *DayCounter,        OPER *RefDate,        double *AtmValue,        OPER *Permanent,        OPER *Trigger,        bool *Overwrite) {    // declare a shared pointer to the Function Call object    boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;    try {        // instantiate the Function Call object        functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(            new ObjectHandler::FunctionCall("qlFlatSmileSection"));        ObjectHandler::validateRange(Trigger, "Trigger");        // initialize the session ID (if enabled)        SET_SESSION_ID        // convert input datatypes to C++ datatypes        ObjectHandler::property_t OptionDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(            ObjectHandler::ConvertOper(*OptionDate));        std::string DayCounterCpp = ObjectHandler::convert2<std::string>(            ObjectHandler::ConvertOper(*DayCounter), "DayCounter", "Actual/365 (Fixed)");        ObjectHandler::property_t RefDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(            ObjectHandler::ConvertOper(*RefDate));        bool PermanentCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*Permanent), "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Date OptionDateLib = ObjectHandler::convert2<QuantLib::Date>(            ObjectHandler::ConvertOper(*OptionDate), "OptionDate");        QuantLib::Date RefDateLib = ObjectHandler::convert2<QuantLib::Date>(            ObjectHandler::ConvertOper(*RefDate), "RefDate");        // convert input datatypes to QuantLib enumerated datatypes        QuantLib::DayCounter DayCounterEnum =            ObjectHandler::Create<QuantLib::DayCounter>()(DayCounterCpp);        // Strip the Excel cell update counter suffix from Object IDs                std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlFlatSmileSection(                ObjectIdStrip,                OptionDateCpp,                *Volatility,                DayCounterCpp,                RefDateCpp,                *AtmValue,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::FlatSmileSection(                valueObject,                OptionDateLib,                *Volatility,                DayCounterEnum,                RefDateLib,                *AtmValue,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, *Overwrite, valueObject);        // Convert and return the return value        static char ret[XL_MAX_STR_LEN];        ObjectHandler::stringToChar(returnValue, ret);        return ret;    } catch (const std::exception &e) {        ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);        return 0;    } catch (...) {        ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);        return 0;//.........这里部分代码省略.........

XLL_DEC char *qlSmileSectionFromSabrVolSurface(        char *ObjectId,        char *SabrVolSurface,        double *OptionTime,        OPER *Permanent,        OPER *Trigger,        bool *Overwrite) {    // declare a shared pointer to the Function Call object    boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;    try {        // instantiate the Function Call object        functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(            new ObjectHandler::FunctionCall("qlSmileSectionFromSabrVolSurface"));        ObjectHandler::validateRange(Trigger, "Trigger");        // initialize the session ID (if enabled)        SET_SESSION_ID        // convert input datatypes to C++ datatypes        bool PermanentCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*Permanent), "Permanent", false);        // convert object IDs into library objects        OH_GET_OBJECT(SabrVolSurfaceCoerce, SabrVolSurface, ObjectHandler::Object)        QuantLib::Handle<QuantLib::SabrVolSurface> SabrVolSurfaceLibObj =            QuantLibAddin::CoerceHandle<                QuantLibAddin::SabrVolSurface,                QuantLib::SabrVolSurface>()(                    SabrVolSurfaceCoerce);        // Strip the Excel cell update counter suffix from Object IDs                std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);        std::string SabrVolSurfaceStrip = ObjectHandler::CallingRange::getStub(SabrVolSurface);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlSmileSectionFromSabrVolSurface(                ObjectIdStrip,                SabrVolSurfaceStrip,                *OptionTime,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::SmileSectionFromSabrVolSurface(                valueObject,                SabrVolSurfaceLibObj,                *OptionTime,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, *Overwrite, valueObject);        // Convert and return the return value        static char ret[XL_MAX_STR_LEN];        ObjectHandler::stringToChar(returnValue, ret);        return ret;    } catch (const std::exception &e) {        ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);        return 0;    } catch (...) {        ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);        return 0;    }}

    std::string CALBarrierOption(            const std::string &ObjectId,            const std::string &BarrierType,            const double &Barrier,            const double &Rebate,            const std::string &Payoff,            const std::string &Exercise,            const ObjectHandler::property_t &Permanent,            const ObjectHandler::property_t &Trigger,            const bool &Overwrite) {        try {        // convert input datatypes to C++ datatypes        bool PermanentCpp = ObjectHandler::convert2<bool>(            Permanent, "Permanent", false);        // convert input datatypes to QuantLib enumerated datatypes        QuantLib::Barrier::Type BarrierTypeEnum =            ObjectHandler::Create<QuantLib::Barrier::Type>()(BarrierType);        // convert object IDs into library objects        OH_GET_REFERENCE(PayoffLibObjPtr, Payoff,            QuantLibAddin::StrikedTypePayoff, QuantLib::StrikedTypePayoff)        OH_GET_REFERENCE(ExerciseLibObjPtr, Exercise,            QuantLibAddin::Exercise, QuantLib::Exercise)        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::CALBarrierOption(                ObjectId,                BarrierType,                Barrier,                Rebate,                Payoff,                Exercise,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::BarrierOption(                valueObject,                BarrierTypeEnum,                Barrier,                Rebate,                PayoffLibObjPtr,                ExerciseLibObjPtr,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::Repository::instance().storeObject(ObjectId, object, Overwrite);        // Convert and return the return value        return returnValue;        } catch (const std::exception &e) {            OH_FAIL("Error in function CALBarrierOption : " << e.what());        }    }

XLL_DEC char *qlGeneralizedBlackScholesProcess(        char *ObjectId,        char *BlackVolID,        double *Underlying,        OPER *DayCounter,        OPER *SettlementDate,        double *RiskFreeRate,        double *DividendYield,        OPER *Permanent,        OPER *Trigger,        bool *Overwrite) {    // declare a shared pointer to the Function Call object    boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;    try {        // instantiate the Function Call object        functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(            new ObjectHandler::FunctionCall("qlGeneralizedBlackScholesProcess"));        ObjectHandler::validateRange(Trigger, "Trigger");        // initialize the session ID (if enabled)        SET_SESSION_ID        // convert input datatypes to C++ datatypes        std::string DayCounterCpp = ObjectHandler::convert2<std::string>(            ObjectHandler::ConvertOper(*DayCounter), "DayCounter", "Actual/365 (Fixed)");        ObjectHandler::property_t SettlementDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(            ObjectHandler::ConvertOper(*SettlementDate));        bool PermanentCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*Permanent), "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Date SettlementDateLib = ObjectHandler::convert2<QuantLib::Date>(            ObjectHandler::ConvertOper(*SettlementDate), "SettlementDate");        // convert input datatypes to QuantLib enumerated datatypes        QuantLib::DayCounter DayCounterEnum =            ObjectHandler::Create<QuantLib::DayCounter>()(DayCounterCpp);        // convert object IDs into library objects        OH_GET_REFERENCE(BlackVolIDLibObjPtr, BlackVolID,            QuantLibAddin::BlackVolTermStructure, QuantLib::BlackVolTermStructure)        // Strip the Excel cell update counter suffix from Object IDs                std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);        std::string BlackVolIDStrip = ObjectHandler::CallingRange::getStub(BlackVolID);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlGeneralizedBlackScholesProcess(                ObjectIdStrip,                BlackVolIDStrip,                *Underlying,                DayCounterCpp,                SettlementDateCpp,                *RiskFreeRate,                *DividendYield,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::GeneralizedBlackScholesProcess(                valueObject,                BlackVolIDLibObjPtr,                *Underlying,                DayCounterEnum,                SettlementDateLib,                *RiskFreeRate,                *DividendYield,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, *Overwrite, valueObject);        // Convert and return the return value        static char ret[XL_MAX_STR_LEN];        ObjectHandler::stringToChar(returnValue, ret);        return ret;    } catch (const std::exception &e) {        ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);        return 0;//.........这里部分代码省略.........

    std::string CALQuantoForwardVanillaOption(            const std::string &ObjectId,            const double &Moneyness,            const ObjectHandler::property_t &ResetDate,            const std::string &Payoff,            const std::string &Exercise,            const ObjectHandler::property_t &Permanent,            const ObjectHandler::property_t &Trigger,            const bool &Overwrite) {        try {        // convert input datatypes to C++ datatypes        bool PermanentCpp = ObjectHandler::convert2<bool>(            Permanent, "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Date ResetDateLib = ObjectHandler::convert2<QuantLib::Date>(            ResetDate, "ResetDate");        // convert object IDs into library objects        OH_GET_REFERENCE(PayoffLibObjPtr, Payoff,            QuantLibAddin::StrikedTypePayoff, QuantLib::StrikedTypePayoff)        OH_GET_REFERENCE(ExerciseLibObjPtr, Exercise,            QuantLibAddin::Exercise, QuantLib::Exercise)        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::CALQuantoForwardVanillaOption(                ObjectId,                Moneyness,                ResetDate,                Payoff,                Exercise,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::QuantoForwardVanillaOption(                valueObject,                Moneyness,                ResetDateLib,                PayoffLibObjPtr,                ExerciseLibObjPtr,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::Repository::instance().storeObject(ObjectId, object, Overwrite);        // Convert and return the return value        return returnValue;        } catch (const std::exception &e) {            OH_FAIL("Error in function CALQuantoForwardVanillaOption : " << e.what());        }    }

XLL_DEC char *qlAbcdCalibration(        char *ObjectId,        OPER *Times,        OPER *BlackVols,        OPER *A,        OPER *B,        OPER *C,        OPER *D,        OPER *AIsFixed,        OPER *BIsFixed,        OPER *CIsFixed,        OPER *DIsFixed,        OPER *VegaWeighted,        OPER *EndCriteria,        OPER *Method,        OPER *Permanent,        OPER *Trigger,        bool *Overwrite) {    // declare a shared pointer to the Function Call object    boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;    try {        // instantiate the Function Call object        functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(            new ObjectHandler::FunctionCall("qlAbcdCalibration"));        ObjectHandler::validateRange(Trigger, "Trigger");        // initialize the session ID (if enabled)        SET_SESSION_ID        // convert input datatypes to C++ datatypes        std::vector<double> TimesCpp =            ObjectHandler::operToVector<double>(*Times, "Times");        std::vector<double> BlackVolsCpp =            ObjectHandler::operToVector<double>(*BlackVols, "BlackVols");        double ACpp = ObjectHandler::convert2<double>(            ObjectHandler::ConvertOper(*A), "A", -0.06);        double BCpp = ObjectHandler::convert2<double>(            ObjectHandler::ConvertOper(*B), "B", 0.17);        double CCpp = ObjectHandler::convert2<double>(            ObjectHandler::ConvertOper(*C), "C", 0.54);        double DCpp = ObjectHandler::convert2<double>(            ObjectHandler::ConvertOper(*D), "D", 0.17);        bool AIsFixedCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*AIsFixed), "AIsFixed", false);        bool BIsFixedCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*BIsFixed), "BIsFixed", false);        bool CIsFixedCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*CIsFixed), "CIsFixed", false);        bool DIsFixedCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*DIsFixed), "DIsFixed", false);        bool VegaWeightedCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*VegaWeighted), "VegaWeighted", false);        std::string EndCriteriaCpp = ObjectHandler::convert2<std::string>(            ObjectHandler::ConvertOper(*EndCriteria), "EndCriteria", "");        std::string MethodCpp = ObjectHandler::convert2<std::string>(            ObjectHandler::ConvertOper(*Method), "Method", "");        bool PermanentCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*Permanent), "Permanent", false);        // convert object IDs into library objects        OH_GET_REFERENCE_DEFAULT(EndCriteriaLibObjPtr, EndCriteriaCpp,            QuantLibAddin::EndCriteria, QuantLib::EndCriteria)        OH_GET_REFERENCE_DEFAULT(MethodLibObjPtr, MethodCpp,            QuantLibAddin::OptimizationMethod, QuantLib::OptimizationMethod)        // Strip the Excel cell update counter suffix from Object IDs                std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);        std::string EndCriteriaStrip = ObjectHandler::CallingRange::getStub(EndCriteriaCpp);        std::string MethodStrip = ObjectHandler::CallingRange::getStub(MethodCpp);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlAbcdCalibration(                ObjectIdStrip,                TimesCpp,//.........这里部分代码省略.........

XLL_DEC char *qlFRA(        char *ObjectId,        OPER *ValueDate,        OPER *MaturityDate,        char *Position,        double *Strike,        double *Notional,        char *IborIndex,        char *YieldCurve,        OPER *Permanent,        OPER *Trigger,        bool *Overwrite) {    // declare a shared pointer to the Function Call object    boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;    try {        // instantiate the Function Call object        functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(            new ObjectHandler::FunctionCall("qlFRA"));        ObjectHandler::validateRange(Trigger, "Trigger");        // initialize the session ID (if enabled)        SET_SESSION_ID        // convert input datatypes to C++ datatypes        ObjectHandler::property_t ValueDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(            ObjectHandler::ConvertOper(*ValueDate));        ObjectHandler::property_t MaturityDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(            ObjectHandler::ConvertOper(*MaturityDate));        bool PermanentCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*Permanent), "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Date ValueDateLib = ObjectHandler::convert2<QuantLib::Date>(            ObjectHandler::ConvertOper(*ValueDate), "ValueDate");        QuantLib::Date MaturityDateLib = ObjectHandler::convert2<QuantLib::Date>(            ObjectHandler::ConvertOper(*MaturityDate), "MaturityDate");        // convert input datatypes to QuantLib enumerated datatypes        QuantLib::Position::Type PositionEnum =            ObjectHandler::Create<QuantLib::Position::Type>()(Position);        // convert object IDs into library objects        OH_GET_REFERENCE(IborIndexLibObjPtr, IborIndex,            QuantLibAddin::IborIndex, QuantLib::IborIndex)        OH_GET_OBJECT(YieldCurveCoerce, YieldCurve, ObjectHandler::Object)        QuantLib::Handle<QuantLib::YieldTermStructure> YieldCurveLibObj =            QuantLibAddin::CoerceHandle<                QuantLibAddin::YieldTermStructure,                QuantLib::YieldTermStructure>()(                    YieldCurveCoerce);        // Strip the Excel cell update counter suffix from Object IDs                std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);        std::string IborIndexStrip = ObjectHandler::CallingRange::getStub(IborIndex);        std::string YieldCurveStrip = ObjectHandler::CallingRange::getStub(YieldCurve);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlFRA(                ObjectIdStrip,                ValueDateCpp,                MaturityDateCpp,                Position,                *Strike,                *Notional,                IborIndexStrip,                YieldCurveStrip,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::ForwardRateAgreement(                valueObject,                ValueDateLib,                MaturityDateLib,                PositionEnum,                *Strike,                *Notional,                IborIndexLibObjPtr,                YieldCurveLibObj,                PermanentCpp));//.........这里部分代码省略.........

    std::string CALMakeCapFloor(            const std::string &ObjectId,            const std::string &OptionType,            const std::string &Length,            const std::string &IborIndex,            const ObjectHandler::property_t &Strike,            const std::string &ForwardStart,            const std::string &PricingEngineID,            const ObjectHandler::property_t &Permanent,            const ObjectHandler::property_t &Trigger,            const bool &Overwrite) {        try {        // convert input datatypes to C++ datatypes        double StrikeCpp = ObjectHandler::convert2<double>(            Strike, "Strike", QuantLib::Null<QuantLib::Rate>());        bool PermanentCpp = ObjectHandler::convert2<bool>(            Permanent, "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Period LengthLib;        QuantLibAddin::cppToLibrary(Length, LengthLib);        QuantLib::Period ForwardStartLib;        QuantLibAddin::cppToLibrary(ForwardStart, ForwardStartLib);        // convert input datatypes to QuantLib enumerated datatypes        QuantLib::CapFloor::Type OptionTypeEnum =            ObjectHandler::Create<QuantLib::CapFloor::Type>()(OptionType);        // convert object IDs into library objects        OH_GET_REFERENCE(IborIndexLibObjPtr, IborIndex,            QuantLibAddin::IborIndex, QuantLib::IborIndex)        OH_GET_REFERENCE(PricingEngineIDLibObjPtr, PricingEngineID,            QuantLibAddin::PricingEngine, QuantLib::PricingEngine)        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::CALMakeCapFloor(                ObjectId,                OptionType,                Length,                IborIndex,                StrikeCpp,                ForwardStart,                PricingEngineID,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::CapFloor(                valueObject,                OptionTypeEnum,                LengthLib,                IborIndexLibObjPtr,                StrikeCpp,                ForwardStartLib,                PricingEngineIDLibObjPtr,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::Repository::instance().storeObject(ObjectId, object, Overwrite);        // Convert and return the return value        return returnValue;        } catch (const std::exception &e) {            OH_FAIL("Error in function CALMakeCapFloor : " << e.what());        }    }

DLLEXPORT char *createPortfolioEvolver(char *objectID, char *portfolioID, char *pathGeneratorID, OPER* dates, int holdingPeriodInDays, bool *permanent) {    boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;    static char ret[XL_MAX_STR_LEN];    try     {        functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>            (new ObjectHandler::FunctionCall("createPortfolioEvolver"));        OH_GET_OBJECT(portfolioIDLibObjPtr, portfolioID, sjdObjects::Portfolio);        OH_GET_OBJECT(pathGeneratorIDLibObjPtr, pathGeneratorID, sjdObjects::SingleFactorEconomicScenarioGenerator);                std::vector<QuantLib::Date> DatesLib =            ObjectHandler::operToVector<QuantLib::Date>(*dates, "Dates");                if (!sjd::isStrictlyIncreasing<QuantLib::Date>(DatesLib))         {            ObjectHandler::stringToChar("Input dates vector not increasing", ret);            return ret;        }        set<Date> dateSet = set<Date>(DatesLib.begin(), DatesLib.end());        // Strip the Excel cell update counter suffix from Object IDs                std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(objectID);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new sjdObjects::ValueObjects::GenericUnimplementedValueObject(ObjectIdStrip,*permanent));                sjdObjects::PortfolioEvolver *pe;                if (holdingPeriodInDays <= 0)        {            pe = new sjdObjects::PortfolioEvolver(valueObject,                                                   portfolioIDLibObjPtr,                                                   pathGeneratorIDLibObjPtr,                                                   dateSet,                                                   *permanent);                }        else        {            pe = new sjdObjects::PortfolioEvolver(valueObject,                                                   portfolioIDLibObjPtr,                                                   pathGeneratorIDLibObjPtr,                                                   dateSet,                                                   holdingPeriodInDays,                                                  *permanent);                }        if (!pe->isOK())        {            ObjectHandler::stringToChar(pe->getErrorMessages(), ret);            return ret;        }        boost::shared_ptr<ObjectHandler::Object> object = boost::shared_ptr<ObjectHandler::Object>(pe);        std::string returnValue =            ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, true);        ObjectHandler::stringToChar(returnValue, ret);        return ret;    }     SJD_XLL_CATCH_STRING()}

XLL_DEC char *qlAmericanExercise(        char *ObjectId,        OPER *EarliestDate,        OPER *LatestDate,        OPER *PayoffAtExpiry,        OPER *Permanent,        OPER *Trigger,        bool *Overwrite) {    // declare a shared pointer to the Function Call object    boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;    try {        // instantiate the Function Call object        functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(            new ObjectHandler::FunctionCall("qlAmericanExercise"));        ObjectHandler::validateRange(Trigger, "Trigger");        // initialize the session ID (if enabled)        SET_SESSION_ID        // convert input datatypes to C++ datatypes        ObjectHandler::property_t EarliestDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(            ObjectHandler::ConvertOper(*EarliestDate));        ObjectHandler::property_t LatestDateCpp = ObjectHandler::convert2<ObjectHandler::property_t>(            ObjectHandler::ConvertOper(*LatestDate));        bool PayoffAtExpiryCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*PayoffAtExpiry), "PayoffAtExpiry", false);        bool PermanentCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*Permanent), "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Date EarliestDateLib = ObjectHandler::convert2<QuantLib::Date>(            ObjectHandler::ConvertOper(*EarliestDate), "EarliestDate");        QuantLib::Date LatestDateLib = ObjectHandler::convert2<QuantLib::Date>(            ObjectHandler::ConvertOper(*LatestDate), "LatestDate");        // Strip the Excel cell update counter suffix from Object IDs                std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlAmericanExercise(                ObjectIdStrip,                EarliestDateCpp,                LatestDateCpp,                PayoffAtExpiryCpp,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::AmericanExercise(                valueObject,                EarliestDateLib,                LatestDateLib,                PayoffAtExpiryCpp,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::RepositoryXL::instance().storeObject(ObjectIdStrip, object, *Overwrite, valueObject);        // Convert and return the return value        static char ret[XL_MAX_STR_LEN];        ObjectHandler::stringToChar(returnValue, ret);        return ret;    } catch (const std::exception &e) {        ObjectHandler::RepositoryXL::instance().logError(e.what(), functionCall);        return 0;    } catch (...) {        ObjectHandler::RepositoryXL::instance().logError("unkown error type", functionCall);        return 0;    }}

    std::string qlBlackConstantVol(            const std::string &ObjectId,            const ObjectHandler::property_t &SettlementDate,            const std::string &Calendar,            const double &Volatility,            const ObjectHandler::property_t &DayCounter,            const ObjectHandler::property_t &Permanent,            const ObjectHandler::property_t &Trigger,            const bool &Overwrite) {        try {        // convert input datatypes to C++ datatypes        std::string DayCounterCpp = ObjectHandler::convert2<std::string>(            DayCounter, "DayCounter", "Actual/365 (Fixed)");        bool PermanentCpp = ObjectHandler::convert2<bool>(            Permanent, "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Date SettlementDateLib = ObjectHandler::convert2<QuantLib::Date>(            SettlementDate, "SettlementDate");        // convert input datatypes to QuantLib enumerated datatypes        QuantLib::Calendar CalendarEnum =            ObjectHandler::Create<QuantLib::Calendar>()(Calendar);        QuantLib::DayCounter DayCounterEnum =            ObjectHandler::Create<QuantLib::DayCounter>()(DayCounterCpp);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlBlackConstantVol(                ObjectId,                SettlementDate,                Calendar,                Volatility,                DayCounterCpp,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::BlackConstantVol(                valueObject,                SettlementDateLib,                CalendarEnum,                Volatility,                DayCounterEnum,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::Repository::instance().storeObject(ObjectId, object, Overwrite, valueObject);        // Convert and return the return value        return returnValue;        } catch (const std::exception &e) {            OH_FAIL("Error in function qlBlackConstantVol : " << e.what());        }    }

XLL_DEC char *qlPiecewiseYieldCurve(        char *ObjectId,        OPER *NDays,        char *Calendar,        OPER *RateHelpers,        OPER *DayCounter,        OPER *Jumps,        OPER *JumpDates,        OPER *Accuracy,        OPER *TraitsID,        OPER *InterpolatorID,        OPER *Permanent,        OPER *Trigger,        bool *Overwrite) {    // declare a shared pointer to the Function Call object    boost::shared_ptr<ObjectHandler::FunctionCall> functionCall;    try {        // instantiate the Function Call object        functionCall = boost::shared_ptr<ObjectHandler::FunctionCall>(            new ObjectHandler::FunctionCall("qlPiecewiseYieldCurve"));        ObjectHandler::validateRange(Trigger, "Trigger");        // initialize the session ID (if enabled)        SET_SESSION_ID        // convert input datatypes to C++ datatypes        long NDaysCpp = ObjectHandler::convert2<long>(            ObjectHandler::ConvertOper(*NDays), "NDays", 0);        std::vector<std::string> RateHelpersCpp =            ObjectHandler::operToVector<std::string>(*RateHelpers, "RateHelpers");        std::string DayCounterCpp = ObjectHandler::convert2<std::string>(            ObjectHandler::ConvertOper(*DayCounter), "DayCounter", "Actual/365 (Fixed)");        std::vector<ObjectHandler::property_t> JumpsCpp =            ObjectHandler::operToVector<ObjectHandler::property_t>(*Jumps, "Jumps");        std::vector<ObjectHandler::property_t> JumpDatesCpp =            ObjectHandler::operToVector<ObjectHandler::property_t>(*JumpDates, "JumpDates");        double AccuracyCpp = ObjectHandler::convert2<double>(            ObjectHandler::ConvertOper(*Accuracy), "Accuracy", 1.0e-12);        std::string TraitsIDCpp = ObjectHandler::convert2<std::string>(            ObjectHandler::ConvertOper(*TraitsID), "TraitsID", "Discount");        std::string InterpolatorIDCpp = ObjectHandler::convert2<std::string>(            ObjectHandler::ConvertOper(*InterpolatorID), "InterpolatorID", "LogLinear");        bool PermanentCpp = ObjectHandler::convert2<bool>(            ObjectHandler::ConvertOper(*Permanent), "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Natural NDaysLib = ObjectHandler::convert2<QuantLib::Natural>(            ObjectHandler::ConvertOper(*NDays), "NDays", 0);        std::vector<QuantLib::Date> JumpDatesLib =            ObjectHandler::operToVector<QuantLib::Date>(*JumpDates, "JumpDates");        QuantLib::Real AccuracyLib = ObjectHandler::convert2<QuantLib::Real>(            ObjectHandler::ConvertOper(*Accuracy), "Accuracy", 1.0e-12);        // convert input datatypes to QuantLib enumerated datatypes        QuantLib::Calendar CalendarEnum =            ObjectHandler::Create<QuantLib::Calendar>()(Calendar);        QuantLib::DayCounter DayCounterEnum =            ObjectHandler::Create<QuantLib::DayCounter>()(DayCounterCpp);        // convert object IDs into library objects        std::vector<boost::shared_ptr<QuantLib::RateHelper> > RateHelpersLibObjPtr =            ObjectHandler::getLibraryObjectVector<QuantLibAddin::RateHelper, QuantLib::RateHelper>(RateHelpersCpp);        std::vector<QuantLib::Handle<QuantLib::Quote> > JumpsLibObj =            ObjectHandler::operToVector<QuantLib::Handle<QuantLib::Quote> >(*Jumps, "Jumps");        // Strip the Excel cell update counter suffix from Object IDs                std::string ObjectIdStrip = ObjectHandler::CallingRange::getStub(ObjectId);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlPiecewiseYieldCurve(                ObjectIdStrip,                NDaysCpp,                Calendar,                RateHelpersCpp,//.........这里部分代码省略.........

    std::string CALDaAsianOption(            const std::string &ObjectId,            const std::string &AverageType,            const double &RunningAccumulator,            const long &PastFixings,            const std::vector<ObjectHandler::property_t>& FixingDates,            const std::string &Payoff,            const std::string &Exercise,            const ObjectHandler::property_t &Permanent,            const ObjectHandler::property_t &Trigger,            const bool &Overwrite) {        try {        // convert input datatypes to C++ datatypes        bool PermanentCpp = ObjectHandler::convert2<bool>(            Permanent, "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Size PastFixingsLib;        QuantLibAddin::cppToLibrary(PastFixings, PastFixingsLib);        std::vector<QuantLib::Date> FixingDatesLib =             ObjectHandler::vector::convert2<QuantLib::Date>(FixingDates, "FixingDates");        // convert input datatypes to QuantLib enumerated datatypes        QuantLib::Average::Type AverageTypeEnum =            ObjectHandler::Create<QuantLib::Average::Type>()(AverageType);        // convert object IDs into library objects        OH_GET_REFERENCE(PayoffLibObjPtr, Payoff,            QuantLibAddin::StrikedTypePayoff, QuantLib::StrikedTypePayoff)        OH_GET_REFERENCE(ExerciseLibObjPtr, Exercise,            QuantLibAddin::Exercise, QuantLib::Exercise)        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::CALDaAsianOption(                ObjectId,                AverageType,                RunningAccumulator,                PastFixings,                FixingDates,                Payoff,                Exercise,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::DiscreteAveragingAsianOption(                valueObject,                AverageTypeEnum,                RunningAccumulator,                PastFixingsLib,                FixingDatesLib,                PayoffLibObjPtr,                ExerciseLibObjPtr,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::Repository::instance().storeObject(ObjectId, object, Overwrite);        // Convert and return the return value        return returnValue;        } catch (const std::exception &e) {            OH_FAIL("Error in function CALDaAsianOption : " << e.what());        }    }

STRING SAL_CALL CalcAddins_impl::qlEuribor(        const STRING &ObjectId,        const STRING &Tenor,        const ANY &YieldCurve,        const ANY &Permanent,        const ANY &Trigger,        sal_Int32 Overwrite) throw(RuntimeException) {    try {        // convert input datatypes to C++ datatypes        std::string ObjectIdCpp = ouStringToStlString(ObjectId);        std::string TenorCpp = ouStringToStlString(Tenor);        std::string YieldCurveCpp;        calcToScalar(YieldCurveCpp, YieldCurve);        bool PermanentCpp;        calcToScalar(PermanentCpp, Permanent);        // convert object IDs into library objects	// RL: Use OH_GET_OBJECT_DEFAULT instead of OH_GET_OBJECT         OH_GET_OBJECT_DEFAULT(YieldCurveCoerce, YieldCurveCpp, ObjectHandler::Object)        QuantLib::Handle<QuantLib::YieldTermStructure> YieldCurveLibObj =            QuantLibAddin::CoerceHandle<                QuantLibAddin::YieldTermStructure,                QuantLib::YieldTermStructure>()(                    YieldCurveCoerce);        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlEuribor(                ObjectIdCpp,                TenorCpp,                YieldCurveCpp,                PermanentCpp));        // Construct the Object                boost::shared_ptr<ObjectHandler::Object> object(            new QuantLibAddin::Euribor(                valueObject,                TenorCpp,                YieldCurveLibObj,                PermanentCpp));        // Store the Object in the Repository        std::string returnValue =            ObjectHandler::Repository::instance().storeObject(ObjectIdCpp, object, Overwrite);        // Convert and return the return value        STRING returnValueCalc;        scalarToCalc(returnValueCalc, returnValue);        return returnValueCalc;    } catch (const std::exception &e) {        OH_LOG_MESSAGE("ERROR: qlEuribor: " << e.what());        THROW_RTE;    }}

    std::string qlFloatingRateBond(            const std::string &ObjectId,            const ObjectHandler::property_t &Description,            const std::string &Currency,            const long &SettlementDays,            const ObjectHandler::property_t &PaymentBDC,            const ObjectHandler::property_t &FaceAmount,            const std::string &ScheduleID,            const ObjectHandler::property_t &FixingDays,            const ObjectHandler::property_t &IsInArrears,            const std::string &DayCounter,            const std::vector<double>& Floors,            const std::vector<double>& Gearings,            const std::string &IborIndex,            const std::vector<double>& Spreads,            const std::vector<double>& Caps,            const ObjectHandler::property_t &Redemption,            const ObjectHandler::property_t &IssueDate,            const ObjectHandler::property_t &Permanent,            const ObjectHandler::property_t &Trigger,            const bool &Overwrite) {        try {        // convert input datatypes to C++ datatypes        std::string DescriptionCpp = ObjectHandler::convert2<std::string>(            Description, "Description", std::string());        std::string PaymentBDCCpp = ObjectHandler::convert2<std::string>(            PaymentBDC, "PaymentBDC", "Following");        double FaceAmountCpp = ObjectHandler::convert2<double>(            FaceAmount, "FaceAmount", 100.0);        long FixingDaysCpp = ObjectHandler::convert2<long>(            FixingDays, "FixingDays", QuantLib::Null<QuantLib::Natural>());        bool IsInArrearsCpp = ObjectHandler::convert2<bool>(            IsInArrears, "IsInArrears", false);        double RedemptionCpp = ObjectHandler::convert2<double>(            Redemption, "Redemption", 100);        bool PermanentCpp = ObjectHandler::convert2<bool>(            Permanent, "Permanent", false);        // convert input datatypes to QuantLib datatypes        QuantLib::Size SettlementDaysLib;        QuantLibAddin::cppToLibrary(SettlementDays, SettlementDaysLib);        QuantLib::Real FaceAmountLib = ObjectHandler::convert2<QuantLib::Real>(            FaceAmount, "FaceAmount", 100.0);        QuantLib::Natural FixingDaysLib = ObjectHandler::convert2<long>(            FixingDays, "FixingDays", QuantLib::Null<QuantLib::Natural>());        QuantLib::Real RedemptionLib = ObjectHandler::convert2<QuantLib::Real>(            Redemption, "Redemption", 100);        QuantLib::Date IssueDateLib = ObjectHandler::convert2<QuantLib::Date>(            IssueDate, "IssueDate", QuantLib::Date());        // convert input datatypes to QuantLib enumerated datatypes        QuantLib::Currency CurrencyEnum =            ObjectHandler::Create<QuantLib::Currency>()(Currency);        QuantLib::BusinessDayConvention PaymentBDCEnum =            ObjectHandler::Create<QuantLib::BusinessDayConvention>()(PaymentBDCCpp);        QuantLib::DayCounter DayCounterEnum =            ObjectHandler::Create<QuantLib::DayCounter>()(DayCounter);        // convert object IDs into library objects        OH_GET_REFERENCE(ScheduleIDLibObjPtr, ScheduleID,            QuantLibAddin::Schedule, QuantLib::Schedule)        OH_GET_REFERENCE(IborIndexLibObjPtr, IborIndex,            QuantLibAddin::IborIndex, QuantLib::IborIndex)        // Construct the Value Object        boost::shared_ptr<ObjectHandler::ValueObject> valueObject(            new QuantLibAddin::ValueObjects::qlFloatingRateBond(                ObjectId,                DescriptionCpp,                Currency,                SettlementDays,                PaymentBDCCpp,                FaceAmountCpp,                ScheduleID,                FixingDaysCpp,                IsInArrearsCpp,                DayCounter,                Floors,                Gearings,                IborIndex,//.........这里部分代码省略.........