/// <summary>
/// Converts to an adjustable date type.
/// </summary>
/// <param name="unadjustedDate"></param>
/// <param name="businessDayConvention"></param>
/// <param name="businessCentersAsString"></param>
/// <returns></returns>
public static AdjustableDate ToAdjustableDate(DateTime unadjustedDate, BusinessDayConventionEnum businessDayConvention, string businessCentersAsString)
{
AdjustableDate result = ToAdjustableDate(unadjustedDate, businessDayConvention);
result.dateAdjustments.businessCenters = BusinessCentersHelper.Parse(businessCentersAsString);
return(result);
}
/// <summary>
/// Find the next business day with respect to the given date and
/// rolling convention.
/// </summary>
/// <param name="date">The date.</param>
/// <param name="businessDayConvention">The business day convention.</param>
/// <returns>Returns the resulting <see cref="DateTime"/>.</returns>
public DateTime Roll(DateTime date, BusinessDayConventionEnum businessDayConvention)
{
// QL_REQUIRE(d!=Date(), "Calendar::roll : null date");
DateTime rolledDate = date;
if (businessDayConvention == BusinessDayConventionEnum.FOLLOWING || businessDayConvention == BusinessDayConventionEnum.MODFOLLOWING)
{
while (IsHoliday(rolledDate))
{
rolledDate = Calendar.AddDays(rolledDate, 1);
}
if (businessDayConvention == BusinessDayConventionEnum.MODFOLLOWING && rolledDate.Month != date.Month)
{
return(Roll(date, BusinessDayConventionEnum.PRECEDING));
}
}
else if (businessDayConvention == BusinessDayConventionEnum.PRECEDING || businessDayConvention == BusinessDayConventionEnum.MODPRECEDING)
{
while (IsHoliday(rolledDate))
{
rolledDate = Calendar.AddDays(rolledDate, -1);
}
if (businessDayConvention == BusinessDayConventionEnum.MODPRECEDING && rolledDate.Month != date.Month)
{
return(Roll(date, BusinessDayConventionEnum.FOLLOWING));
}
}
else if (businessDayConvention != BusinessDayConventionEnum.NONE)
{
throw new ArgumentOutOfRangeException(nameof(businessDayConvention), "Unknown rolling convention.");
}
return(rolledDate);
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableRateCoupon"/> class.
/// </summary>
/// <param name="cashflowId">The stream id.</param>
/// <param name="payerIsBase">The payer is base flag.</param>
/// <param name="accrualStartDate">The accrual start date. If adjusted, the adjustCalculationDatesIndicator should be false.</param>
/// <param name="accrualEndDate">The accrual end date. If adjusted, the adjustCalculationDatesIndicator should be false.</param>
/// <param name="adjustCalculationDatesIndicator">if set to <c>true</c> [adjust calculation dates indicator].</param>
/// <param name="accrualBusinessCenters">The accrual business centers.</param>
/// <param name="fixedRate">The fixed rate.</param>
/// <param name="notionalAmount">The notional amount.</param>
/// <param name="dayCountFraction">Type of day Count fraction.</param>
/// <param name="paymentDate">The payment date.</param>
/// <param name="accrualRollConvention">The accrual roll convention.</param>
/// <param name="discountingType">The swap discounting type.</param>
/// <param name="discountRate">The discount rate.</param>
/// <param name="fraDiscounting">Determines whether the coupon is discounted or not. If this parameter is null,
/// then it is assumed that there is no fra discounting</param>
/// <param name="paymentCalendar">The paymentCalendar.</param>
public PriceableFixedRateCoupon
(
string cashflowId
, bool payerIsBase
, DateTime accrualStartDate
, DateTime accrualEndDate
, bool adjustCalculationDatesIndicator
, BusinessCenters accrualBusinessCenters
, BusinessDayConventionEnum accrualRollConvention
, DayCountFraction dayCountFraction
, decimal fixedRate
, Money notionalAmount
, AdjustableOrAdjustedDate paymentDate
, DiscountingTypeEnum?discountingType
, decimal?discountRate
, FraDiscountingEnum?fraDiscounting
, IBusinessCalendar paymentCalendar)
: base(cashflowId, CouponType.FixedRate, payerIsBase, accrualStartDate, accrualEndDate, adjustCalculationDatesIndicator,
accrualBusinessCenters, accrualRollConvention, dayCountFraction, fixedRate, notionalAmount, paymentDate,
discountingType, discountRate, fraDiscounting, paymentCalendar)
{
Id = cashflowId;
CalculatePaymentAmount(0);
ForecastAmount = PaymentAmount;
}
public DateOffset(XmlNode xmlNode)
: base(xmlNode)
{
XmlNodeList businessDayConventionNodeList = xmlNode.SelectNodes("businessDayConvention");
if (businessDayConventionNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in businessDayConventionNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
businessDayConventionIDRef = item.Attributes["id"].Name;
BusinessDayConventionEnum ob = BusinessDayConventionEnum();
IDManager.SetID(businessDayConventionIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
businessDayConventionIDRef = item.Attributes["href"].Name;
}
else
{
businessDayConvention = new BusinessDayConventionEnum(item);
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableFxRateCashflow"/> class.
/// </summary>
/// <param name="cashlfowId">The stream id.</param>
/// <param name="payerIsBase">The payer is base flag.</param>
/// <param name="accrualStartDate">The accrual start date. If adjusted, the adjustCalculationDatesIndicator should be false.</param>
/// <param name="accrualEndDate">The accrual end date. If adjusted, the adjustCalculationDatesIndicator should be false.</param>
/// <param name="adjustAccrualDatesIndicator">if set to <c>true</c> [adjust calculation dates indicator].</param>
/// <param name="accrualBusinessCenters">The accrual business centers.</param>
/// <param name="margin">The margin.</param>
/// <param name="baseRate">The base rate for a nettable fixed/floating cash flow. </param>
/// <param name="observedRate">The observed Rate.</param>
/// <param name="notionalAmount">The notional amount.</param>
/// <param name="dayCountfraction">Type of day Countfraction.</param>
/// <param name="paymentDate">The payment date.</param>
/// <param name="accrualRollConvention">The accrual roll convention.</param>
/// <param name="resetRelativeTo">reset relative to?</param>
/// <param name="fixingDateRelativeOffset">The fixing date offset.</param>
/// <param name="forecastRateIndex">The forecastrateindex.</param>
/// <param name="discountingType">The swap discounting type.</param>
/// <param name="discountRate">The discount rate.</param>
/// <param name="fraDiscounting">Determines whether the coupon is discounted or not. If this parameter is null,
/// then it is assumed that there is no fradiscounting</param>
/// <param name="fixingCalendar">The fixingCalendar.</param>
/// <param name="paymentCalendar">The paymentCalendar.</param>
public PriceableFloatingRateCoupon
(
string cashlfowId
, bool payerIsBase
, DateTime accrualStartDate
, DateTime accrualEndDate
, Boolean adjustAccrualDatesIndicator
, BusinessCenters accrualBusinessCenters
, BusinessDayConventionEnum accrualRollConvention
, DayCountFraction dayCountfraction
, ResetRelativeToEnum resetRelativeTo
, RelativeDateOffset fixingDateRelativeOffset
, Decimal margin
, Decimal baseRate
, Decimal?observedRate
, Money notionalAmount
, AdjustableOrAdjustedDate paymentDate
, ForecastRateIndex forecastRateIndex
, DiscountingTypeEnum?discountingType
, Decimal?discountRate
, FraDiscountingEnum?fraDiscounting
, IBusinessCalendar fixingCalendar
, IBusinessCalendar paymentCalendar)
: base(
cashlfowId
, CouponType.FloatingRate
, payerIsBase
, accrualStartDate
, accrualEndDate
, adjustAccrualDatesIndicator
, accrualBusinessCenters
, accrualRollConvention
, dayCountfraction
, observedRate
, notionalAmount
, paymentDate
, discountingType
, discountRate
, fraDiscounting
, paymentCalendar)
{
BaseRate = baseRate;
FixingCalendar = fixingCalendar;
ModelIdentifier = "DualCurveCouponModel";
Id = cashlfowId;
ForwardStartDate = AccrualStartDate;
ForecastRateIndex = forecastRateIndex;
FixingDateRelativeOffset = fixingDateRelativeOffset;
ResetRelativeTo = resetRelativeTo;
Margin = margin;
AdjustedFixingDate = GetResetDate(resetRelativeTo, fixingDateRelativeOffset);
if (observedRate != null)
{
RateObservation = RateObservationHelper.Parse(AdjustedFixingDate, (decimal)observedRate, "1");
}
SetRateObservation(RateObservation, ResetDate);
ForecastCurveName = CurveNameHelpers.GetForecastCurveName(forecastRateIndex);
}
public static BusinessDayAdjustments Create(BusinessDayConventionEnum businessDayConvention, BusinessCenters businessCenters)
{
var result = new BusinessDayAdjustments
{
businessDayConvention = businessDayConvention,
businessCenters = businessCenters
};
return(result);
}
public static BusinessDayAdjustments Create(BusinessDayConventionEnum businessDayConvention, string businessCentersAsString)
{
var result = new BusinessDayAdjustments
{
businessDayConvention = businessDayConvention,
businessCenters =
BusinessCentersHelper.Parse(businessCentersAsString)
};
return(result);
}
/// <summary>
/// Converts t an adjustable date type.
/// </summary>
/// <param name="unadjustedDate"></param>
/// <param name="businessDayConvention"></param>
/// <returns></returns>
public static AdjustableDate ToAdjustableDate(DateTime unadjustedDate, BusinessDayConventionEnum businessDayConvention)
{
var result = new AdjustableDate {
unadjustedDate = ToUnadjustedIdentifiedDate(unadjustedDate)
};
var businessDayAdjustments = new BusinessDayAdjustments
{
businessDayConvention = businessDayConvention,
businessDayConventionSpecified = true
};
result.dateAdjustments = businessDayAdjustments;
return(result);
}
/// <summary>
/// Advances the specified calendars.
/// </summary>
/// <param name="businessCalendar">The calendars.</param>
/// <param name="date">The date.</param>
/// <param name="dayTypeString">The day type string.</param>
/// <param name="periodInterval">The period interval.</param>
/// <param name="businessDayConvention">The business day convention.</param>
/// <returns></returns>
public static DateTime Advance(IBusinessCalendar businessCalendar, DateTime date, string dayTypeString, string periodInterval, string businessDayConvention)
{
//IBusinessCalendar calendar = GetCalendar(calendars, ruleFullFilePath);
Period interval = PeriodHelper.Parse(periodInterval);
var dayType = DayTypeEnum.Calendar;
if (dayTypeString.Length > 0)
{
dayType = (DayTypeEnum)Enum.Parse(typeof(DayTypeEnum), dayTypeString, true);
}
Offset offset = OffsetHelper.FromInterval(interval, dayType);
BusinessDayConventionEnum dayConvention = BusinessDayConventionHelper.Parse(businessDayConvention);
return(businessCalendar.Advance(date, offset, dayConvention));
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableFxRateCashflow"/> class.
/// </summary>
/// <param name="cashlfowId">The stream id.</param>
/// <param name="payerIsBase">The payer is base flag.</param>
/// <param name="accrualStartDate">The accrual start date. If adjusted, the adjustCalculationDatesIndicator should be false.</param>
/// <param name="accrualEndDate">The accrual end date. If adjusted, the adjustCalculationDatesIndicator should be false.</param>
/// <param name="adjustAccrualDatesIndicator">if set to <c>true</c> [adjust calculation dates indicator].</param>
/// <param name="accrualBusinessCenters">The accrual business centers.</param>
/// <param name="margin">The margin.</param>
/// <param name="observedRate">The observed Rate.</param>
/// <param name="notionalAmount">The notional amount.</param>
/// <param name="dayCountfraction">Type of day Countfraction.</param>
/// <param name="paymentDate">The payment date.</param>
/// <param name="accrualRollConvention">The accrual roll convention.</param>
/// <param name="resetRelativeTo">reset relative to?</param>
/// <param name="fixingDateRelativeOffset">The fixing date offset.</param>
/// <param name="forecastRateIndex">The forecastrateindex.</param>
/// <param name="discountingType">The swap discounting type.</param>
/// <param name="discountRate">The discount rate.</param>
/// <param name="fraDiscounting">Determines whether the coupon is discounted or not. If this parameter is null,
/// then it is assumed that there is no fradiscounting</param>
/// <param name="fixingCalendar">The fixingCalendar.</param>
/// <param name="paymentCalendar">The paymentCalendar.</param>
public PriceableFloatingRateCoupon
(
string cashlfowId
, bool payerIsBase
, DateTime accrualStartDate
, DateTime accrualEndDate
, Boolean adjustAccrualDatesIndicator
, BusinessCenters accrualBusinessCenters
, BusinessDayConventionEnum accrualRollConvention
, DayCountFraction dayCountfraction
, ResetRelativeToEnum resetRelativeTo
, RelativeDateOffset fixingDateRelativeOffset
, Decimal margin
, Decimal?observedRate
, Money notionalAmount
, AdjustableOrAdjustedDate paymentDate
, ForecastRateIndex forecastRateIndex
, DiscountingTypeEnum?discountingType
, Decimal?discountRate
, FraDiscountingEnum?fraDiscounting
, IBusinessCalendar fixingCalendar
, IBusinessCalendar paymentCalendar)
: this(
cashlfowId
, payerIsBase
, accrualStartDate
, accrualEndDate
, adjustAccrualDatesIndicator
, accrualBusinessCenters
, accrualRollConvention
, dayCountfraction
, resetRelativeTo
, fixingDateRelativeOffset
, margin
, 0.0m
, observedRate
, notionalAmount
, paymentDate
, forecastRateIndex
, discountingType
, discountRate
, fraDiscounting
, fixingCalendar
, paymentCalendar)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableRateCoupon"/> class.
/// </summary>
/// <param name="cashlfowId">The stream id.</param>
/// <param name="accrualStartDate">The accrual start date. If adjusted, the adjustCalculationDatesIndicator should be false.</param>
/// <param name="accrualEndDate">The accrual end date. If adjusted, the adjustCalculationDatesIndicator should be false.</param>
/// <param name="adjustCalculationDatesIndicator">if set to <c>true</c> [adjust calculation dates indicator].</param>
/// <param name="accrualBusinessCenters">The accrual business centers.</param>
/// <param name="underlyingRateIndex">Te underlying rate index can be Xibor or Swap.</param>
/// <param name="resetLagOffset">This allows for non-standard lags to be used in convexity adjustment calculations.</param>
/// <param name="margin">The margin.</param>
/// <param name="observedRate">The observed Rate.</param>
/// <param name="notionalAmount">The notional amount.</param>
/// <param name="accrualDayCountfraction">Type of day Countfraction used for the acrual period.</param>
/// <param name="paymentDate">The payment date.</param>
/// <param name="accrualRollConvention">The accrual roll convention.</param>
/// <param name="resetRelativeTo">reset relative to?</param>
/// <param name="fixingDateRelativeOffset">The fixing date offset.</param>
/// <param name="forecastRateIndex">The forecastrateindex.</param>
/// <param name="discountingType">The swap discounting type.</param>
/// <param name="discountRate">The discount rate.</param>
/// <param name="fraDiscounting">Determines whether the coupon is discounted or not. If this parameter is null,
/// <param name="underlyingRateIndex"></param>
/// then it is assumed that there is no fradiscounting</param>
public PriceableStructuredRateCoupon
(
string cashlfowId
, DateTime accrualStartDate
, DateTime accrualEndDate
, Boolean adjustCalculationDatesIndicator
, BusinessCenters accrualBusinessCenters
, BusinessDayConventionEnum accrualRollConvention
, DayCountFraction accrualDayCountfraction
, ResetRelativeToEnum resetRelativeTo
, RelativeDateOffset fixingDateRelativeOffset
, RateIndex underlyingRateIndex
, RelativeDateOffset resetLagOffset
, Decimal margin
, Decimal?observedRate
, Money notionalAmount
, AdjustableDate paymentDate
, ForecastRateIndex forecastRateIndex
, DiscountingTypeEnum?discountingType
, Decimal?discountRate
, FraDiscountingEnum?fraDiscounting)
: base(
cashlfowId
, accrualStartDate
, accrualEndDate
, adjustCalculationDatesIndicator
, accrualBusinessCenters
, accrualRollConvention
, accrualDayCountfraction
, resetRelativeTo
, fixingDateRelativeOffset
, margin
, observedRate
, notionalAmount
, paymentDate
, forecastRateIndex
, discountingType
, discountRate
, fraDiscounting
)
{
UnderlyingRateIndex = underlyingRateIndex;
ResetLagOffset = resetLagOffset;
PriceableCouponType = CouponType.StructuredRate;
AnalyticsModel = new StructuredRateCouponAnalytic();
}
/// <summary>
/// Constructor for the class <see cref="SwapRate"/>.</summary>
/// <param name="logger">The logger.</param>
/// <param name="cache">The cache.</param>
/// <param name="nameSpace">The clients namespace</param>
/// <param name="businessCalendar">Four letter (uppercase) code for
/// the business calendar that will be used to generate all dates in
/// the swap schedule.
/// Example: AUSY.</param>
/// <param name="calculationDate">Base date.</param>
/// <param name="dayCount">Three letter (uppercase) code for the day
/// count convention that will be used to compute the accrual factors.
/// Example: ACT/365.</param>
/// <param name="discountFactors">Array of known discount factors.
/// </param>
/// <param name="offsets">The number of days from the Calculation
/// Date to each known discount factor.</param>
/// <param name="fixedSideFrequency">Roll frequency (number of
/// rolls/payments per year) on the fixed side of the swap.
/// Precondition: must be a divisor of 12.
/// Example: Quarterly corresponds to a frequency of 4; Monthly
/// corresponds to a frequency of 12.</param>
/// <param name="rollConvention">Roll convention used to generate
/// the swap schedule.
/// Example: MODFOLLOWING.</param>
public SwapRate(ILogger logger, ICoreCache cache,
string nameSpace,
string businessCalendar,
DateTime calculationDate,
string dayCount,
double[] discountFactors,
int[] offsets,
int fixedSideFrequency,
BusinessDayConventionEnum rollConvention)
{
InitialisePrivateFields(logger, cache,
nameSpace,
businessCalendar,
calculationDate,
dayCount,
discountFactors,
offsets,
fixedSideFrequency,
rollConvention);
}
/// <summary>
/// Adds the period.
/// </summary>
/// <param name="startDate">The start date.</param>
/// <param name="tenorString">The tenor string.</param>
/// <param name="calendar">The calendar.</param>
/// <param name="rollConvention">The roll convention.</param>
/// <param name="dayType">Type of the day.</param>
/// <returns></returns>
public static DateTime AddPeriod(DateTime startDate, string tenorString, IBusinessCalendar calendar, string rollConvention, string dayType)
{
const string defaultRollConvention = "FOLLOWING";
if (calendar == null)
{
calendar = new Hell();
}
if (String.IsNullOrEmpty(rollConvention))
{
rollConvention = defaultRollConvention;
}
Period rollPeriod = PeriodHelper.Parse(tenorString);
if (String.IsNullOrEmpty(dayType))
{
dayType = DayTypeStringFromRollPeriodInterval(rollPeriod);
}
var dayTypeEnum = (DayTypeEnum)Enum.Parse(typeof(DayTypeEnum), dayType, true);
BusinessDayConventionEnum businessDayConvention = BusinessDayConventionHelper.Parse(rollConvention);
DateTime endDate = calendar.Advance(startDate, OffsetHelper.FromInterval(rollPeriod, dayTypeEnum), businessDayConvention);
return(endDate);
}
/// <summary>
/// Master function used by the constructor to initialise all
/// private fields.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="cache">The cache.</param>
/// <param name="nameSpace">The clients namespace</param>
/// <param name="businessCalendar">Four letter (uppercase) code for
/// the business calendar that will be used to generate all dates in
/// the swap schedule.
/// Example: AUSY.</param>
/// <param name="calculationDate">Base date.</param>
/// <param name="dayCount">Three letter (uppercase) code for the day
/// count convention that will be used to compute the accrual factors.
/// Example: ACT/365.</param>
/// <param name="discountFactors">Array of known discount factors.
/// </param>
/// <param name="offsets">The number of days from the Calculation
/// Date to each known discount factor.</param>
/// <param name="fixedSideFrequency">Roll frequency (number of
/// rolls/payments per year) on the fixed side of the swap.
/// Precondition: must be a divisor of 12.
/// Example: Quarterly corresponds to a frequency of 4; Monthly
/// corresponds to a frequency of 12.</param>
/// <param name="rollConvention">Roll convention used to generate
/// the swap schedule.
/// Example: MODFOLLOWING.</param>
private void InitialisePrivateFields
(ILogger logger, ICoreCache cache,
string nameSpace,
string businessCalendar,
DateTime calculationDate,
string dayCount,
double[] discountFactors,
int[] offsets,
int fixedSideFrequency,
BusinessDayConventionEnum rollConvention)
{
// Initialise all private fields, except for the one dimensional
// interpolation object.
_businessCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, new[] { businessCalendar }, nameSpace);
_calculationDate = calculationDate;
_discountFactors = null;
_dayCount = dayCount;
_fixedSideFrequency = fixedSideFrequency;
_rollConvention = rollConvention;
_swapSchedule = null;
// Initialise the one dimensional interpolation object.
InitialiseDiscountFactorObject(discountFactors, offsets);
logger.LogDebug("Discount factors initialised.");
}
public CapletBootstrapEngineHelperTests()
{
const string CalculationDateString = @"2007-11-29";
const string StartDateString = @"2007-11-30";
const bool ValidateArguments = true;
_calculationDate = DateTime.Parse(CalculationDateString);
_capFrequency = CapFrequency.Quarterly;
_capStartLag = 1;
_currency = "AUD";
_handle = "Caplet Bootstrap Engine Helper tests";
_numYears = 10.0d;
_parVolatilityInterpolation =
ParVolatilityInterpolationType.CubicHermiteSpline;
_rollConvention = BusinessDayConventionEnum.MODFOLLOWING;
_startDate = DateTime.Parse(StartDateString);
_tolerance = 1.0E-5d;
_settingsObj = new CapletBootstrapSettings
(_calculationDate,
_capFrequency,
_capStartLag,
_currency,
_handle,
_parVolatilityInterpolation,
_rollConvention,
ValidateArguments);
// Initialise the offsets.
_offsets = new List <double>();
foreach (DateTime date in _dates)
{
TimeSpan dateDiff = date - _calculationDate;
_offsets.Add(dateDiff.Days);
}
}
/// <summary>
/// Rolls the specified date using the underlying calendars.
/// </summary>
/// <param name="businessCalendar">The calendars.</param>
/// <param name="date">The date.</param>
/// <param name="businessDayConvention">The business day convention.</param>
/// <returns></returns>
public static DateTime Roll(IBusinessCalendar businessCalendar, DateTime date, string businessDayConvention)
{
BusinessDayConventionEnum dayConvention = BusinessDayConventionHelper.Parse(businessDayConvention);
return(businessCalendar.Roll(date, dayConvention));
}
public FinalCalculationPeriodDateAdjustment(XmlNode xmlNode)
{
XmlNodeList relevantUnderlyingDateReferenceNodeList = xmlNode.SelectNodes("relevantUnderlyingDateReference");
if (relevantUnderlyingDateReferenceNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in relevantUnderlyingDateReferenceNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
relevantUnderlyingDateReferenceIDRef = item.Attributes["id"].Name;
RelevantUnderlyingDateReference ob = RelevantUnderlyingDateReference();
IDManager.SetID(relevantUnderlyingDateReferenceIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
relevantUnderlyingDateReferenceIDRef = item.Attributes["href"].Name;
}
else
{
relevantUnderlyingDateReference = new RelevantUnderlyingDateReference(item);
}
}
}
XmlNodeList swapStreamReferenceNodeList = xmlNode.SelectNodes("swapStreamReference");
if (swapStreamReferenceNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in swapStreamReferenceNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
swapStreamReferenceIDRef = item.Attributes["id"].Name;
InterestRateStreamReference ob = InterestRateStreamReference();
IDManager.SetID(swapStreamReferenceIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
swapStreamReferenceIDRef = item.Attributes["href"].Name;
}
else
{
swapStreamReference = new InterestRateStreamReference(item);
}
}
}
XmlNodeList businessDayConventionNodeList = xmlNode.SelectNodes("businessDayConvention");
if (businessDayConventionNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in businessDayConventionNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
businessDayConventionIDRef = item.Attributes["id"].Name;
BusinessDayConventionEnum ob = BusinessDayConventionEnum();
IDManager.SetID(businessDayConventionIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
businessDayConventionIDRef = item.Attributes["href"].Name;
}
else
{
businessDayConvention = new BusinessDayConventionEnum(item);
}
}
}
}
/// <summary>
/// Adjusted dates from effective date.
/// </summary>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="terminationDate">The termination date.</param>
/// <param name="periodInterval">The period interval.</param>
/// <param name="rollConvention">The roll convention.</param>
/// <param name="businessCalender">The business calender.</param>
/// <param name="dateAdjustmentConvention">The date adjustment convention.</param>
/// <returns></returns>
public static DateTime[] AdjustedDatesFromEffectiveDate(DateTime effectiveDate, DateTime terminationDate, string periodInterval,
string rollConvention, IBusinessCalendar businessCalender, BusinessDayConventionEnum dateAdjustmentConvention)
{
DateTime[] dateSchedule = DateScheduler.GetUnadjustedDatesFromEffectiveDate(effectiveDate, terminationDate, PeriodHelper.Parse(periodInterval), RollConventionEnumHelper.Parse(rollConvention), out _, out _);
List <DateTime> adjustedDateSchedule = GetAdjustedDateSchedule(dateSchedule, dateAdjustmentConvention, businessCalender);
return(adjustedDateSchedule.ToArray());
}
/// <summary>
/// Gets the adjusted date schedule.
/// </summary>
/// <param name="unadjustedPeriodDates">The unadjusted Dates.</param>
/// <param name="businessDayConvention">The business day convention.</param>
/// <param name="paymentCalendar">The payment Calendar.</param>
/// <returns></returns>
public static List <DateTime> GetAdjustedDateSchedule(IEnumerable <DateTime> unadjustedPeriodDates, BusinessDayConventionEnum businessDayConvention, IBusinessCalendar paymentCalendar)
{
IEnumerable <DateTime> adjustedPeriodDates
= unadjustedPeriodDates.Select(a => paymentCalendar.Roll(a, businessDayConvention));
return(adjustedPeriodDates.ToList());
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableCapFloorCoupon"/> class.
/// </summary>
/// <param name="cashFlowId">The stream id.</param>
/// <param name="buyerIsBase">The buyer is base flag.</param>
/// <param name="capStrike">The Cap strike.</param>
/// <param name="floorStrike">The floor strike.</param>
/// <param name="accrualStartDate">The accrual start date. If adjusted, the adjustCalculationDatesIndicator should be false.</param>
/// <param name="accrualEndDate">The accrual end date. If adjusted, the adjustCalculationDatesIndicator should be false.</param>
/// <param name="adjustAccrualDatesIndicator">if set to <c>true</c> [adjust calculation dates indicator].</param>
/// <param name="accrualBusinessCenters">The accrual business centers.</param>
/// <param name="margin">The margin.</param>
/// <param name="observedRate">The observed Rate.</param>
/// <param name="notionalAmount">The notional amount.</param>
/// <param name="dayCountFraction">Type of day Count fraction.</param>
/// <param name="paymentDate">The payment date.</param>
/// <param name="accrualRollConvention">The accrual roll convention.</param>
/// <param name="resetRelativeTo">reset relative to?</param>
/// <param name="fixingDateRelativeOffset">The fixing date offset.</param>
/// <param name="forecastRateIndex">The forecast rate index.</param>
/// <param name="discountingType">The swap discounting type.</param>
/// <param name="discountRate">The discount rate.</param>
/// <param name="fraDiscounting">Determines whether the coupon is discounted or not. If this parameter is null,
/// then it is assumed that there is no fra discounting</param>
/// <param name="fixingCalendar">The fixingCalendar.</param>
/// <param name="paymentCalendar">The paymentCalendar.</param>
public PriceableCapFloorCoupon
(
string cashFlowId
, bool buyerIsBase
, decimal?capStrike
, decimal?floorStrike
, DateTime accrualStartDate
, DateTime accrualEndDate
, Boolean adjustAccrualDatesIndicator
, BusinessCenters accrualBusinessCenters
, BusinessDayConventionEnum accrualRollConvention
, DayCountFraction dayCountFraction
, ResetRelativeToEnum resetRelativeTo
, RelativeDateOffset fixingDateRelativeOffset
, Decimal margin
, Decimal?observedRate
, Money notionalAmount
, AdjustableOrAdjustedDate paymentDate
, ForecastRateIndex forecastRateIndex
, DiscountingTypeEnum?discountingType
, Decimal?discountRate
, FraDiscountingEnum?fraDiscounting
, IBusinessCalendar fixingCalendar
, IBusinessCalendar paymentCalendar)
: base(
cashFlowId
, buyerIsBase
, accrualStartDate
, accrualEndDate
, adjustAccrualDatesIndicator
, accrualBusinessCenters
, accrualRollConvention
, dayCountFraction
, resetRelativeTo
, fixingDateRelativeOffset
, margin
, observedRate
, notionalAmount
, paymentDate
, forecastRateIndex
, discountingType
, discountRate
, fraDiscounting
, fixingCalendar
, paymentCalendar)
{
CapStrike = capStrike;
FloorStrike = floorStrike;
VolatilitySurfaceName = CurveNameHelpers.GetRateVolatilityMatrixName(forecastRateIndex);
if (capStrike != null && floorStrike == null)
{
PriceableCouponType = CouponType.Cap;
ModelIdentifier = "DualCurveCapModel";
IsCall = true;
}
if (floorStrike != null && capStrike == null)
{
PriceableCouponType = CouponType.Floor;
ModelIdentifier = "DualCurveFloorModel";
}
if (floorStrike != null && capStrike != null)
{
PriceableCouponType = CouponType.Collar;
ModelIdentifier = "DualCurveCollarModel";
}
}
/// <summary>
/// Advances the given date the given offset.
/// </summary>
/// <param name="date">The <see cref="DateTime"/> that is to be advanced.</param>
/// <param name="offset">The <see cref="Offset"/> that the given date is advanced.</param>
/// <param name="businessDayConvention">The <see cref="BusinessDayConventionEnum"/> to use.</param>
/// <returns>Returns the resulting <see cref="DateTime"/>.</returns>
public DateTime Advance(DateTime date, Offset offset, BusinessDayConventionEnum businessDayConvention)
{
return(Advance(date, int.Parse(offset.periodMultiplier), offset.period, offset.dayType, businessDayConvention));
}
public StockIndex(XmlNode xmlNode)
{
XmlNodeList codeNodeList = xmlNode.SelectNodes("code");
if (codeNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in codeNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
codeIDRef = item.Attributes["id"].Name;
XsdTypeToken ob = XsdTypeToken();
IDManager.SetID(codeIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
codeIDRef = item.Attributes["href"].Name;
}
else
{
code = new XsdTypeToken(item);
}
}
}
XmlNodeList nameNodeList = xmlNode.SelectNodes("name");
if (nameNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in nameNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
nameIDRef = item.Attributes["id"].Name;
XsdTypeToken ob = XsdTypeToken();
IDManager.SetID(nameIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
nameIDRef = item.Attributes["href"].Name;
}
else
{
name = new XsdTypeToken(item);
}
}
}
XmlNodeList indexTypeNodeList = xmlNode.SelectNodes("indexType");
if (indexTypeNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in indexTypeNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
indexTypeIDRef = item.Attributes["id"].Name;
XsdTypeToken ob = XsdTypeToken();
IDManager.SetID(indexTypeIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
indexTypeIDRef = item.Attributes["href"].Name;
}
else
{
indexType = new XsdTypeToken(item);
}
}
}
XmlNodeList businessDayConventionNodeList = xmlNode.SelectNodes("businessDayConvention");
if (businessDayConventionNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in businessDayConventionNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
businessDayConventionIDRef = item.Attributes["id"].Name;
BusinessDayConventionEnum ob = BusinessDayConventionEnum();
IDManager.SetID(businessDayConventionIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
businessDayConventionIDRef = item.Attributes["href"].Name;
}
else
{
businessDayConvention = new BusinessDayConventionEnum(item);
}
}
}
XmlNodeList endOfMonthNodeList = xmlNode.SelectNodes("endOfMonth");
if (endOfMonthNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in endOfMonthNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
endOfMonthIDRef = item.Attributes["id"].Name;
XsdTypeBoolean ob = XsdTypeBoolean();
IDManager.SetID(endOfMonthIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
endOfMonthIDRef = item.Attributes["href"].Name;
}
else
{
endOfMonth = new XsdTypeBoolean(item);
}
}
}
XmlNodeList dayCounterNodeList = xmlNode.SelectNodes("dayCounter");
if (dayCounterNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in dayCounterNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
dayCounterIDRef = item.Attributes["id"].Name;
XsdTypeToken ob = XsdTypeToken();
IDManager.SetID(dayCounterIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
dayCounterIDRef = item.Attributes["href"].Name;
}
else
{
dayCounter = new XsdTypeToken(item);
}
}
}
}
/// <summary>
/// Advances the given <see cref="DateTime"/> the given
/// <paramref name="periodMultiplier"/> of time <paramref name="period"/>.
/// </summary>
/// <param name="date">The <see cref="DateTime"/> that is to be advanced.</param>
/// <param name="periodMultiplier">The number of time period to advance.</param>
/// <param name="period">The <see cref="PeriodEnum"/> used.</param>
/// <param name="dayType">Type of the day.</param>
/// <param name="businessDayConvention">The business day convention.</param>
/// <returns>
/// Returns the resulting <see cref="DateTime"/>.
/// </returns>
/// <overloads>
/// Advances the given <see cref="DateTime"/>.
/// </overloads>
private DateTime Advance(DateTime date, int periodMultiplier, PeriodEnum period, DayTypeEnum dayType, BusinessDayConventionEnum businessDayConvention)
{
#region Assert validity of parameters
if ((dayType != DayTypeEnum.Business) & (dayType != DayTypeEnum.Calendar))
{
throw new ArgumentOutOfRangeException(nameof(dayType), dayType, "Only 'DayTypeEnum.Business' and 'DayTypeEnum.Calendar' day types are currently supported.");
}
// We can only use Business dayType for days intervals.
//
if ((dayType == DayTypeEnum.Business) & (period != PeriodEnum.D))
{
throw new NotSupportedException();
}
#endregion
// handling the NONE day convention
if (businessDayConvention == BusinessDayConventionEnum.NONE)
{
// No rolling if multiplier is zero
if (periodMultiplier == 0)
{
return(date);
}
BusinessDayConventionEnum advConvention = periodMultiplier > 0? BusinessDayConventionEnum.FOLLOWING: BusinessDayConventionEnum.PRECEDING;
return(Advance(date, periodMultiplier, period, dayType, advConvention));
}
if (periodMultiplier == 0)
{
return(Roll(date, businessDayConvention));
}
if ((period == PeriodEnum.D) & DayTypeEnum.Business == dayType) //Business days
{
DateTime returnValue = date;
if (periodMultiplier > 0)
{
while (periodMultiplier > 0)
{
returnValue = returnValue.AddDays(1);
while (IsHoliday(returnValue))
{
returnValue = returnValue.AddDays(1);
}
periodMultiplier--;
}
}
else
{
while (periodMultiplier < 0)
{
returnValue = returnValue.AddDays(-1);
while (IsHoliday(returnValue))
{
returnValue = returnValue.AddDays(-1);
}
periodMultiplier++;
}
}
return(returnValue);
}
var interval = new Period {
period = period, periodMultiplier = periodMultiplier.ToString(CultureInfo.InvariantCulture)
};
return(Roll(Add(date, interval), businessDayConvention));
}
public FxFixingDate(XmlNode xmlNode)
: base(xmlNode)
{
XmlNodeList businessDayConventionNodeList = xmlNode.SelectNodes("businessDayConvention");
if (businessDayConventionNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in businessDayConventionNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
businessDayConventionIDRef = item.Attributes["id"].Name;
BusinessDayConventionEnum ob = BusinessDayConventionEnum();
IDManager.SetID(businessDayConventionIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
businessDayConventionIDRef = item.Attributes["href"].Name;
}
else
{
businessDayConvention = new BusinessDayConventionEnum(item);
}
}
}
XmlNodeList businessCentersReferenceNodeList = xmlNode.SelectNodes("businessCentersReference");
if (businessCentersReferenceNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in businessCentersReferenceNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
businessCentersReferenceIDRef = item.Attributes["id"].Name;
BusinessCentersReference ob = BusinessCentersReference();
IDManager.SetID(businessCentersReferenceIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
businessCentersReferenceIDRef = item.Attributes["href"].Name;
}
else
{
businessCentersReference = new BusinessCentersReference(item);
}
}
}
XmlNodeList businessCentersNodeList = xmlNode.SelectNodes("businessCenters");
if (businessCentersNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in businessCentersNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
businessCentersIDRef = item.Attributes["id"].Name;
BusinessCenters ob = BusinessCenters();
IDManager.SetID(businessCentersIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
businessCentersIDRef = item.Attributes["href"].Name;
}
else
{
businessCenters = new BusinessCenters(item);
}
}
}
XmlNodeList dateRelativeToPaymentDatesNodeList = xmlNode.SelectNodes("dateRelativeToPaymentDates");
if (dateRelativeToPaymentDatesNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in dateRelativeToPaymentDatesNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
dateRelativeToPaymentDatesIDRef = item.Attributes["id"].Name;
DateRelativeToPaymentDates ob = DateRelativeToPaymentDates();
IDManager.SetID(dateRelativeToPaymentDatesIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
dateRelativeToPaymentDatesIDRef = item.Attributes["href"].Name;
}
else
{
dateRelativeToPaymentDates = new DateRelativeToPaymentDates(item);
}
}
}
XmlNodeList dateRelativeToCalculationPeriodDatesNodeList = xmlNode.SelectNodes("dateRelativeToCalculationPeriodDates");
if (dateRelativeToCalculationPeriodDatesNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in dateRelativeToCalculationPeriodDatesNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
dateRelativeToCalculationPeriodDatesIDRef = item.Attributes["id"].Name;
DateRelativeToCalculationPeriodDates ob = DateRelativeToCalculationPeriodDates();
IDManager.SetID(dateRelativeToCalculationPeriodDatesIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
dateRelativeToCalculationPeriodDatesIDRef = item.Attributes["href"].Name;
}
else
{
dateRelativeToCalculationPeriodDates = new DateRelativeToCalculationPeriodDates(item);
}
}
}
}
/// <summary>
/// Gets the forward spot date.
/// </summary>
/// <returns></returns>
protected DateTime GetForwardDate(DateTime spotDate, IBusinessCalendar paymentCalendar, Period tenor, BusinessDayConventionEnum businessDayConvention)
{
return(paymentCalendar.Advance(spotDate, OffsetHelper.FromInterval(tenor, DayTypeEnum.Calendar), businessDayConvention));
}
public RelativeDateOffset(XmlNode xmlNode)
: base(xmlNode)
{
XmlNodeList businessDayConventionNodeList = xmlNode.SelectNodes("businessDayConvention");
if (businessDayConventionNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in businessDayConventionNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
businessDayConventionIDRef = item.Attributes["id"].Name;
BusinessDayConventionEnum ob = BusinessDayConventionEnum();
IDManager.SetID(businessDayConventionIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
businessDayConventionIDRef = item.Attributes["href"].Name;
}
else
{
businessDayConvention = new BusinessDayConventionEnum(item);
}
}
}
XmlNodeList businessCentersReferenceNodeList = xmlNode.SelectNodes("businessCentersReference");
if (businessCentersReferenceNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in businessCentersReferenceNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
businessCentersReferenceIDRef = item.Attributes["id"].Name;
BusinessCentersReference ob = BusinessCentersReference();
IDManager.SetID(businessCentersReferenceIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
businessCentersReferenceIDRef = item.Attributes["href"].Name;
}
else
{
businessCentersReference = new BusinessCentersReference(item);
}
}
}
XmlNodeList businessCentersNodeList = xmlNode.SelectNodes("businessCenters");
if (businessCentersNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in businessCentersNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
businessCentersIDRef = item.Attributes["id"].Name;
BusinessCenters ob = BusinessCenters();
IDManager.SetID(businessCentersIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
businessCentersIDRef = item.Attributes["href"].Name;
}
else
{
businessCenters = new BusinessCenters(item);
}
}
}
XmlNodeList dateRelativeToNodeList = xmlNode.SelectNodes("dateRelativeTo");
if (dateRelativeToNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in dateRelativeToNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
dateRelativeToIDRef = item.Attributes["id"].Name;
DateReference ob = DateReference();
IDManager.SetID(dateRelativeToIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
dateRelativeToIDRef = item.Attributes["href"].Name;
}
else
{
dateRelativeTo = new DateReference(item);
}
}
}
XmlNodeList adjustedDateNodeList = xmlNode.SelectNodes("adjustedDate");
if (adjustedDateNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in adjustedDateNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
adjustedDateIDRef = item.Attributes["id"].Name;
IdentifiedDate ob = IdentifiedDate();
IDManager.SetID(adjustedDateIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
adjustedDateIDRef = item.Attributes["href"].Name;
}
else
{
adjustedDate = new IdentifiedDate(item);
}
}
}
}
/// <summary>
/// Converts to an adjustable date type.
/// </summary>
/// <param name="unadjustedDate"></param>
/// <param name="businessDayConvention"></param>
/// <param name="businessCentersAsString"></param>
/// <returns></returns>
public static AdjustableOrAdjustedDate ToAdjustableOrAdjustedDate(DateTime unadjustedDate, BusinessDayConventionEnum businessDayConvention, string businessCentersAsString)
{
var result = AdjustableOrAdjustedDateHelper.CreateUnadjustedDate(unadjustedDate, businessDayConvention.ToString(), businessCentersAsString);
return(result);
}
public BusinessDayAdjustments(XmlNode xmlNode)
{
XmlNodeList businessDayConventionNodeList = xmlNode.SelectNodes("businessDayConvention");
if (businessDayConventionNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in businessDayConventionNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
businessDayConventionIDRef = item.Attributes["id"].Name;
BusinessDayConventionEnum ob = BusinessDayConventionEnum();
IDManager.SetID(businessDayConventionIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
businessDayConventionIDRef = item.Attributes["href"].Name;
}
else
{
businessDayConvention = new BusinessDayConventionEnum(item);
}
}
}
XmlNodeList businessCentersReferenceNodeList = xmlNode.SelectNodes("businessCentersReference");
if (businessCentersReferenceNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in businessCentersReferenceNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
businessCentersReferenceIDRef = item.Attributes["id"].Name;
BusinessCentersReference ob = BusinessCentersReference();
IDManager.SetID(businessCentersReferenceIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
businessCentersReferenceIDRef = item.Attributes["href"].Name;
}
else
{
businessCentersReference = new BusinessCentersReference(item);
}
}
}
XmlNodeList businessCentersNodeList = xmlNode.SelectNodes("businessCenters");
if (businessCentersNodeList.Count > 1 )
{
throw new Exception();
}
foreach (XmlNode item in businessCentersNodeList)
{
if (item.Attributes["href"] != null || item.Attributes["id"] == null)
{
if (item.Attributes["id"] != null)
{
businessCentersIDRef = item.Attributes["id"].Name;
BusinessCenters ob = BusinessCenters();
IDManager.SetID(businessCentersIDRef, ob);
}
else if (item.Attributes.ToString() == "href")
{
businessCentersIDRef = item.Attributes["href"].Name;
}
else
{
businessCenters = new BusinessCenters(item);
}
}
}
}