예제 #1
0
 qlAssetSwap::qlAssetSwap(
         const std::string& ObjectId,
         bool PayBondCoupon,
         const std::string& Bond,
         double CleanPrice,
         const std::string& IborIndex,
         double Spread,
         const std::string& FloatingLegSchedule,
         const std::string& FloatingLegDayCounter,
         bool ParAssetSwap,
         bool Permanent) :
     ObjectHandler::ValueObject(ObjectId, "qlAssetSwap", Permanent),
     PayBondCoupon_(PayBondCoupon),
     Bond_(Bond),
     CleanPrice_(CleanPrice),
     IborIndex_(IborIndex),
     Spread_(Spread),
     FloatingLegSchedule_(FloatingLegSchedule),
     FloatingLegDayCounter_(FloatingLegDayCounter),
     ParAssetSwap_(ParAssetSwap),
     Permanent_(Permanent) {
               
         processPrecedentID(Bond);
         processPrecedentID(IborIndex);
         processPrecedentID(FloatingLegSchedule);
         
 }
예제 #2
0
 qlAssetSwap2::qlAssetSwap2(
         const std::string& ObjectId,
         bool ParAssetSwap,
         const std::string& Bond,
         double CleanPrice,
         double NonParRepayment,
         double Gearing,
         const std::string& IborIndex,
         double Spread,
         const std::string& FloatingLegDayCounter,
         const ObjectHandler::property_t& DealMaturity,
         bool PayBondCoupon,
         bool Permanent) :
     ObjectHandler::ValueObject(ObjectId, "qlAssetSwap2", Permanent),
     ParAssetSwap_(ParAssetSwap),
     Bond_(Bond),
     CleanPrice_(CleanPrice),
     NonParRepayment_(NonParRepayment),
     Gearing_(Gearing),
     IborIndex_(IborIndex),
     Spread_(Spread),
     FloatingLegDayCounter_(FloatingLegDayCounter),
     DealMaturity_(DealMaturity),
     PayBondCoupon_(PayBondCoupon),
     Permanent_(Permanent) {
               
         processPrecedentID(Bond);
         processPrecedentID(IborIndex);
         
 }
예제 #3
0
 qlSwaption::qlSwaption(
         const std::string& ObjectId,
         const std::string& VanillaSwap,
         const std::string& Exercise,
         const std::string& SettlementType,
         bool Permanent) :
     ObjectHandler::ValueObject(ObjectId, "qlSwaption", Permanent),
     VanillaSwap_(VanillaSwap),
     Exercise_(Exercise),
     SettlementType_(SettlementType),
     Permanent_(Permanent) {
               
         processPrecedentID(VanillaSwap);
         processPrecedentID(Exercise);
         
 }
예제 #4
0
 qlCmsMarketCalibration::qlCmsMarketCalibration(
         const std::string& ObjectId,
         const std::string& VolCube,
         const std::string& CmsMarket,
         const std::vector<std::vector<double> >& Weights,
         const std::string& CalibrationType,
         bool Permanent) :
     ObjectHandler::ValueObject(ObjectId, "qlCmsMarketCalibration", Permanent),
     VolCube_(VolCube),
     CmsMarket_(CmsMarket),
     Weights_(Weights),
     CalibrationType_(CalibrationType),
     Permanent_(Permanent) {
               
         processPrecedentID(VolCube);
         processPrecedentID(CmsMarket);
         
 }
예제 #5
0
 qlMakeSwaption::qlMakeSwaption(
         const std::string& ObjectId,
         const std::string& SwapIndex,
         const std::string& OptionTenor,
         double Strike,
         const std::string& PricingEngineID,
         bool Permanent) :
     ObjectHandler::ValueObject(ObjectId, "qlMakeSwaption", Permanent),
     SwapIndex_(SwapIndex),
     OptionTenor_(OptionTenor),
     Strike_(Strike),
     PricingEngineID_(PricingEngineID),
     Permanent_(Permanent) {
               
         processPrecedentID(SwapIndex);
         processPrecedentID(PricingEngineID);
         
 }
 qlRelinkableHandleDefaultProbabilityTermStructure::qlRelinkableHandleDefaultProbabilityTermStructure(
         const std::string& ObjectId,
         const std::string& CurrentLink,
         bool Permanent) :
     ObjectHandler::ValueObject(ObjectId, "qlRelinkableHandleDefaultProbabilityTermStructure", Permanent),
     CurrentLink_(CurrentLink),
     Permanent_(Permanent) {
               
         processPrecedentID(CurrentLink);
         
 }
예제 #7
0
 qlOvernightIndexedSwapFromOISRateHelper::qlOvernightIndexedSwapFromOISRateHelper(
         const std::string& ObjectId,
         const std::string& OISRateHelper,
         bool Permanent) :
     ObjectHandler::ValueObject(ObjectId, "qlOvernightIndexedSwapFromOISRateHelper", Permanent),
     OISRateHelper_(OISRateHelper),
     Permanent_(Permanent) {
               
         processPrecedentID(OISRateHelper);
         
 }
예제 #8
0
 qlSabrVolSurface::qlSabrVolSurface(
         const std::string& ObjectId,
         const std::string& InterestRateIndex,
         const std::string& BlackAtmVolCurve,
         const std::vector<ObjectHandler::property_t>& OptionTenors,
         const std::vector<double>& AtmRateSpreads,
         const std::vector<std::vector<ObjectHandler::property_t> >& VolatilitiesQuotes,
         bool Permanent) :
     ObjectHandler::ValueObject(ObjectId, "qlSabrVolSurface", Permanent),
     InterestRateIndex_(InterestRateIndex),
     BlackAtmVolCurve_(BlackAtmVolCurve),
     OptionTenors_(OptionTenors),
     AtmRateSpreads_(AtmRateSpreads),
     VolatilitiesQuotes_(VolatilitiesQuotes),
     Permanent_(Permanent) {
               
         processPrecedentID(InterestRateIndex);
         processPrecedentID(BlackAtmVolCurve);
         processVariant(VolatilitiesQuotes);
         
 }
예제 #9
0
 qlScheduleTruncated::qlScheduleTruncated(
         const std::string& ObjectId,
         const std::string& OriginalSchedule,
         const ObjectHandler::property_t& TruncationDate,
         bool Permanent) :
     ObjectHandler::ValueObject(ObjectId, "qlScheduleTruncated", Permanent),
     OriginalSchedule_(OriginalSchedule),
     TruncationDate_(TruncationDate),
     Permanent_(Permanent) {
               
         processPrecedentID(OriginalSchedule);
         
 }
예제 #10
0
 qlImpliedTermStructure::qlImpliedTermStructure(
         const std::string& ObjectId,
         const std::string& BaseYieldCurve,
         const ObjectHandler::property_t& ReferenceDate,
         bool Permanent) :
     ObjectHandler::ValueObject(ObjectId, "qlImpliedTermStructure", Permanent),
     BaseYieldCurve_(BaseYieldCurve),
     ReferenceDate_(ReferenceDate),
     Permanent_(Permanent) {
               
         processPrecedentID(BaseYieldCurve);
         
 }
예제 #11
0
 qlForwardSpreadedTermStructure::qlForwardSpreadedTermStructure(
         const std::string& ObjectId,
         const std::string& BaseYieldCurve,
         const ObjectHandler::property_t& Spread,
         bool Permanent) :
     ObjectHandler::ValueObject(ObjectId, "qlForwardSpreadedTermStructure", Permanent),
     BaseYieldCurve_(BaseYieldCurve),
     Spread_(Spread),
     Permanent_(Permanent) {
               
         processPrecedentID(BaseYieldCurve);
         processVariant(Spread);
         
 }
예제 #12
0
 qlOvernightIndexedSwap::qlOvernightIndexedSwap(
         const std::string& ObjectId,
         const std::string& PayerReceiver,
         const std::vector<double>& Nominal,
         const std::string& Schedule,
         double FixedRate,
         const std::string& FixDayCounter,
         const std::string& OvernightIndex,
         double Spread,
         bool Permanent) :
     ObjectHandler::ValueObject(ObjectId, "qlOvernightIndexedSwap", Permanent),
     PayerReceiver_(PayerReceiver),
     Nominal_(Nominal),
     Schedule_(Schedule),
     FixedRate_(FixedRate),
     FixDayCounter_(FixDayCounter),
     OvernightIndex_(OvernightIndex),
     Spread_(Spread),
     Permanent_(Permanent) {
               
         processPrecedentID(Schedule);
         processPrecedentID(OvernightIndex);
         
 }
zeroCouponInflationSwapUnitedStatesValueObject::zeroCouponInflationSwapUnitedStatesValueObject(
    const std::string & ObjectId,
    const std::vector<std::string> & LegIDs,
    const std::vector<std::string> & LegTypes,
    const std::vector<bool> & Payer,
    bool Permanent) :
    ObjectHandler::ValueObject(ObjectId, "zeroCouponInflationSwapUnitedStatesValueObject", Permanent),
    LegIDs_(LegIDs),
    LegTypes_(LegTypes),
    Payer_(Payer),
    Permanent_(Permanent) {

    for (std::vector<std::string>::const_iterator i = LegIDs.begin() ;

            i != LegIDs.end() ; ++i) processPrecedentID(*i) ;

}
예제 #14
0
 qlMakeOIS::qlMakeOIS(
         const std::string& ObjectId,
         const std::string& SwapTenor,
         const std::string& OvernightIndex,
         double FixedRate,
         const std::string& ForwardStart,
         const std::string& FixDayCounter,
         double Spread,
         bool Permanent) :
     ObjectHandler::ValueObject(ObjectId, "qlMakeOIS", Permanent),
     SwapTenor_(SwapTenor),
     OvernightIndex_(OvernightIndex),
     FixedRate_(FixedRate),
     ForwardStart_(ForwardStart),
     FixDayCounter_(FixDayCounter),
     Spread_(Spread),
     Permanent_(Permanent) {
               
         processPrecedentID(OvernightIndex);
         
 }
예제 #15
0
 qlMakeDatedOIS::qlMakeDatedOIS(
         const std::string& ObjectId,
         const ObjectHandler::property_t& StartDate,
         const ObjectHandler::property_t& EndDate,
         const std::string& OvernightIndex,
         double FixedRate,
         const std::string& FixDayCounter,
         double Spread,
         bool Permanent) :
     ObjectHandler::ValueObject(ObjectId, "qlMakeDatedOIS", Permanent),
     StartDate_(StartDate),
     EndDate_(EndDate),
     OvernightIndex_(OvernightIndex),
     FixedRate_(FixedRate),
     FixDayCounter_(FixDayCounter),
     Spread_(Spread),
     Permanent_(Permanent) {
               
         processPrecedentID(OvernightIndex);
         
 }