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 void LookupByNameSingleValue() { FudgeMsg msg = StandardFudgeMessages.CreateMessageAllNames(fudgeContext); IFudgeField field = null; IList <IFudgeField> fields = null; field = msg.GetByName("boolean"); Assert.NotNull(field); Assert.Equal(PrimitiveFieldTypes.BooleanType, field.Type); Assert.Equal(true, field.Value); Assert.Equal("boolean", field.Name); Assert.Null(field.Ordinal); field = msg.GetByName("Boolean"); Assert.NotNull(field); Assert.Equal(PrimitiveFieldTypes.BooleanType, field.Type); Assert.Equal((object)false, field.Value); Assert.Equal("Boolean", field.Name); Assert.Null(field.Ordinal); fields = msg.GetAllByName("boolean"); Assert.NotNull(fields); Assert.Equal(1, fields.Count); field = fields[0]; Assert.NotNull(field); Assert.Equal(PrimitiveFieldTypes.BooleanType, field.Type); Assert.Equal(true, field.Value); Assert.Equal("boolean", field.Name); Assert.Null(field.Ordinal); // Check the indicator type specially Assert.Same(IndicatorType.Instance, msg.GetValue("indicator")); }
public void LookupByNameMultipleValues() { FudgeMsg msg = StandardFudgeMessages.CreateMessageAllNames(fudgeContext); IFudgeField field = null; IList <IFudgeField> fields = null; // Now add a second by name. msg.Add("boolean", true); field = msg.GetByName("boolean"); Assert.NotNull(field); Assert.Equal(PrimitiveFieldTypes.BooleanType, field.Type); Assert.Equal(true, field.Value); Assert.Equal("boolean", field.Name); Assert.Null(field.Ordinal); fields = msg.GetAllByName("boolean"); Assert.NotNull(fields); Assert.Equal(2, fields.Count); field = fields[0]; Assert.NotNull(field); Assert.Equal(PrimitiveFieldTypes.BooleanType, field.Type); Assert.Equal(true, field.Value); Assert.Equal("boolean", field.Name); Assert.Null(field.Ordinal); field = fields[1]; Assert.NotNull(field); Assert.Equal(PrimitiveFieldTypes.BooleanType, field.Type); Assert.Equal(true, field.Value); Assert.Equal("boolean", field.Name); Assert.Null(field.Ordinal); }
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); }
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 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)); }
private static Pair <Tenor, Tenor> DeserializeKey(IFudgeField fudgeField) { Tenor first = DeserializeTenor(fudgeField, "first"); Tenor second = DeserializeTenor(fudgeField, "second"); return(new Pair <Tenor, Tenor>(first, second)); }
/// <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); } }
/// <inheritdoc/> public object FromField(IFudgeField field, Type type) { if (field == null) { return(null); } if (field.Type == FudgeMsgFieldType.Instance) { // SubMsg var subMsg = (FudgeMsg)field.Value; int refId = msgToIndexMap[subMsg]; Debug.Assert(objectList[refId].Msg == subMsg); return(GetFromRef(refId, type)); // It is possible that we've already deserialized this, so we call GetFromRef rather than just processing the message } else if (field.Type == IndicatorFieldType.Instance) { // Indicator means null return(null); } else { int relativeRef = Convert.ToInt32(field.Value); int refIndex = relativeRef + stack.Peek().RefId; return(GetFromRef(refIndex, type)); } }
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)); }
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)); }
/// <inheritdoc /> public void Add(IFudgeField field) { if (field == null) { throw new ArgumentNullException("Cannot add an empty field"); } Add(field.Name, field.Ordinal, field.Type, field.Value); }
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); } }
public static object GetValue(IFudgeDeserializer deserializer, IFudgeField valueField, ValueSpecification valueSpecification) { if (valueSpecification.ValueName == "YieldCurveJacobian") { var fudgeFieldContainer = (IFudgeFieldContainer)valueField.Value; //TODO I hope this gets a better type one day? return(fudgeFieldContainer.Where(f => !f.Ordinal.HasValue).Select(f => (double[])f.Value).ToList()); } return(Pair.FromField(deserializer, valueField)); }
private static Tenor DeserializeTenor(IFudgeField fudgeField, string fieldName) { var fieldContainer = (IFudgeFieldContainer)fudgeField.Value; var value = fieldContainer.GetString(fieldName); if (value == null) { var fudgeFieldContainer = fieldContainer.GetMessage(fieldName); value = fudgeFieldContainer.GetString("tenor"); } return(new Tenor(value)); }
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)); }
private static DateTimeOffset GetDateTime(IFudgeField zonedDateTimeField) { var inner = (IFudgeFieldContainer)zonedDateTimeField.Value; string zone = inner.GetString("zone"); // TODO this string odt = inner.GetString("datetime"); DateTimeOffset dateTimeOffset = DateTimeOffset.Parse(odt); if (zone != "UTC") { throw new NotImplementedException(); } return(dateTimeOffset); }
/// <summary> /// Convenience method to get any field value as a string. /// </summary> /// <param name="field">Field containing the value.</param> /// <returns><c>null</c> if the field value is <c>null</c>, otherwise the result of calling <see cref="object.ToString"/> on the value.</returns> public static string GetString(this IFudgeField field) { object value = field.Value; if (value == null) { return(null); } else { return(value.ToString()); } }
public bool DeserializeField(IFudgeField field, IFudgeDeserializer deserializer, object obj) { if (field.Name == null) { return(false); // Can't process without a name (yet) } MorePropertyData prop; if (propMap.TryGetValue(field.Name, out prop)) { prop.Adder(prop, obj, field, deserializer); return(true); } return(false); }
/// <summary> /// Helper method to deserialize an individual field. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="field"></param> /// <param name="deserializer"></param> /// <param name="kind"></param> /// <returns></returns> protected T DeserializeField <T>(IFudgeField field, IFudgeDeserializer deserializer, TypeData.TypeKind kind) where T : class { switch (kind) { case TypeData.TypeKind.FudgePrimitive: return((T)context.TypeHandler.ConvertType(field.Value, typeof(T))); case TypeData.TypeKind.Inline: case TypeData.TypeKind.Reference: return(deserializer.FromField <T>(field)); default: throw new FudgeRuntimeException("Unknown TypeData.TypeKind: " + kind); } }
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); }
/// <inheritdoc/> public FudgeStreamElement MoveNext() { if (currentState == null) { if (!HasNext) // Will fetch the next if required { element = FudgeStreamElement.NoElement; } else { currentState = new State(nextMessage); nextMessage = null; element = FudgeStreamElement.MessageStart; } } else if (currentState.Fields.Count == 0) { if (stack.Count == 0) { // Finished the message currentState = null; element = FudgeStreamElement.MessageEnd; } else { currentState = stack.Pop(); element = FudgeStreamElement.SubmessageFieldEnd; } } else { field = currentState.Fields.Dequeue(); if (field.Type == FudgeMsgFieldType.Instance) { stack.Push(currentState); currentState = new State((FudgeMsg)field.Value); element = FudgeStreamElement.SubmessageFieldStart; } else { element = FudgeStreamElement.SimpleField; } } return(element); }
public static void AssertAllFieldsMatch(FudgeMsg expectedMsg, FudgeMsg actualMsg) { var expectedIter = expectedMsg.GetAllFields().GetEnumerator(); var actualIter = actualMsg.GetAllFields().GetEnumerator(); while (expectedIter.MoveNext()) { Assert.True(actualIter.MoveNext()); IFudgeField expectedField = expectedIter.Current; IFudgeField actualField = actualIter.Current; Assert.Equal(expectedField.Name, actualField.Name); Assert.Equal(expectedField.Type, actualField.Type); Assert.Equal(expectedField.Ordinal, actualField.Ordinal); if (expectedField.Value.GetType().IsArray) { Assert.Equal(expectedField.Value.GetType(), actualField.Value.GetType()); Assert.Equal(expectedField.Value, actualField.Value); // XUnit will check all values in the arrays } else if (expectedField.Value is FudgeMsg) { Assert.True(actualField.Value is FudgeMsg); AssertAllFieldsMatch((FudgeMsg)expectedField.Value, (FudgeMsg)actualField.Value); } else if (expectedField.Value is UnknownFudgeFieldValue) { Assert.IsType <UnknownFudgeFieldValue>(actualField.Value); UnknownFudgeFieldValue expectedValue = (UnknownFudgeFieldValue)expectedField.Value; UnknownFudgeFieldValue actualValue = (UnknownFudgeFieldValue)actualField.Value; Assert.Equal(expectedField.Type.TypeId, actualField.Type.TypeId); Assert.Equal(expectedValue.Type.TypeId, actualField.Type.TypeId); Assert.Equal(expectedValue.Contents, actualValue.Contents); } else { Assert.Equal(expectedField.Value, actualField.Value); } } Assert.False(actualIter.MoveNext()); }
/// <summary> /// Writes a line describing a field and its value. If the field is a submessage, that message is output at a deeper indentation level. /// </summary> /// <param name="field">field to output</param> /// <param name="index">physical index within containing message</param> /// <param name="depth">indentation level</param> /// <param name="fieldSpec">field description text (includes indent)</param> /// <param name="maxFieldSpecWidth">length of longest field description text (for layout)</param> /// <param name="maxTypeNameWidth">length of longest type name (for layout)</param> protected void Format(IFudgeField field, int index, int depth, string fieldSpec, int maxFieldSpecWidth, int maxTypeNameWidth) { if (field == null) { throw new ArgumentNullException("Cannot format a null field"); } Writer.Write(fieldSpec); int nWritten = fieldSpec.Length; int requiredSize = maxFieldSpecWidth + 1; for (int i = nWritten; i <= requiredSize; i++) { Writer.Write(' '); nWritten++; } string typeName = GetTypeName(field.Type); Writer.Write(typeName); nWritten += typeName.Length; requiredSize = requiredSize + maxTypeNameWidth + 1; for (int i = nWritten; i <= requiredSize; i++) { Writer.Write(' '); nWritten++; } if (field.Value is FudgeMsg) { Writer.WriteLine(); FudgeMsg msgValue = (FudgeMsg)field.Value; Format(msgValue, depth + 1); } else { Writer.Write(field.Value); Writer.WriteLine(); } Writer.Flush(); }
private Type GetObjectType(Type hintType, FudgeMsg message) { Type objectType = null; IFudgeField typeField = message.GetByOrdinal(FudgeSerializer.TypeIdFieldOrdinal); if (typeField == null) { if (hintType == null) { throw new FudgeRuntimeException("Serialized object has no type ID"); } objectType = hintType; } else if (typeField.Type == StringFieldType.Instance) { var typeName = (string)typeField.Value; objectType = typeMappingStrategy.GetType(typeName); if (objectType == null) { var typeNames = message.GetAllValues <string>(FudgeSerializer.TypeIdFieldOrdinal); for (int i = 1; i < typeNames.Count; i++) // 1 because we've already tried the first { objectType = typeMappingStrategy.GetType(typeNames[i]); if (objectType != null) { // Found it break; } } } } else { throw new NotSupportedException("Serialisation framework does not support back/forward references"); } return(objectType); }
/// <summary> /// Returns a string describing the field with an indentation prefix. The description includes the physical index, ordinal index (if specified), /// and field name (if specified). /// </summary> /// <param name="field">field</param> /// <param name="index">physical index within a message</param> /// <param name="depth">indentation level</param> /// <returns>field description</returns> protected string GetFieldSpec(IFudgeField field, int index, int depth) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < depth; i++) { sb.Append(indentText); } sb.Append(index); sb.Append("-"); if (field.Ordinal != null) { sb.Append("(").Append(field.Ordinal).Append(")"); if (field.Name != null) { sb.Append(" "); } } if (field.Name != null) { sb.Append(field.Name); } return(sb.ToString()); }
private static bool IsWrappedPrimitive(IFudgeField fudgeField) { var ffc = fudgeField.Value as IFudgeFieldContainer; if (ffc == null) { return(false); } var valueFields = ffc.GetAllByName("value"); var valueFieldCount = valueFields.Count; if (valueFieldCount != 1) { return(false); } var allByOrdinal = ffc.GetAllByOrdinal(0); if (allByOrdinal.Count == 0) { return(false); } if (valueFieldCount + allByOrdinal.Count != ffc.Count()) { return(false); } if (valueFieldCount != 1) { return(false); } if (valueFields.Single().Value is IFudgeFieldContainer) { return(false); } return(true); }
private static DateTimeOffset GetDateTime(IFudgeField zonedDateTimeField) { var inner = (IFudgeFieldContainer)zonedDateTimeField.Value; string zone = inner.GetString("zone"); // TODO this string odt = inner.GetString("datetime"); DateTimeOffset dateTimeOffset = DateTimeOffset.Parse(odt); if (zone != "UTC") throw new NotImplementedException(); return dateTimeOffset; }
/// <summary> /// Returns a string describing the field with an indentation prefix. The description includes the physical index, ordinal index (if specified), /// and field name (if specified). /// </summary> /// <param name="field">field</param> /// <param name="index">physical index within a message</param> /// <param name="depth">indentation level</param> /// <returns>field description</returns> protected string GetFieldSpec(IFudgeField field, int index, int depth) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < depth; i++) { sb.Append(indentText); } sb.Append(index); sb.Append("-"); if (field.Ordinal != null) { sb.Append("(").Append(field.Ordinal).Append(")"); if (field.Name != null) { sb.Append(" "); } } if (field.Name != null) { sb.Append(field.Name); } return sb.ToString(); }
private static long GetLong(IFudgeField field) { return ((IConvertible)field.Value).ToInt64(null); }
private static Tuple<double, double> ReadPair(IFudgeField f) { var fudgeFieldContainer = (IFudgeFieldContainer) f.Value; return Tuple.Create(fudgeFieldContainer.GetDouble(0).Value, fudgeFieldContainer.GetDouble(1).Value); }
/// <summary> /// Creates a new message field from an existing field. /// </summary> /// <param name="field">an existing field to copy</param> public FudgeMsgField(IFudgeField field) : this(field.Type, field.Value, field.Name, field.Ordinal) { }
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; }
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; }
/// <inheritdoc/> public FudgeStreamElement MoveNext() { if (currentState == null) { if (!HasNext) // Will fetch the next if required { element = FudgeStreamElement.NoElement; } else { currentState = new State(nextMessage); nextMessage = null; element = FudgeStreamElement.MessageStart; } } else if (currentState.Fields.Count == 0) { if (stack.Count == 0) { // Finished the message currentState = null; element = FudgeStreamElement.MessageEnd; } else { currentState = stack.Pop(); element = FudgeStreamElement.SubmessageFieldEnd; } } else { field = currentState.Fields.Dequeue(); if (field.Type == FudgeMsgFieldType.Instance) { stack.Push(currentState); currentState = new State((IFudgeFieldContainer)field.Value); element = FudgeStreamElement.SubmessageFieldStart; } else { element = FudgeStreamElement.SimpleField; } } return element; }
/// <summary> /// Calculates the length of the field description (physical index, ordinal index if specified, and field name if specified). /// The length includes the indentation prefix. /// </summary> /// <param name="field">field</param> /// <param name="index">physical index within a containing message</param> /// <param name="depth">indentation level</param> /// <returns></returns> protected int GetFieldSpecWidth(IFudgeField field, int index, int depth) { return GetFieldSpec(field, index, depth).Length; }