public void ReplacePartiesInValuationReport(ICoreCache cache, string nameSpace, string valuationId, List <Party> partyList)
{
if (cache.LoadItem <ValuationReport>(nameSpace + "." + valuationId).Data is ValuationReport valuationReport)
{
valuationReport.party = partyList.ToArray();
}
}
public string SaveToFile(ICoreCache cache, string nameSpace, string valuationId, string filename)
{
var valuationReport = cache.LoadItem <ValuationReport>(nameSpace + "." + valuationId).Data as ValuationReport;
string actualFilename = AppendValuationIdToFilename(filename, valuationId);
XmlSerializerHelper.SerializeToFile(typeof(Document), valuationReport, actualFilename);
return($"FpML document '{valuationId}' successfully saved to '{actualFilename}'");
}
/// <summary>
/// Initializes a new instance of the <see cref="SecuredRateCurve"/> class.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="cache">The cache.</param>
/// <param name="nameSpace">The client namespace</param>
/// <param name="fpmlData">The FPML data.</param>
/// <param name="properties">The properties.</param>
/// <param name="fixingCalendar">The fixingCalendar.</param>
/// <param name="rollCalendar">The rollCalendar.</param>
public SecuredRateCurve(ILogger logger, ICoreCache cache, string nameSpace,
Pair <PricingStructure, PricingStructureValuation> fpmlData,
NamedValueSet properties, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar)
: base(logger, cache, nameSpace, fpmlData, properties, fixingCalendar, rollCalendar)
{
var refId = properties.GetValue <String>(BondProp.ReferenceBond, true);
var refItem = cache.LoadItem <Bond>(nameSpace + '.' + "ReferenceData.FixedIncome." + refId);
var refAsset = refItem.Data as Bond;
UnderlyingAsset = refAsset;
}
private static Instrument GetFxInstrumentConfigurationData(ICoreCache cache, string nameSpace, string[] parts)
{
string currency1 = parts[0].Substring(0, 3);
string currency2 = parts[0].Substring(3, 3);
if (currency1 == "USD")
{
currency1 = currency2;
currency2 = "USD";
}
string uniqueName;
bool isCross = currency2 != "USD";
ICoreItem loadedItem = null;
if (parts.Length > 2)
{
uniqueName = CreateKey(nameSpace, parts[1], currency1 + currency2, parts[2]);
loadedItem = cache.LoadItem <Instrument>(uniqueName);
if (loadedItem == null && isCross) // try again the other way round
{
uniqueName = CreateKey(nameSpace, parts[1], currency2 + currency1, parts[2]);
loadedItem = cache.LoadItem <Instrument>(uniqueName);
}
}
if (loadedItem == null)
{
uniqueName = CreateKey(nameSpace, parts[1], currency1 + currency2);
loadedItem = cache.LoadItem <Instrument>(uniqueName);
if (loadedItem == null && isCross) // try again the other way round
{
uniqueName = CreateKey(nameSpace, parts[1], currency2 + currency1);
loadedItem = cache.LoadItem <Instrument>(uniqueName);
//throw MissingKey(uniqueName);
}
}
var instrument = loadedItem?.Data as Instrument;
return(instrument);
}
public void TestSaveLoadPrivateCacheItems()
{
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router))
{
server.Start();
using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
using (ICoreCache cacheA = client.CreateCache())
{
Guid id = cacheA.SavePrivateObject("data", "name1", null);
//ICoreItem item = cacheA.LoadPrivateItem<string>("name1");
ICoreItem item = cacheA.LoadItem <string>("name1");
string data = (string)item.Data;
Assert.AreEqual <string>("data", data);
}
}
}
protected ICoreItem LoadAndCheckMarketItem(ICoreCache cache, string nameSpace, string curveUniqueId)//TODO use the proper loader.
{
ICoreItem marketItem = cache.LoadItem <Market>(nameSpace + "." + curveUniqueId);
if (marketItem == null)
{
throw new ApplicationException("Curve '" + curveUniqueId + "' not found!");
}
var market = (Market)marketItem.Data;
if ((market.Items == null) || (market.Items.Length < 1) || (market.Items[0] == null))
{
throw new ApplicationException("Curve '" + curveUniqueId + "' contains no PricingStructure!");
}
if ((market.Items1 == null) || (market.Items1.Length < 1) || (market.Items1[0] == null))
{
throw new ApplicationException("Curve '" + curveUniqueId + "' contains no PricingStructureValuation!");
}
return(marketItem);
}
/// <summary>
/// Tries to get the algorithm.
/// </summary>
/// <param name="nameSpace"></param>
/// <param name="pricingStructureType"></param>
/// <param name="algorithmName"></param>
/// <param name="logger"></param>
/// <param name="cache">The value</param>
/// <returns>Whether the property existed or not</returns>
public Algorithm GetAlgorithm(ILogger logger, ICoreCache cache, string nameSpace, PricingStructureTypeEnum pricingStructureType, string algorithmName)
{
Algorithm algorithm = null;
if (cache != null)
{
try
{
var uniqueName = nameSpace + "." + AlgorithmsProp.GenericName + "." + pricingStructureType + "." +
algorithmName;
var item = cache.LoadItem <Algorithm>(uniqueName);
algorithm = (Algorithm)item?.Data;
}
catch (Exception ex)
{
logger.Log(ex);
}
}
return(algorithm);
}
public List <ValuationInfoRangeItem> GetInfo(ICoreCache cache, string nameSpace, string valuationId)
{
var list = new List <ValuationInfoRangeItem>();
var item = cache.LoadItem <ValuationReport>(nameSpace + "." + valuationId);
if (item != null)
{
var valuationReport = (ValuationReport)item.Data;
var envelope = new ValuationInfoRangeItem
{
Id = valuationReport.header.messageId.Value,
Description = "envelope"
};
list.Add(envelope);
foreach (TradeValuationItem tradeValuationItem in valuationReport.tradeValuationItem)
{
foreach (Trade trade in tradeValuationItem.Items)
{
if (trade.tradeHeader.partyTradeIdentifier[0].Items[0] is TradeId tradeId)
{
var product = new ValuationInfoRangeItem
{
Id = tradeId.Value
};
if (trade.Item is Swap swap1)
{
product.Description = "swap";
var swap = swap1;
string leg1Type = GetInterestRateStreamType(swap.swapStream[0]);
string leg2Type = GetInterestRateStreamType(swap.swapStream[1]);
product.Description += $"({leg1Type}/{leg2Type})";
}
else if (trade.Item is Swaption)
{
product.Description = "swaption";
}
else
{
if (trade.Item is CapFloor floor)//could be cap, floor, or collar
{
var capFloor = floor;
Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(
capFloor.capFloorStream.calculationPeriodAmount);
FloatingRateCalculation floatingRateCalculation = XsdClassesFieldResolver.CalculationGetFloatingRateCalculation(calculation);
if (null != floatingRateCalculation.capRateSchedule & null != floatingRateCalculation.floorRateSchedule)
{
product.Description = "collar";
}
else if (null != floatingRateCalculation.capRateSchedule)
{
product.Description = "cap";
}
else
{
product.Description = null != floatingRateCalculation.floorRateSchedule ? "floor" : "unknown product";
}
}
else
{
product.Description = "unknown product";
}
}
list.Add(product);
}
}
}
}
return(list);
}
public ValuationReport Get(ICoreCache cache, string nameSpace, string valuationId)
{
var valuationReport = cache.LoadItem <ValuationReport>(nameSpace + "." + valuationId).Data as ValuationReport;
return(valuationReport);
}
public string Merge(ICoreCache cache, string nameSpace, string valuationId1, string valuationId2,
string valuationId3, string valuationId4, string valuationId5, string valuationId6,
string valuationId7, string valuationId8, string valuationId9, string valuationId10)
{
var valuationIds = new List <string>();
if (!String.IsNullOrEmpty(valuationId1))
{
valuationIds.Add(valuationId1);
}
if (!String.IsNullOrEmpty(valuationId2))
{
valuationIds.Add(valuationId2);
}
if (!String.IsNullOrEmpty(valuationId3))
{
valuationIds.Add(valuationId3);
}
if (!String.IsNullOrEmpty(valuationId4))
{
valuationIds.Add(valuationId4);
}
if (!String.IsNullOrEmpty(valuationId5))
{
valuationIds.Add(valuationId5);
}
if (!String.IsNullOrEmpty(valuationId6))
{
valuationIds.Add(valuationId6);
}
if (!String.IsNullOrEmpty(valuationId7))
{
valuationIds.Add(valuationId7);
}
if (!String.IsNullOrEmpty(valuationId8))
{
valuationIds.Add(valuationId8);
}
if (!String.IsNullOrEmpty(valuationId9))
{
valuationIds.Add(valuationId9);
}
if (!String.IsNullOrEmpty(valuationId10))
{
valuationIds.Add(valuationId10);
}
var item = cache.LoadItem <ValuationReport>(nameSpace + "." + valuationIds[0]);
var result = (ValuationReport)item.Data;
valuationIds.RemoveAt(0);
if (0 == valuationIds.Count)
{
string resultValuationIdOnlyOne = result.header.messageId.Value;
return(resultValuationIdOnlyOne);
}
result = valuationIds.Select(valuationId => cache.LoadItem <ValuationReport>(nameSpace + "." + valuationId).Data as ValuationReport).Aggregate(result, ValuationReportGenerator.Merge);
string resultValuationId = result.header.messageId.Value;
cache.SaveObject(result, nameSpace + "." + resultValuationId, null);//TODO add properties here.
return(resultValuationId);
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="cache"></param>
/// <param name="nameSpace"></param>
/// <param name="tradeDate"></param>
/// <param name="effectiveDate"></param>
/// <param name="referenceEquity"></param>
/// <param name="settlementCalendar"></param>
/// <param name="equityFpML"></param>
/// <param name="basePartyReference"></param>
/// <param name="forecastRateInterpolation"></param>
public EquityTransactionPricer(ILogger logger, ICoreCache cache, string nameSpace, DateTime tradeDate, DateTime effectiveDate,
String referenceEquity, IBusinessCalendar settlementCalendar, EquityTransaction equityFpML, string basePartyReference, Boolean forecastRateInterpolation)
{
logger.LogInfo("EquityType set. Commence to build a equity transaction.");
if (equityFpML == null)
{
return;
}
SettlementDate = effectiveDate;
TradeDate = tradeDate;
Multiplier = 1.0m;
BuyerReference = equityFpML.buyerPartyReference.href;
PaymentCurrencies = new List <string> {
equityFpML.unitPrice.currency.Value
};
SellerReference = equityFpML.sellerPartyReference.href;
BasePartyBuyer = basePartyReference == equityFpML.buyerPartyReference.href;
ForecastRateInterpolation = forecastRateInterpolation;
SettlementCalendar = settlementCalendar;
ReferenceEquity = referenceEquity;
NumberOfShares = Convert.ToInt16(equityFpML.numberOfUnits);
PurchasePrice = MoneyHelper.GetAmount(equityFpML.unitPrice.amount, equityFpML.unitPrice.currency.Value);
PaymentCurrencies = new List <string> {
equityFpML.unitPrice.currency.Value
};
var exchangeMIC = equityFpML.equity.exchangeId;
var exchangeMICData = InstrumentDataHelper.CreateEquityExchangeKey(nameSpace, exchangeMIC.Value);
var exchangeData = cache.LoadItem <ExchangeConfigData>(exchangeMICData);
if (exchangeData?.Data is ExchangeConfigData)
{
var exchange = (ExchangeConfigData)exchangeData.Data;
var equityTypeInfo = new EquityNodeStruct {
SettlementDate = exchange.SettlementDate
};
if (equityFpML.equity != null)
{
if (SettlementCalendar == null)
{
SettlementCalendar = BusinessCenterHelper.ToBusinessCalendar(cache,
equityTypeInfo.SettlementDate
.businessCenters,
nameSpace);
}
if (PaymentCalendar == null)
{
PaymentCalendar = SettlementCalendar;
}
var equity = XmlSerializerHelper.Clone(equityFpML.equity);
EquityTypeInfo = XmlSerializerHelper.Clone(equityTypeInfo);
EquityTypeInfo.Equity = equity;;
RiskMaturityDate = SettlementDate;
MaturityDate = SettlementDate;
if (!PaymentCurrencies.Contains(equityFpML.equity.currency.Value))
{
PaymentCurrencies.Add(equityFpML.equity.currency.Value);
}
logger.LogInfo("Equity transaction has been successfully created.");
}
}
else
{
logger.LogInfo("Equity type data not available.");
}
//Add payments like the settlement price
if (PurchasePrice == null || !PurchasePrice.amountSpecified)
{
return;
}
var amount = PurchasePrice.amount * NumberOfShares;
var settlementPayment = PaymentHelper.Create("EquitySettlemetAmount", BuyerReference, SellerReference, amount, SettlementDate);
AdditionalPayments = PriceableInstrumentsFactory.CreatePriceablePayments(basePartyReference, new[] { settlementPayment }, PaymentCalendar);
if (!PaymentCurrencies.Contains(settlementPayment.paymentAmount.currency.Value))
{
PaymentCurrencies.Add(settlementPayment.paymentAmount.currency.Value);
}
}
public FutureTransactionPricer(ILogger logger, ICoreCache cache, string nameSpace, DateTime tradeDate, ExchangeContractTypeEnum futuresType,
IBusinessCalendar settlementCalendar, FutureTransaction futureFpML, string basePartyReference, Boolean forecastRateInterpolation)
{
logger.LogInfo("FuturesType set. Commence to build a future transaction.");
if (futureFpML == null)
{
return;
}
Multiplier = 1.0m;
BuyerReference = futureFpML.buyerPartyReference.href;
PaymentCurrencies = new List <string> {
futureFpML.unitPrice.currency.Value
};
SellerReference = futureFpML.sellerPartyReference.href;
BasePartyBuyer = basePartyReference == futureFpML.buyerPartyReference.href;
if (!BasePartyBuyer)
{
Multiplier = -1.0m;
}
ForecastRateInterpolation = forecastRateInterpolation;
SettlementCalendar = settlementCalendar;
FuturesType = futuresType;
ReferenceContract = futureFpML.future.id;
var futuresCode = ReferenceContract.Split('-')[2];
NumberOfContracts = Convert.ToInt16(futureFpML.numberOfUnits);
PurchasePrice = MoneyHelper.GetAmount(futureFpML.unitPrice.amount, futureFpML.unitPrice.currency.Value);
var exchangeMIC = futureFpML.future.exchangeId;
FuturesCurveName = CurveNameHelpers.GetExchangeTradedCurveName(futureFpML.unitPrice.currency.Value, exchangeMIC.Value, futuresCode);
DiscountCurveName = CurveNameHelpers.GetDiscountCurveName(futureFpML.unitPrice.currency, true);
FuturesTypeInfo = new FutureNodeStruct();
var exchangeMICData = InstrumentDataHelper.CreateEquityExchangeKey(nameSpace, exchangeMIC.Value);
var exchangeData = cache.LoadItem <ExchangeConfigData>(exchangeMICData);
if (exchangeData?.Data is ExchangeConfigData)
{
Exchange = (ExchangeConfigData)exchangeData.Data;
FuturesTypeInfo.SpotDate = Exchange.SettlementDate;
}
if (futureFpML.future != null)
{
if (SettlementCalendar == null)
{
SettlementCalendar = BusinessCenterHelper.ToBusinessCalendar(cache,
FuturesTypeInfo.SpotDate
.businessCenters,
nameSpace);
}
var future = XmlSerializerHelper.Clone(futureFpML.future);
FuturesTypeInfo.Future = future;
if (FuturesTypeInfo.SpotDate != null)
{
SettlementDate = GetSettlementDate(tradeDate, SettlementCalendar,
FuturesTypeInfo.SpotDate);
}
//Instantiate the priceable future.
NamedValueSet namedValueSet = PriceableAssetFactory.BuildPropertiesForAssets(nameSpace, FuturesTypeInfo.Future.id, tradeDate);
var asset = AssetHelper.Parse(FuturesTypeInfo.Future.id, 0.0m, 0.0m);
UnderlyingFuture = PriceableAssetFactory.Create(logger, cache, nameSpace, asset.Second, namedValueSet, null, null) as IPriceableFuturesAssetController;
if (UnderlyingFuture != null)
{
RiskMaturityDate = UnderlyingFuture.GetRiskMaturityDate();
MaturityDate = RiskMaturityDate;
LastTradeDate = UnderlyingFuture.LastTradeDate;
}
if (!PaymentCurrencies.Contains(futureFpML.future.currency.Value))
{
PaymentCurrencies.Add(futureFpML.future.currency.Value);
}
logger.LogInfo("Futures transaction has been successfully created.");
}
else
{
logger.LogInfo("Futures type data not available.");
}
//Add payments like the settlement price
if (!PurchasePrice.amountSpecified)
{
return;
}
var amount = PurchasePrice.amount * NumberOfContracts / 100;
var settlementPayment = PaymentHelper.Create("FuturesSettlemetAmount", BuyerReference, SellerReference, amount, SettlementDate);
AdditionalPayments = PriceableInstrumentsFactory.CreatePriceablePayments(basePartyReference, new[] { settlementPayment }, SettlementCalendar);
if (!PaymentCurrencies.Contains(settlementPayment.paymentAmount.currency.Value))
{
PaymentCurrencies.Add(settlementPayment.paymentAmount.currency.Value);
}
}
/// <summary>
/// Gets the instrument config data.
/// </summary>
/// <param name="cache">The cache.</param>
/// <param name="nameSpace">The client namespace</param>
/// <param name="parts">The AssetId or the parts of the AssetId.</param>
/// <returns></returns>
public static Instrument GetInstrumentConfigurationData(ICoreCache cache, string nameSpace, params string[] parts)
{
bool simplifiable = true;
if (parts.Length == 1)
{
parts = parts[0].Split('-');
}
string uniqueName;
var assetType = (AssetTypesEnum)Enum.Parse(typeof(AssetTypesEnum), parts[1], true);
var swapTypes = new[] { AssetTypesEnum.IRSwap, AssetTypesEnum.BasisSwap, AssetTypesEnum.XccyBasisSwap, AssetTypesEnum.XccySwap };
var fxTypes = new[] { AssetTypesEnum.FxSpot, AssetTypesEnum.FxForward };
var bondTypes = new[] { AssetTypesEnum.Bond };
var commodityTypes = new[] { AssetTypesEnum.CommoditySpread, AssetTypesEnum.CommodityForward };
var equityTypes = new[] { AssetTypesEnum.Equity, AssetTypesEnum.EquityForward, AssetTypesEnum.EquitySpread };
var irfuturesOptionTypes = new[] { AssetTypesEnum.IRFutureOption, AssetTypesEnum.IRCallFutureOption, AssetTypesEnum.IRPutFutureOption };
var otherTypes = new[] { AssetTypesEnum.BondForward, AssetTypesEnum.BondSpot };
ICoreItem loadedItem;
Instrument instrument;
string exchangeMIC = null;
if (swapTypes.Contains(assetType) && parts.Length > 3)
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0], parts[2], parts[3]);
}
else if (irfuturesOptionTypes.Contains(assetType) && parts.Length > 2)
{
uniqueName = CreateKey(nameSpace, AssetTypesEnum.IRFutureOption.ToString(), parts[0], parts[2]);
}
else if (commodityTypes.Contains(assetType) && parts.Length > 3)
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0], parts[2], parts[3]);
}
else if (fxTypes.Contains(assetType))
{
return(GetFxInstrumentConfigurationData(cache, nameSpace, parts));
}
else if (bondTypes.Contains(assetType) && parts[2].Split('.').Length > 4)
{
uniqueName = CreateBondKey(nameSpace, parts[2]);
var extraData = cache.LoadItem <Bond>(uniqueName);
var bondType = extraData.AppProps.GetValue <string>(BondProp.BondType, true);
uniqueName = CreateKey(nameSpace, parts[1], parts[0], bondType);
loadedItem = cache.LoadItem <Instrument>(uniqueName);
instrument = loadedItem.Data as Instrument;
if (instrument != null)
{
var newInstrument = XmlSerializerHelper.Clone(instrument);
((BondNodeStruct)newInstrument.InstrumentNodeItem).Bond = extraData.Data as Bond;
return(newInstrument);
}
}
else if (equityTypes.Contains(assetType))
{
var assetCode = parts[2].Split('.');
EquityAsset equityAsset = null;
if (assetCode.Length == 2)
{
uniqueName = CreateEquityAssetKey(nameSpace, parts[2]);
var equity = cache.LoadItem <EquityAsset>(uniqueName);
exchangeMIC = equity.AppProps.GetValue <string>(EquityProp.ExchangeMIC, true);
equityAsset = equity.Data as EquityAsset;
}
if (assetCode.Length == 1)
{
exchangeMIC = assetCode[0];
}
uniqueName = CreateEquityExchangeKey(nameSpace, exchangeMIC);
loadedItem = cache.LoadItem <ExchangeConfigData>(uniqueName);
if (assetType == AssetTypesEnum.Equity && loadedItem.Data is ExchangeConfigData exchange)
{
instrument = new Instrument();
var equityNode = new EquityNodeStruct
{
Equity = equityAsset,
Exchange = exchange.ExchangeData,
SettlementDate = exchange.SettlementDate
};
instrument.AssetType = parts[1];
instrument.InstrumentNodeItem = equityNode;
instrument.Currency = CurrencyHelper.Parse(parts[0]);
instrument.ExtraItem = equityNode.Exchange.MIC;
return(instrument);
}
if (parts.Length > 3)
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0], exchangeMIC, parts[3]);
}
else
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0], exchangeMIC);
simplifiable = false;
}
}
else if (otherTypes.Contains(assetType) && parts.Length > 3)
{
//This is to simplify the configuration data and no bond forward is required
uniqueName = CreateKey(nameSpace, parts[1], parts[0], parts[2], parts[3]);
}
//Default Area that sweeps all the standard keys structures.
else if (parts.Length > 2)
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0], parts[2]);
}
else
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0]);
simplifiable = false;
}
loadedItem = cache.LoadItem <Instrument>(uniqueName);
if (loadedItem == null && simplifiable)
{
if (swapTypes.Contains(assetType) && parts.Length > 3)
{
//This handles the special case of IRSwaps, where the underlying maturity should use the default.
uniqueName = CreateKey(nameSpace, parts[1], parts[0], "Default", parts[3]);
}
else if (commodityTypes.Contains(assetType) && parts.Length > 3)
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0], parts[2]);
}
else if (equityTypes.Contains(assetType) && parts.Length > 3)
{
//Orion.V5r3.Configuration.Instrument.EquityForward.AUD-EquityForward.AU.0D
uniqueName = CreateKey(nameSpace, parts[1], parts[0], exchangeMIC);
}
else if (otherTypes.Contains(assetType))
{
//This is to simplify the configuration data and no bond forward is required
uniqueName = CreateKey(nameSpace, AssetTypesEnum.Bond.ToString(), parts[0], parts[2]);
}
else
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0]);
}
loadedItem = cache.LoadItem <Instrument>(uniqueName);
}
instrument = loadedItem?.Data as Instrument;
return(instrument);
}
/// <summary>
/// Gets the curve.
/// </summary>
/// <param name="uniqueName">The uniqueName.</param>
/// <param name="forceBootstrap">The force a bootstrap flag.</param>
/// <returns></returns>
public IPricingStructure GetCurve(String uniqueName, Boolean forceBootstrap)
{
var item = Cache.LoadItem <Market>(NameSpace + "." + uniqueName);
if (item == null)
{
return(null);
}
var deserializedMarket = (Market)item.Data;
NamedValueSet properties = item.AppProps;
if (forceBootstrap)
{
properties.Set("Bootstrap", true);
}
//Handle ratebasiscurves that are dependent on another ratecurve.
//TODO This functionality needs to be extended for calibrations (bootstrapping),
//TODO where there is AccountReference dependency on one or more pricing structures.
var pst = PropertyHelper.ExtractPricingStructureType(properties);
if (pst == PricingStructureTypeEnum.RateBasisCurve)
{
//Get the referrence curve identifier.
var refCurveId = properties.GetValue <string>(CurveProp.ReferenceCurveUniqueId, true);
//Load the data.
var refItem = Cache.LoadItem <Market>(refCurveId);
var deserializedRefCurveMarket = (Market)refItem.Data;
var refCurveProperties = refItem.AppProps;
//Format the ref curve data and call the pricing structure helper.
var refCurveFpmlTriplet =
new Triplet <PricingStructure, PricingStructureValuation, NamedValueSet>(
deserializedRefCurveMarket.Items[0],
deserializedRefCurveMarket.Items1[0], refCurveProperties);
var spreadCurveFpmlTriplet =
new Triplet <PricingStructure, PricingStructureValuation, NamedValueSet>(deserializedMarket.Items[0],
deserializedMarket.Items1[0],
properties);
//create and set the pricingstructure
var psBasis = CurveEngine.Factory.PricingStructureFactory.Create(Logger.Target, Cache, NameSpace, null, null, refCurveFpmlTriplet, spreadCurveFpmlTriplet);
return(psBasis);
}
if (pst == PricingStructureTypeEnum.RateXccyCurve)
{
//Get the referrence curve identifier.
var refCurveId = properties.GetValue <string>(CurveProp.ReferenceCurveUniqueId, true);
//Load the data.
var refItem = Cache.LoadItem <Market>(refCurveId);
var deserializedRefCurveMarket = (Market)refItem.Data;
var refCurveProperties = refItem.AppProps;
//Get the referrence curve identifier.
var refFxCurveId = properties.GetValue <string>(CurveProp.ReferenceFxCurveUniqueId, true);
//Load the data.
var refFxItem = Cache.LoadItem <Market>(refFxCurveId);
var deserializedRefFxCurveMarket = (Market)refFxItem.Data;
var refFxCurveProperties = refFxItem.AppProps;
//Get the currency2 curve identifier.
var currency2CurveId = properties.GetValue <string>(CurveProp.ReferenceCurrency2CurveId, true);
//Load the data.
var currrecny2Item = Cache.LoadItem <Market>(currency2CurveId);
var deserializedCurrecny2CurveMarket = (Market)currrecny2Item.Data;
var refCurrecnyCurveProperties = currrecny2Item.AppProps;
//Format the ref curve data and call the pricing structure helper.
var refCurveFpmlTriplet =
new Triplet <PricingStructure, PricingStructureValuation, NamedValueSet>(
deserializedRefCurveMarket.Items[0],
deserializedRefCurveMarket.Items1[0], refCurveProperties);
var refFxCurveFpmlTriplet =
new Triplet <PricingStructure, PricingStructureValuation, NamedValueSet>(
deserializedRefFxCurveMarket.Items[0],
deserializedRefFxCurveMarket.Items1[0], refFxCurveProperties);
var currency2CurveFpmlTriplet =
new Triplet <PricingStructure, PricingStructureValuation, NamedValueSet>(
deserializedCurrecny2CurveMarket.Items[0],
deserializedCurrecny2CurveMarket.Items1[0], refCurrecnyCurveProperties);
var spreadCurveFpmlTriplet =
new Triplet <PricingStructure, PricingStructureValuation, NamedValueSet>(deserializedMarket.Items[0],
deserializedMarket.Items1[0], properties);
//create and set the pricingstructure
var psBasis = CurveEngine.Factory.PricingStructureFactory.Create(Logger.Target, Cache, NameSpace, null, null, refCurveFpmlTriplet, refFxCurveFpmlTriplet,
currency2CurveFpmlTriplet, spreadCurveFpmlTriplet);
return(psBasis);
}
// Create FpML pair from Market
//
var fpmlPair = new Pair <PricingStructure, PricingStructureValuation>(deserializedMarket.Items[0],
deserializedMarket.Items1[0]);
//create and set the pricingstructure
var ps = CurveEngine.Factory.PricingStructureFactory.Create(Logger.Target, Cache, NameSpace, null, null, fpmlPair, properties);
return(ps);
}
public void TestCoreCaching()
{
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router))
{
server.Start();
using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").Create())
using (ICoreCache cacheA = client.CreateCache())
using (ICoreCache cacheB = client.CreateCache())
{
using (cacheA.SubscribeNoWait <TestData>(Expr.ALL, null, null))
{
using (cacheB.SubscribeNoWait <TestData>(Expr.ALL, null, null))
{
// publish an item and check all caches are consistent
Guid id0 = cacheA.SaveObject <TestData>(new TestData("Zero", 0), "Item0", null, TimeSpan.MaxValue);
// cacheA is publisher - should be immediately consistent
Assert.AreEqual <int>(1, cacheA.ItemCount);
ICoreItem item0a = cacheA.Items[0];
Assert.IsNotNull(item0a);
TestData data0a = (TestData)item0a.Data;
Assert.IsNotNull(data0a);
Assert.AreEqual <string>("Zero", (data0a.field1));
// cacheB is not publisher - allow for propagation delay
Thread.Sleep(500);
// both caches should now be consistent
Assert.AreEqual <int>(1, cacheA.ItemCount);
Assert.AreEqual <int>(1, cacheB.ItemCount);
ICoreItem item0b = cacheA.Items[0];
Assert.IsNotNull(item0b);
TestData data0b = (TestData)item0b.Data;
Assert.IsNotNull(data0b);
Assert.AreEqual <string>("Zero", (data0b.field1));
Assert.AreEqual <Guid>(item0a.Id, item0b.Id);
}
// cacheB unsubscribed - should not receive updates from cacheA
Guid id1 = cacheA.SaveObject <TestData>(new TestData("One", 1), "Item1", null);
ICoreItem data1a = cacheA.LoadItem <TestData>("Item1");
Guid id2 = cacheB.SaveObject <TestData>(new TestData("Two", 2), "Item2", null);
ICoreItem data2b = cacheB.LoadItem <TestData>("Item2");
// object is immediately available in local cache but not others
Assert.IsNotNull(data1a);
Assert.AreEqual <Guid>(id1, data1a.Id);
Assert.IsNotNull(data2b);
Assert.AreEqual <Guid>(id2, data2b.Id);
// wait a bit for propagation
Thread.Sleep(500);
// both caches should now be 'up-to-date'
// - A should receive from B, but not vice versa
Assert.AreEqual <int>(3, cacheA.ItemCount);
ICoreItem data2a = cacheA.LoadItem <TestData>("Item2");
Assert.IsNotNull(data2a);
Assert.AreEqual <Guid>(id2, data2a.Id);
// - B should be inconsistent with A
Assert.AreEqual <int>(2, cacheB.ItemCount);
// - but becomes consistent as soon as we load the missing item
ICoreItem data1b = cacheB.LoadItem <TestData>("Item1");
Assert.AreEqual <int>(3, cacheB.ItemCount);
Assert.IsNotNull(data1b);
Assert.AreEqual <Guid>(id1, data1b.Id);
}
}
}
}
