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;
}
/// <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();
}
/// <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>
/// 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)
{
}
/// <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;
}
