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 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 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>())); }
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 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 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 SABRFittedSurfaces FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer) { return(new SABRFittedSurfaces( deserializer.FromField <InterpolatedDoublesSurface>(ffc.GetByName("AlphaSurface")), deserializer.FromField <InterpolatedDoublesSurface>(ffc.GetByName("BetaSurface")), deserializer.FromField <InterpolatedDoublesSurface>(ffc.GetByName("NuSurface")), deserializer.FromField <InterpolatedDoublesSurface>(ffc.GetByName("RhoSurface")), Currency.Create(ffc.GetString("Currency")), ffc.GetString("DayCountName") )); }
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 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 CompiledViewDefinitionImpl FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer) { ViewDefinition defn = deserializer.FromField <ViewDefinition>(ffc.GetByName("viewDefinition")); IPortfolio portfolio = deserializer.FromField <IPortfolio>(ffc.GetByName("portfolio")); DateTimeOffset latestValidity = ffc.GetValue <FudgeDateTime>("latestValidity").ToDateTimeOffsetWithDefault(); DateTimeOffset earliestValidity = ffc.GetValue <FudgeDateTime>("earliestValidity").ToDateTimeOffsetWithDefault(); var configs = ffc.GetAllByName("compiledCalculationConfigurations").Select(deserializer.FromField <CompiledViewCalculationConfigurationImpl>).ToDictionary(c => c.Name, c => (ICompiledViewCalculationConfiguration)c); return(new CompiledViewDefinitionImpl(defn, portfolio, latestValidity, earliestValidity, configs)); }
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 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 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 TestWrapper <T> FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer) { return(new TestWrapper <T> { Test = deserializer.FromField <T>(ffc.GetByName("test")) }); }
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 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 object FromField(IFudgeDeserializer deserializer, IFudgeField valueField) { if (valueField.Type != FudgeMsgFieldType.Instance) { return(valueField.Value); } var fudgeFieldContainer = (IFudgeFieldContainer)valueField.Value; foreach (var typeField in fudgeFieldContainer.GetAllByOrdinal(0)) { switch (typeField.Value as string) { case "java.lang.Number": case "java.lang.String": return(fudgeFieldContainer.GetValue("value")); case "org.fudgemsg.StandardFudgeMsg": return(valueField.Value); //TODO: this is not right default: continue; } } return(deserializer.FromField(valueField, null)); }
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); }
private void ObjectAdd(MorePropertyData prop, object obj, IFudgeField field, IFudgeDeserializer deserializer) { // Handles both reference and inline object subObject = deserializer.FromField(field, prop.PropertyData.Type); prop.PropertyData.Setter(obj, subObject); }
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 void LoadReq(FudgeMsg message, IFudgeDeserializer deserializer) { var values = new Dictionary <Tuple <Currency, Currency>, CurrencyMatrixValue>(); foreach (var field in message) { Currency source = Currency.Create(field.Name); foreach (var field2 in (IFudgeFieldContainer)field.Value) { Currency target = Currency.Create(field2.Name); if (field2.Value is IFudgeFieldContainer) { CurrencyMatrixValue value = deserializer.FromField <CurrencyMatrixValue.CurrencyMatrixValueRequirement>(field2); values.Add(Tuple.Create(source, target), value); values.Add(Tuple.Create(target, source), value.Reciprocal); } else { values.Remove(Tuple.Create(target, source)); } } } foreach (var valueEntry in values) { AddConversion(valueEntry.Key.Item1, valueEntry.Key.Item2, valueEntry.Value); } }
private static Tuple <string, ValueProperties> GetReqPair(IFudgeField field, IFudgeDeserializer deserializer) { var ffc = (IFudgeFieldContainer)field.Value; string requiredOutput = ffc.GetString("requiredOutput"); var constraints = deserializer.FromField <ValueProperties>(ffc.GetByName("constraints")); return(Tuple.Create(requiredOutput, constraints)); }
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); }
private static Pair <ValueSpecification, object> GetValue(IFudgeField field, IFudgeDeserializer deserializer) { var msg = (IFudgeFieldContainer)field.Value; var spec = deserializer.FromField <ValueSpecification>(msg.GetByName("first")); var value = ComputedValueBuilder.GetValue(deserializer, msg.GetByName("second"), spec); return(new Pair <ValueSpecification, object>(spec, value)); }
protected static Tuple <DateTimeNumericEncoding, T[], double[]> FromFudgeMsgImpl(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer) { var encoding = deserializer.FromField <DateTimeNumericEncoding>(ffc.GetByOrdinal(1)); var times = ffc.GetValue <T[]>(2); var values = ffc.GetValue <double[]>(3); return(System.Tuple.Create(encoding, times, values)); }
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)); }
private void ListAppend <T>(MorePropertyData prop, object obj, IFudgeField field, IFudgeDeserializer deserializer) where T : class { IList <T> newList = deserializer.FromField <IList <T> >(field); IList <T> currentList = (IList <T>)prop.PropertyData.Getter(obj); foreach (T item in newList) { currentList.Add(item); } }
/// <remarks> /// See also <see cref="ComputedValueBuilder.GetValue"/> /// </remarks> private static object Deserialize(IFudgeDeserializer deserializer, IFudgeTypeMappingStrategy typeMap, string labelType, IFudgeField labelValue) { if (labelValue.Type != FudgeMsgFieldType.Instance) { return(labelValue.Value); } Type labelClass = typeMap.GetType(labelType); return(deserializer.FromField(labelValue, labelClass)); }
public static ManageableUnstructuredMarketDataSnapshot FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer) { var dictionary = new Dictionary <MarketDataValueSpecification, IDictionary <string, ValueSnapshot> >(); foreach (var entryField in ffc.GetAllByOrdinal(1)) { var entryMsg = (IFudgeFieldContainer)entryField.Value; MarketDataValueSpecification valueSpec = null; string valueName = null; ValueSnapshot value = null; foreach (var field in entryMsg) { switch (field.Name) { case "valueSpec": valueSpec = deserializer.FromField <MarketDataValueSpecification>(field); break; case "valueName": valueName = (string)field.Value; break; case "value": value = deserializer.FromField <ValueSnapshot>(field); break; default: throw new ArgumentOutOfRangeException(); } } IDictionary <string, ValueSnapshot> innerDict; if (!dictionary.TryGetValue(valueSpec, out innerDict)) { innerDict = new Dictionary <string, ValueSnapshot>(); dictionary.Add(valueSpec, innerDict); } innerDict.Add(valueName, value); } return(new ManageableUnstructuredMarketDataSnapshot(dictionary)); }
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 override DependencyNode DeserializeImpl(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer) { var target = deserializer.FromField <ComputationTarget>(ffc.GetByName("target")); string parameterizedFunctionUniqueId = ffc.GetString("parameterizedFunctionUniqueId"); var functionParametersField = ffc.GetByName("functionParameters"); var functionParameters = functionParametersField != null?deserializer.FromField <IFunctionParameters>(functionParametersField) : null; string functionShortName = ffc.GetString("functionShortName"); string functionUniqueId = ffc.GetString("functionUniqueId"); ICompiledFunctionDefinition function = new CompiledFunctionDefinitionStub(target.Type, functionShortName, functionUniqueId); var parameterizedFunction = new ParameterizedFunction(function, functionParameters, parameterizedFunctionUniqueId); var inputValues = DeserializeSet <ValueSpecification>(deserializer, ffc, "inputValues"); var outputValues = DeserializeSet <ValueSpecification>(deserializer, ffc, "outputValues"); var terminalOutputValues = DeserializeSet <ValueSpecification>(deserializer, ffc, "terminalOutputValues"); return(new DependencyNode(target, inputValues, outputValues, terminalOutputValues, parameterizedFunction)); }
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); }
private static object GetValue(IFudgeDeserializer deserializer, IFudgeField valueField) { if (valueField.Type != FudgeMsgFieldType.Instance) { if (valueField.Value is string) { return(UniqueId.Parse((string)valueField.Value)); } throw new ArgumentException("Computation target type which I don't know how to deserialize"); } return(deserializer.FromField <object>(valueField)); }
public override PortfolioDocument DeserializeImpl(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer) { DateTimeOffset versionToInstant; DateTimeOffset correctionFromInstant; DateTimeOffset correctionToInstant; DateTimeOffset versionFromInstant = AbstractDocument.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 portfolio = deserializer.FromField <ManageablePortfolio>(ffc.GetByName("portfolio")); return(new PortfolioDocument(versionFromInstant, versionToInstant, correctionFromInstant, correctionToInstant, uid, portfolio)); }
public override IPosition DeserializeImpl(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer) { var id = ffc.GetValue <string>("uniqueId"); var secKey = deserializer.FromField <ExternalIdBundle>(ffc.GetByName("securityKey")); var quant = ffc.GetValue <string>("quantity"); var trades = deserializer.FromField <IList <ITrade> >(ffc.GetByName("trades")) ?? new List <ITrade>(); decimal quantity; if (!decimal.TryParse(quant, out quantity)) { if (quant == "0E-8") { quantity = 0; } else { throw new OpenGammaException("Failed to parse quantity " + quant); } } return(new SimplePosition(id == null ? null : UniqueId.Parse(id), quantity, secKey, trades)); }
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 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 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 static SABRFittedSurfaces FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer) { return new SABRFittedSurfaces( deserializer.FromField<InterpolatedDoublesSurface>(ffc.GetByName("AlphaSurface")), deserializer.FromField<InterpolatedDoublesSurface>(ffc.GetByName("BetaSurface")), deserializer.FromField<InterpolatedDoublesSurface>(ffc.GetByName("NuSurface")), deserializer.FromField<InterpolatedDoublesSurface>(ffc.GetByName("RhoSurface")), Currency.Create(ffc.GetString("Currency")), ffc.GetString("DayCountName") ); }
public void LoadReq(FudgeMsg message, IFudgeDeserializer deserializer) { var values = new Dictionary<Tuple<Currency, Currency>, CurrencyMatrixValue>(); foreach (var field in message) { Currency source = Currency.Create(field.Name); foreach (var field2 in (IFudgeFieldContainer)field.Value) { Currency target = Currency.Create(field2.Name); if (field2.Value is IFudgeFieldContainer) { CurrencyMatrixValue value = deserializer.FromField<CurrencyMatrixValue.CurrencyMatrixValueRequirement>(field2); values.Add(Tuple.Create(source, target), value); values.Add(Tuple.Create(target, source), value.Reciprocal); } else { values.Remove(Tuple.Create(target, source)); } } } foreach (var valueEntry in values) { AddConversion(valueEntry.Key.Item1, valueEntry.Key.Item2, valueEntry.Value); } }
public static ForwardCurve FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer) { return new ForwardCurve(deserializer.FromField<Math.Curve.Curve>(ffc.GetByName("forwardCurve"))); }
public void Deserialize(IFudgeFieldContainer msg, IFudgeDeserializer deserializer) { // Skip message Other = deserializer.FromField<ClassWithMessageIn>(msg.GetByName("other")); }
protected virtual bool DeserializeField(IFudgeDeserializer deserializer, IFudgeField field) { switch (field.Name) { case "name": Name = field.GetString(); return true; case "mainAddress": MainAddress = deserializer.FromField<Address>(field); return true; } // Field not recognised return false; }
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() ); }
/// <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 CycleExecutionFailedCall FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer) { return new CycleExecutionFailedCall(deserializer.FromField<ViewCycleExecutionOptions>(ffc.GetByName("executionOptions")), deserializer.FromField<JavaException>(ffc.GetByName("exception"))); }
public static ViewDefinitionCompilationFailedCall FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer) { return new ViewDefinitionCompilationFailedCall(ffc.GetValue<DateTimeOffset>("valuationTime"), deserializer.FromField<JavaException>(ffc.GetByName("exception"))); }
public static CompiledViewDefinitionImpl FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer) { ViewDefinition defn = deserializer.FromField<ViewDefinition>(ffc.GetByName("viewDefinition")); IPortfolio portfolio = deserializer.FromField<IPortfolio>(ffc.GetByName("portfolio")); DateTimeOffset latestValidity = ffc.GetValue<FudgeDateTime>("latestValidity").ToDateTimeOffsetWithDefault(); DateTimeOffset earliestValidity = ffc.GetValue<FudgeDateTime>("earliestValidity").ToDateTimeOffsetWithDefault(); var configs = ffc.GetAllByName("compiledCalculationConfigurations").Select(deserializer.FromField<CompiledViewCalculationConfigurationImpl>).ToDictionary(c => c.Name, c => (ICompiledViewCalculationConfiguration)c); return new CompiledViewDefinitionImpl(defn, portfolio, latestValidity, earliestValidity, configs); }
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 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 FixedIncomeStripWithIdentifier FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer) { return new FixedIncomeStripWithIdentifier(ExternalId.Parse(ffc.GetString("identifier")), deserializer.FromField<FixedIncomeStrip>(ffc.GetByName("strip"))); }
protected override bool DeserializeField(IFudgeDeserializer deserializer, IFudgeField field) { // Let the base process first if (base.DeserializeField(deserializer, field)) return true; // Now process our fields switch (field.Name) { case "siblings": siblings.Add(deserializer.FromField<Person>(field)); return true; } // Neither recognised the field return false; }