public override ICurrencyMatrix DeserializeImpl(IFudgeFieldContainer message, IFudgeDeserializer deserializer)
{
var matrixImpl = new CurrencyMatrix();
IFudgeField field = message.GetByName(UniqueIDFieldName);
if (field != null)
{
var uid = UniqueId.Parse((string)field.Value);
matrixImpl.UniqueId = uid;
}
field = message.GetByName(CrossConvertFieldName);
if (field != null)
{
var crossconvert = (FudgeMsg)field.Value;
matrixImpl.LoadCross(crossconvert);
}
field = message.GetByName(FixedRateFieldName);
if (field != null)
{
throw new NotImplementedException();
}
field = message.GetByName(ValueRequirementsFieldName);
if (field != null)
{
FudgeMsg value = (FudgeMsg)field.Value;
matrixImpl.LoadReq(value, deserializer);
}
return(matrixImpl);
}
public override ComputedValue DeserializeImpl(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
var valueSpecification = deserializer.FromField <ValueSpecification>(ffc.GetByName("specification"));
var value = GetValue(deserializer, ffc.GetByName("value"), valueSpecification);
return(new ComputedValue(valueSpecification, value));
}
public static Pair FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
var first = FromField(deserializer, ffc, "first");
var second = FromField(deserializer, ffc, "second");
return(Build(first, second));
}
public static UniqueId GetUniqueIdentifier(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer, string fieldName)
{
UniqueId portfolioIdentifier;
IFudgeField idField = ffc.GetByName(fieldName);
if (idField != null)
{
var value = idField.Value;
if (value is string)
{
portfolioIdentifier = UniqueId.Parse((string) value);
}
else if (value is IFudgeFieldContainer)
{
portfolioIdentifier = deserializer.FromField<UniqueId>(idField);
}
else
{
throw new ArgumentException(String.Format("Couldn't read UID {0}", value));
}
}
else
{
portfolioIdentifier = null;
}
return portfolioIdentifier;
}
public override ExternalId DeserializeImpl(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
string scheme = msg.GetValue <string>("Scheme");
string value = msg.GetValue <string>("Value");
return(new ExternalId(scheme, value));
}
public object Deserialize(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
var ret = DeserializeImpl(msg, deserializer);
deserializer.Register(msg, ret);
return(ret);
}
public static InterpolatedDoublesSurface FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
var xData = ffc.GetValue<double[]>("x data");
var yData = ffc.GetValue<double[]>("y data");
var zData = ffc.GetValue<double[]>("z data");
return new InterpolatedDoublesSurface(xData, yData, zData);
}
public override VolatilitySurfaceData DeserializeImpl(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
Currency currency = ffc.GetValue <Currency>("currency");
string definitionName = ffc.GetValue <string>("definitionName");
string specificationName = ffc.GetValue <string>("specificationName");
string interpolatorName = ffc.GetValue <string>("interpolatorName");
bool xWrapped;
IList <object> xs = ReadAllAsObjectList(ffc, "xs", deserializer, out xWrapped);
bool yWrapped;
IList <object> ys = ReadAllAsObjectList(ffc, "ys", deserializer, out yWrapped);
Type xType = GetType(xs);
Type yType = GetType(ys);
var values = new Dictionary <Tuple <object, object>, double>();
var valuesFields = ffc.GetAllByName("values");
foreach (var valueField in valuesFields)
{
var subMessage = (IFudgeFieldContainer)valueField.Value;
var xField = subMessage.GetByName("x");
var yField = subMessage.GetByName("y");
object x = xWrapped ? GetWrappedPrimitive(xField) : deserializer.FromField(xField, xType);
object y = yWrapped ? GetWrappedPrimitive(yField) : deserializer.FromField(yField, yType);
double value = subMessage.GetValue <double>("value");
values.Add(new Tuple <object, object>(x, y), value);
}
return(Build(xType, yType, definitionName, specificationName, currency, interpolatorName, xs, ys, values));
}
public static ConstantDoublesSurface FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
double z = ffc.GetDouble("z value").Value;
string name = ffc.GetString("surface name");
return(new ConstantDoublesSurface(z, name));
}
private FudgeMsg CopyContainer(IFudgeFieldContainer container)
{
var msg = context.NewMessage();
msg.AddAll(container);
return(msg);
}
public static TestWrapper <T> FromFudgeMsg(IFudgeFieldContainer ffc,
IFudgeDeserializer deserializer)
{
return(new TestWrapper <T> {
Test = deserializer.FromField <T>(ffc.GetByName("test"))
});
}
public static ViewDefinition FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
var name = ffc.GetValue <string>("name");
var uniqueIdString = ffc.GetString("uniqueId");
var uniqueId = uniqueIdString == null ? null : UniqueId.Parse(uniqueIdString);
var resultModelDefinition = deserializer.FromField <ResultModelDefinition>(ffc.GetByName("resultModelDefinition"));
UniqueId portfolioIdentifier = ValueRequirement.GetUniqueIdentifier(ffc, deserializer, "identifier");
var user = deserializer.FromField <UserPrincipal>(ffc.GetByName("user"));
var currency = ffc.GetValue <Currency>("currency");
var minDeltaCalcPeriod = ReadNullableTimeSpanField(ffc, "minDeltaCalcPeriod");
var maxDeltaCalcPeriod = ReadNullableTimeSpanField(ffc, "maxDeltaCalcPeriod");
var minFullCalcPeriod = ReadNullableTimeSpanField(ffc, "fullDeltaCalcPeriod");
var maxFullCalcPeriod = ReadNullableTimeSpanField(ffc, "maxFullCalcPeriod");
var calculationConfigurationsByName = ffc.GetAllByName("calculationConfiguration")
.Select(deserializer.FromField <ViewCalculationConfiguration>)
.ToDictionary(vcc => vcc.Name);
return(new ViewDefinition(name, resultModelDefinition, portfolioIdentifier, user, currency, minDeltaCalcPeriod, maxDeltaCalcPeriod, minFullCalcPeriod, maxFullCalcPeriod, calculationConfigurationsByName, uniqueId));
}
public static FunctionalDoublesCurve FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
string name = GetName(ffc);
double[] parameters = ffc.GetValue <double[]>("NSS parameters");
return(Create(new NelsonSiegelSvennsonBondCurveModel(parameters).Eval, name));
}
public object Deserialize(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
var deserialize = Enum.Parse(typeof(SurrogateEnumTest), msg.GetString(1));
deserializer.Register(msg, deserialize);
return(deserialize);
}
public static ManageableMarketDataSnapshot FromFudgeMsg(IFudgeFieldContainer ffc,
IFudgeDeserializer deserializer)
{
var uidString = ffc.GetString("uniqueId");
UniqueId uid = uidString == null ? null : UniqueId.Parse(uidString);
var surfaceMessage = ffc.GetMessage("volatilitySurfaces");
Dictionary <VolatilitySurfaceKey, ManageableVolatilitySurfaceSnapshot> surfaces;
if (surfaceMessage == null)
{
//Handle old format
surfaces = new Dictionary <VolatilitySurfaceKey, ManageableVolatilitySurfaceSnapshot>();
}
else
{
surfaces = MapBuilder.FromFudgeMsg <VolatilitySurfaceKey, ManageableVolatilitySurfaceSnapshot>(surfaceMessage, deserializer);
}
var manageableMarketDataSnapshot = new ManageableMarketDataSnapshot(
ffc.GetString("basisViewName"),
deserializer.FromField <ManageableUnstructuredMarketDataSnapshot>(ffc.GetByName("globalValues")),
MapBuilder.FromFudgeMsg <YieldCurveKey, ManageableYieldCurveSnapshot>(ffc.GetMessage("yieldCurves"), deserializer),
MapBuilder.FromFudgeMsg <VolatilityCubeKey, ManageableVolatilityCubeSnapshot>(ffc.GetMessage("volatilityCubes"), deserializer),
surfaces,
uid
)
{
Name = ffc.GetString("name")
};
return(manageableMarketDataSnapshot);
}
public override UnorderedCurrencyPair DeserializeImpl(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
Currency ccy1 = Currency.Create(msg.GetString("currency1"));
Currency ccy2 = Currency.Create(msg.GetString("currency2"));
return(new UnorderedCurrencyPair(ccy1, ccy2));
}
private static UniqueId GetUniqueId(IFudgeFieldContainer msg, string fieldName)
{
//TODO: remove this once PLAT-1683 is fixed
var uidStr = msg.GetString(fieldName);
return(uidStr == string.Empty ? null : UniqueId.Parse(uidStr));
}
public static ViewCalculationConfiguration FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
var name = ffc.GetValue <string>("name");
List <ValueRequirement> specificRequirements = GetList <ValueRequirement>(ffc, "specificRequirement", deserializer);
//TODO MAP deserializer by magic
var portfolioRequirementsBySecurityType = new Dictionary <string, HashSet <Tuple <string, ValueProperties> > >();
foreach (var portfolioReqField in ffc.GetAllByName("portfolioRequirementsBySecurityType"))
{
const string securitytypeKey = "securityType";
var securityType = ((IFudgeFieldContainer)portfolioReqField.Value).GetValue <string>(securitytypeKey);
var enumerable = ((IFudgeFieldContainer)portfolioReqField.Value).GetAllByName("portfolioRequirement").Select(f => GetReqPair(f, deserializer));
portfolioRequirementsBySecurityType.Add(securityType, new HashSet <Tuple <string, ValueProperties> >(enumerable));
}
var defaultProperties = deserializer.FromField <ValueProperties>(ffc.GetByName("defaultProperties"));
var deltaDefinition = deserializer.FromField <DeltaDefinition>(ffc.GetByName("deltaDefinition"));
IResolutionRuleTransform transform = null;
IFudgeField transformField = ffc.GetByName("resolutionRuleTransform");
if (transformField != null)
{
transform = deserializer.FromField <IResolutionRuleTransform>(transformField);
}
return(new ViewCalculationConfiguration(name, specificRequirements, portfolioRequirementsBySecurityType, deltaDefinition, defaultProperties, transform));
}
public static UniqueId GetUniqueIdentifier(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer, string fieldName)
{
UniqueId portfolioIdentifier;
IFudgeField idField = ffc.GetByName(fieldName);
if (idField != null)
{
var value = idField.Value;
if (value is string)
{
portfolioIdentifier = UniqueId.Parse((string)value);
}
else if (value is IFudgeFieldContainer)
{
portfolioIdentifier = deserializer.FromField <UniqueId>(idField);
}
else
{
throw new ArgumentException(String.Format("Couldn't read UID {0}", value));
}
}
else
{
portfolioIdentifier = null;
}
return(portfolioIdentifier);
}
/// <inheritdoc/>
public object Deserialize(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
IFudgeSerializable result = (IFudgeSerializable)constructor.Invoke(null);
deserializer.Register(msg, result);
result.Deserialize(msg, deserializer);
return result;
}
public virtual void Deserialize(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
foreach (IFudgeField field in msg)
{
DeserializeField(deserializer, field);
}
}
/// <inheritdoc/>
public object Deserialize(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
var result = fromFudgeMsgMethod.Invoke(null, new object[] { msg, deserializer });
deserializer.Register(msg, result);
return(result);
}
public override SimplePortfolioNode DeserializeImpl(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
return(new SimplePortfolioNode(
UniqueId.Parse(msg.GetString("identifier")), msg.GetString("name"),
deserializer.FromField <IList <PortfolioNode> >(msg.GetByName("subNodes")) ?? new List <PortfolioNode>(),
deserializer.FromField <IList <IPosition> >(msg.GetByName("positions")) ?? new List <IPosition>()));
}
/// <summary>
/// Formats a message with a given starting indent.
/// </summary>
/// <param name="msg">message to format</param>
/// <param name="depth">starting indent</param>
protected void Format(IFudgeFieldContainer msg, int depth)
{
if (msg == null)
{
return;
}
IList <IFudgeField> fields = msg.GetAllFields();
IList <string> fieldSpecs = new List <string>(fields.Count);
int maxFieldSpecWidth = -1;
int maxTypeNameWidth = -1;
for (int i = 0; i < fields.Count; i++)
{
IFudgeField field = fields[i];
string fieldSpec = GetFieldSpec(field, i, depth);
maxFieldSpecWidth = Math.Max(maxFieldSpecWidth, fieldSpec.Length);
maxTypeNameWidth = Math.Max(maxTypeNameWidth, GetTypeName(field.Type).Length);
fieldSpecs.Add(fieldSpec);
}
for (int i = 0; i < fields.Count; i++)
{
IFudgeField field = fields[i];
string fieldSpec = fieldSpecs[i];
Format(field, i, depth, fieldSpec, maxFieldSpecWidth, maxTypeNameWidth);
}
}
public override ValueSpecification DeserializeImpl(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
string valueName = null;
ValueProperties properties = null;
foreach (var fudgeField in msg)
{
switch (fudgeField.Name)
{
case "valueName":
valueName = (string)fudgeField.Value;
break;
case "properties":
properties = deserializer.FromField <ValueProperties>(fudgeField);
break;
default:
break;
}
}
var targetSpecification = new ComputationTargetSpecificationBuilder(deserializer.Context, typeof(ComputationTargetSpecification)).DeserializeImpl(msg, deserializer); //Can't register twice
return(new ValueSpecification(valueName, targetSpecification, properties));
}
public static ValueSnapshot FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
return(new ValueSnapshot(ffc.GetDouble("marketValue"))
{
OverrideValue = ffc.GetDouble("overrideValue")
});
}
public static UniqueId FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
string schema = null;
string value = null;
string version = null;
foreach (var field in ffc)
{
switch (field.Name)
{
case SchemeFudgeFieldName:
schema = (string)field.Value;
break;
case ValueFudgeFieldName:
value = (string)field.Value;
break;
case VersionFudgeFieldName:
version = (string)field.Value;
break;
case null:
if (field.Ordinal != 0)
{
throw new ArgumentException();
}
break;
default:
throw new ArgumentException();
}
}
return(new UniqueId(schema, value, version));
}
public override VersionCorrection DeserializeImpl(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
var versionOf = ((FudgeDateTime)msg.GetValue("versionAsOf")).ToDateTimeOffsetWithDefault();
var correctedTo = ((FudgeDateTime)msg.GetValue("correctedTo")).ToDateTimeOffsetWithDefault();
return(new VersionCorrection(versionOf, correctedTo));
}
protected override InMemoryViewComputationResultModel BuildObject(IFudgeFieldContainer msg, IFudgeDeserializer deserializer, Dictionary <string, ViewCalculationResultModel> configurationMap, UniqueId viewProcessId, UniqueId viewCycleId, DateTimeOffset inputDataTimestamp, DateTimeOffset resultTimestamp, TimeSpan calculationDuration)
{
var liveDataMsg = msg.GetMessage("liveData");
List <ComputedValue> liveData = liveDataMsg == null ? null : liveDataMsg.GetAllByOrdinal(1).Select(deserializer.FromField <ComputedValue>).ToList();
return(new InMemoryViewComputationResultModel(viewProcessId, viewCycleId, inputDataTimestamp, resultTimestamp, configurationMap, liveData, calculationDuration));
}
public static YieldCurveDefinition FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
Currency currency = null;
string name = null;
string interpolatorName = null;
var strips = new List<FixedIncomeStrip>();
ExternalId region = null;
foreach (var fudgeField in ffc)
{
switch (fudgeField.Name)
{
case "currency":
currency = Currency.Create((string)fudgeField.Value);
break;
case "name":
name = (string)fudgeField.Value;
break;
case "interpolatorName":
interpolatorName = (string)fudgeField.Value;
break;
case "region":
region = ExternalId.Parse((string)fudgeField.Value);
break;
case "strip":
strips.Add(deserializer.FromField<FixedIncomeStrip>(fudgeField));
break;
}
}
var yieldCurveDefinition = new YieldCurveDefinition(currency, name, interpolatorName);
yieldCurveDefinition.Region = region;
yieldCurveDefinition.AddStrip(strips.ToArray());
return yieldCurveDefinition;
}
public object Deserialize(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
var address = new Address(msg.GetString("line1"),
msg.GetString("line2"),
msg.GetString("zip"));
deserializer.Register(msg, address);
return address;
}
public static VolatilityPoint FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
return(new VolatilityPoint(
new Tenor(ffc.GetString("swapTenor")),
new Tenor(ffc.GetString("optionExpiry")),
ffc.GetDouble("relativeStrike").Value
));
}
/// <inheritdoc/>
public object Deserialize(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
return(helper.Deserialize(msg, deserializer, (obj, si, sc) =>
{
var args = new object[] { si, sc };
constructor.Invoke(obj, args);
}));
}
public static ViewCycleExecutionOptions FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
IFudgeField mdsField = ffc.GetByName("marketDataSpecification");
var marketDataSpecification = mdsField == null ? null : deserializer.FromField<MarketDataSpecification>(mdsField);
var valuationValue = ffc.GetValue("valuation");
var valuation = (FudgeDateTime)(valuationValue == IndicatorType.Instance ? null : valuationValue);
return new ViewCycleExecutionOptions(valuation.ToDateTimeOffsetWithDefault(), marketDataSpecification);
}
public static NodalDoublesCurve FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
string name = GetName(ffc);
var xData = ffc.GetValue<double[]>("x data");
var yData = ffc.GetValue<double[]>("y data");
return new NodalDoublesCurve(name, xData, yData);
}
public static TimeSpan? Build(IFudgeFieldContainer msg)
{
if (msg == null)
{
return null;
}
return TimeSpan.FromSeconds(msg.GetLong("seconds").Value) + TimeSpan.FromTicks(msg.GetLong("nanos").Value / 100);
}
public static TimeSpan?Build(IFudgeFieldContainer msg)
{
if (msg == null)
{
return(null);
}
return(TimeSpan.FromSeconds(msg.GetLong("seconds").Value) + TimeSpan.FromTicks(msg.GetLong("nanos").Value / 100));
}
public override ComputationTarget DeserializeImpl(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
var computationTargetType = EnumBuilder <ComputationTargetType> .Parse(ffc.GetMessage("type").GetString(1));
object value = GetValue(deserializer, ffc.GetByName("value"));
return(new ComputationTarget(computationTargetType, value));
}
public static DateTimeOffset GetDocumentValues(IFudgeFieldContainer ffc, out DateTimeOffset versionToInstant, out DateTimeOffset correctionFromInstant, out DateTimeOffset correctionToInstant)
{
var versionFromInstant = ffc.GetValue<FudgeDateTime>("versionFromInstant").ToDateTimeOffsetWithDefault();
correctionFromInstant = ffc.GetValue<FudgeDateTime>("correctionFromInstant").ToDateTimeOffsetWithDefault();
versionToInstant = ffc.GetValue<FudgeDateTime>("versionToInstant").ToDateTimeOffsetWithDefault();
correctionToInstant = ffc.GetValue<FudgeDateTime>("correctionToInstant").ToDateTimeOffsetWithDefault();
return versionFromInstant;
}
public static VolatilityCubeDefinition FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
return new VolatilityCubeDefinition(
deserializer.FromField<List<string>>(ffc.GetByName("swapTenors")).Select(s => new Tenor(s)).ToList(),
deserializer.FromField<List<string>>(ffc.GetByName("optionExpiries")).Select(s => new Tenor(s)).ToList(),
ffc.GetMessage("relativeStrikes").Select(f => f.Value).Cast<double>().ToList()
);
}
public static ArrayLocalDateDoubleTimeSeries FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
var dateTimeConverterField = ffc.GetByOrdinal(1);
var fastTimeSeriesField = ffc.GetByOrdinal(2);
var dateTimeConverter = deserializer.FromField<LocalDateEpochDaysConverter>(dateTimeConverterField);
var fastTimeSeries = deserializer.FromField<FastArrayIntDoubleTimeSeries>(fastTimeSeriesField);
return new ArrayLocalDateDoubleTimeSeries(dateTimeConverter, fastTimeSeries);
}
public static InterpolatedYieldCurveSpecificationWithSecurities FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
return new InterpolatedYieldCurveSpecificationWithSecurities(
new DateTimeOffset(
((FudgeDate) ffc.GetValue("curveDate")).ToDateTime()),
(string) ffc.GetValue("name"),
ffc.GetValue<Currency>("currency"),
ffc.GetAllByName("resolvedStrips").Select(deserializer.FromField<FixedIncomeStripWithSecurity>).ToList()
);
}
public static ValueRequirement FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
ValueProperties constraints = deserializer.FromField<ValueProperties>(ffc.GetByName("constraints")) ?? ValueProperties.Create();
var computationTargetType = ffc.GetValue<string>("computationTargetType");
var computationTargetIdentifier = GetUniqueIdentifier(ffc, deserializer, "computationTargetIdentifier");
var targetSpec = new ComputationTargetSpecification(EnumBuilder<ComputationTargetType>.Parse(computationTargetType), computationTargetIdentifier);
var valueName = ffc.GetValue<string>("valueName");
return new ValueRequirement(valueName, targetSpec, constraints);
}
public static SecurityDocument FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
DateTimeOffset versionToInstant;
DateTimeOffset correctionFromInstant;
DateTimeOffset correctionToInstant;
DateTimeOffset versionFromInstant = GetDocumentValues(ffc, out versionToInstant, out correctionFromInstant, out correctionToInstant);
var uid = (ffc.GetString("uniqueId") != null) ? UniqueId.Parse(ffc.GetString("uniqueId")) : deserializer.FromField<UniqueId>(ffc.GetByName("uniqueId"));
var security = deserializer.FromField<ISecurity>(ffc.GetByName("security"));
return new SecurityDocument(uid, security, versionFromInstant, versionToInstant, correctionFromInstant, correctionToInstant);
}
public static InterpolatedYieldCurveSpecification FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
var curveDate = ffc.GetValue<DateTimeOffset>("curveDate");
string name = ffc.GetString("name");
var currency = ffc.GetValue<Currency>("currency");
var region = ExternalId.Parse(ffc.GetString("region"));
var resolvedStripFields = ffc.GetAllByName("resolvedStrips");
var resolvedStrips = resolvedStripFields.Select(deserializer.FromField<FixedIncomeStripWithIdentifier>)
.ToList();
return new InterpolatedYieldCurveSpecification(curveDate, name, currency, resolvedStrips, region);
}
public static YieldCurveDefinitionDocument FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
DateTimeOffset versionToInstant;
DateTimeOffset correctionFromInstant;
DateTimeOffset correctionToInstant;
DateTimeOffset versionFromInstant = GetDocumentValues(ffc, out versionToInstant, out correctionFromInstant, out correctionToInstant);
var uid = (ffc.GetString("uniqueId") != null) ? UniqueId.Parse(ffc.GetString("uniqueId")) : deserializer.FromField<UniqueId>(ffc.GetByName("uniqueId"));
var definition = deserializer.FromField<YieldCurveDefinition>(ffc.GetByName("yieldCurveDefinition"));
return new YieldCurveDefinitionDocument(versionFromInstant, versionToInstant, correctionFromInstant, correctionToInstant) { YieldCurveDefinition = definition, UniqueId = uid};
}
public static MarketDataSnapshotDocument FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
DateTimeOffset versionToInstant;
DateTimeOffset correctionFromInstant;
DateTimeOffset correctionToInstant;
DateTimeOffset versionFromInstant = GetDocumentValues(ffc, out versionToInstant, out correctionFromInstant, out correctionToInstant);
var uid = (ffc.GetString("uniqueId") != null) ? UniqueId.Parse(ffc.GetString("uniqueId")) : deserializer.FromField<UniqueId>(ffc.GetByName("uniqueId"));
var snapshot = deserializer.FromField<ManageableMarketDataSnapshot>(ffc.GetByName("snapshot"));
return new MarketDataSnapshotDocument(uid, snapshot, versionFromInstant, versionToInstant, correctionFromInstant, correctionToInstant);
}
public static FixedIncomeStripWithSecurity FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
var originalstrip = deserializer.FromField<FixedIncomeStrip>(ffc.GetByName("strip"));
var resolvedTenor = new Tenor(ffc.GetString("resolvedTenor"));
DateTimeOffset maturity = GetDateTime(ffc.GetByName("maturity"));
ExternalId securityIdentifier = ExternalId.Parse(ffc.GetString("identifier"));
var security = deserializer.FromField<ISecurity>(ffc.GetByName("security"));
return new FixedIncomeStripWithSecurity(originalstrip,
resolvedTenor,
maturity,
securityIdentifier,
security
);
}
public static VolatilityCubeData FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
var dataPoints = MapBuilder.FromFudgeMsg(ffc.GetMessage("dataPoints"), deserializer.FromField<VolatilityPoint>, f => (double)f.Value);
var otherValues = deserializer.FromField<SnapshotDataBundle>(ffc.GetByName("otherData"));
Dictionary<Pair<Tenor, Tenor>, double> strikes = null;
var strikesField = ffc.GetMessage("strikes");
if (strikesField != null)
{
strikes = strikesField.Select(deserializer.FromField<StrikeEntry>).ToDictionary(s => new Pair<Tenor, Tenor>(new Tenor(s.SwapTenor), new Tenor(s.OptionExpiry)), s => s.Strike);
}
return new VolatilityCubeData(dataPoints, otherValues, strikes);
}
public static ChangeEvent FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
var changeType = EnumBuilder<ChangeType>.Parse(ffc.GetMessage("type").GetString(1));
var beforeField = ffc.GetString("beforeId");
var beforeId = beforeField == null ? null : UniqueId.Parse(beforeField);
var afterField = ffc.GetString("afterId");
var afterId = afterField == null ? null : UniqueId.Parse(afterField);
var versionField = ffc.GetByName("versionInstant");
var versionInstant = (FudgeDateTime) versionField.Value;
return new ChangeEvent(changeType,
beforeId,
afterId,
new Instant(versionInstant));
}
public object Deserialize(IFudgeFieldContainer msg, IFudgeDeserializer deserializer, Action<object, SerializationInfo, StreamingContext> deserializeMethod)
{
// Create without construction and register before we call the constructor in case there are any cycles
object result = FormatterServices.GetUninitializedObject(type);
deserializer.Register(msg, result);
var converter = new DeserializingFormatterConverter(deserializer);
var si = new SerializationInfo(this.type, converter);
PopulateSerializationInfo(si, msg);
beforeAfterMixin.CallBeforeDeserialize(result);
deserializeMethod(result, si, streamingContext);
beforeAfterMixin.CallAfterDeserialize(result);
return result;
}
public static PresentValueSensitivity FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
var data = new Dictionary<string, List<Tuple<double, double>>>();
var curveNames = ffc.GetAllByName("curve name");
var sensitivities = ffc.GetAllByName("sensitivities");
int id = 0;
foreach (var tuple in curveNames.Zip(sensitivities, Tuple.Create))
{
string curveName = new StringBuilder("TODO ").Append(id++).ToString(); //I believe the java is broken
var listSensitivities = (IFudgeFieldContainer) tuple.Item2;
var pairsFields = listSensitivities.GetAllByName(null);
var tuples = pairsFields.Select(ReadPair).ToList();
data.Add(curveName, tuples);
}
return new PresentValueSensitivity(data);
}
private ComponentRepository GetComponentRepository(IFudgeFieldContainer configMsg)
{
var componentInfos = new Dictionary<ComponentKey, ComponentInfo>();
foreach (var userDataField in configMsg.GetMessage("infos"))
{
if (!(userDataField.Value is IFudgeFieldContainer))
{
continue;
}
var component = (IFudgeFieldContainer)userDataField.Value;
var uri = new Uri(_rootUri, component.GetString("uri"));
var componentKey = new ComponentKey(component.GetString("type"), component.GetString("classifier"));
Dictionary<string, string> attributes = component.GetMessage("attributes").ToDictionary(f => f.Name, f => (string) f.Value);
componentInfos.Add(componentKey, new ComponentInfo(componentKey, uri, attributes));
}
return new ComponentRepository(componentInfos);
}
public void PopulateSerializationInfo(SerializationInfo si, IFudgeFieldContainer msg)
{
foreach (var field in msg)
{
if (field.Name != null)
{
if (field.Type == IndicatorFieldType.Instance)
{
// This is actually a null
si.AddValue(field.Name, null);
}
else
{
si.AddValue(field.Name, field.Value);
}
}
}
}
/// <inheritdoc/>
public object Deserialize(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
// We create the new object without constructing it, so we can register it before trying
// to deserialize the parameters. This allows us to support cycles.
object result = FormatterServices.GetUninitializedObject(type);
deserializer.Register(msg, result);
var args = new object[constructorParams.Length];
foreach (var field in msg)
{
if (field.Name != null)
{
string name = field.Name.ToLower();
for (int i = 0; i < constructorParams.Length; i++)
{
var constructorParam = constructorParams[i];
if (constructorParam.LowerName == name)
{
switch (constructorParam.Kind)
{
case TypeData.TypeKind.FudgePrimitive:
args[i] = context.TypeHandler.ConvertType(field.Value, constructorParam.TypeData.Type); ;
break;
default:
args[i] = deserializer.FromField(field, constructorParam.TypeData.Type);
break;
}
break;
}
}
}
}
constructor.Invoke(result, args);
return result;
}
public static ViewDefinitionCompilationFailedCall FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
return new ViewDefinitionCompilationFailedCall(ffc.GetValue<DateTimeOffset>("valuationTime"), deserializer.FromField<JavaException>(ffc.GetByName("exception")));
}
/// <inheritdoc/>
public object Deserialize(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
return memberSerializer.Deserialize(msg, deserializer);
}
/// <inheritdoc/>
public object Deserialize(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
return helper.CreateAndDeserialize(msg, deserializer);
}
public void Deserialize(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
// Skip message
Other = deserializer.FromField<ClassWithMessageIn>(msg.GetByName("other"));
}
public void Deserialize(IFudgeFieldContainer msg, IFudgeDeserializer deserializer)
{
Bid = msg.GetDouble("Bid") ?? 0.0;
Ask = msg.GetDouble("Ask") ?? 0.0;
BidVolume = msg.GetDouble("BidVolume") ?? 0.0;
AskVolume = msg.GetDouble("AskVolume") ?? 0.0;
Timestamp = msg.GetLong("Timestamp") ?? 0;
}
