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 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 LoadCross(FudgeMsg message)
{
var values = new Dictionary<Tuple<Currency, Currency>, CurrencyMatrixValue>();
foreach (IFudgeField field in message)
{
CurrencyMatrixValue cross = CurrencyMatrixValue.Create(Currency.Create(field.Name));
var value = field.Value;
foreach (IFudgeField field2 in (IFudgeFieldContainer)value)
{
Currency source = Currency.Create(field2.Name);
var value2 = field2.Value;
if (value2 is IFudgeFieldContainer)
{
Currency target = Currency.Create(((IFudgeFieldContainer)value2).First().Name);
values.Add(Tuple.Create(source, target), cross);
}
else
{
Currency target = Currency.Create((string)value2);
values.Add(Tuple.Create(source, target), cross);
values.Add(Tuple.Create(target, source), cross);
}
}
foreach (var valueEntry in values)
{
AddConversion(valueEntry.Key.Item1, valueEntry.Key.Item1, valueEntry.Value);
}
}
}
public void AsQueriesToLongNames()
{
FudgeMsg msg = StandardFudgeMessages.CreateMessageAllNames(fudgeContext);
Assert.Equal((long?)((sbyte)5), msg.GetLong("byte"));
Assert.Equal((long?)((sbyte)5), msg.GetLong("Byte"));
short shortValue = ((short)sbyte.MaxValue) + 5;
Assert.Equal((long?)(shortValue), msg.GetLong("short"));
Assert.Equal((long?)(shortValue), msg.GetLong("Short"));
int intValue = ((int)short.MaxValue) + 5;
Assert.Equal((long?)(intValue), msg.GetLong("int"));
Assert.Equal((long?)(intValue), msg.GetLong("Integer"));
long longValue = ((long)int.MaxValue) + 5;
Assert.Equal((long?)(longValue), msg.GetLong("long"));
Assert.Equal((long?)(longValue), msg.GetLong("Long"));
Assert.Equal((long?)(0), msg.GetLong("float"));
Assert.Equal((long?)(0), msg.GetLong("Float"));
Assert.Equal((long?)(0), msg.GetLong("double"));
Assert.Equal((long?)(0), msg.GetLong("Double"));
}
public void PrimitiveExactQueriesOrdinalsMatch()
{
FudgeMsg msg = StandardFudgeMessages.CreateMessageAllOrdinals(fudgeContext);
Assert.Equal((sbyte)5, msg.GetSByte((short)3));
Assert.Equal((sbyte)5, msg.GetSByte((short)4));
short shortValue = ((short)sbyte.MaxValue) + 5;
Assert.Equal(shortValue, msg.GetShort((short)5));
Assert.Equal(shortValue, msg.GetShort((short)6));
int intValue = ((int)short.MaxValue) + 5;
Assert.Equal(intValue, msg.GetInt((short)7));
Assert.Equal(intValue, msg.GetInt((short)8));
long longValue = ((long)int.MaxValue) + 5;
Assert.Equal(longValue, msg.GetLong((short)9));
Assert.Equal(longValue, msg.GetLong((short)10));
Assert.Equal(0.5f, msg.GetFloat((short)11));
Assert.Equal(0.5f, msg.GetFloat((short)12));
Assert.Equal(0.27362, msg.GetDouble((short)13));
Assert.Equal(0.27362, msg.GetDouble((short)14));
Assert.Equal("Kirk Wylie", msg.GetString((short)15));
}
protected FudgeMsgEnvelope CycleMessage(FudgeContext context, FudgeMsg msg)
{
FudgeStreamParser parser = new FudgeStreamParser(context);
byte[] msgAsBytes = context.ToByteArray(msg);
return(parser.Parse(new MemoryStream(msgAsBytes)));
}
public void PrimitiveExactQueriesNamesMatch()
{
FudgeMsg msg = StandardFudgeMessages.CreateMessageAllNames(fudgeContext);
Assert.Equal((sbyte)5, msg.GetSByte("byte"));
Assert.Equal((sbyte)5, msg.GetSByte("Byte"));
short shortValue = ((short)sbyte.MaxValue) + 5;
Assert.Equal(shortValue, msg.GetShort("short"));
Assert.Equal(shortValue, msg.GetShort("Short"));
int intValue = ((int)short.MaxValue) + 5;
Assert.Equal(intValue, msg.GetInt("int"));
Assert.Equal(intValue, msg.GetInt("Integer"));
long longValue = ((long)int.MaxValue) + 5;
Assert.Equal(longValue, msg.GetLong("long"));
Assert.Equal(longValue, msg.GetLong("Long"));
Assert.Equal(0.5f, msg.GetFloat("float"));
Assert.Equal(0.5f, msg.GetFloat("Float"));
Assert.Equal(0.27362, msg.GetDouble("double"));
Assert.Equal(0.27362, msg.GetDouble("Double"));
Assert.Equal("Kirk Wylie", msg.GetString("String"));
}
internal static FudgeMsg CreateMessageAllOrdinals(FudgeContext context)
{
FudgeMsg msg = context.NewMessage();
msg.Add(1, true);
msg.Add(2, (object)(false));
msg.Add(3, (sbyte)5);
msg.Add(4, (object)((sbyte)5));
short shortValue = ((short)sbyte.MaxValue) + 5;
msg.Add(5, shortValue);
msg.Add(6, (object)(shortValue));
int intValue = ((int)short.MaxValue) + 5;
msg.Add(7, intValue);
msg.Add(8, (object)(intValue));
long longValue = ((long)int.MaxValue) + 5;
msg.Add(9, longValue);
msg.Add(10, (object)(longValue));
msg.Add(11, 0.5f);
msg.Add(12, (object)(0.5f));
msg.Add(13, 0.27362);
msg.Add(14, (object)(0.27362));
msg.Add(15, "Kirk Wylie");
msg.Add(16, new float[24]);
msg.Add(17, new double[273]);
return(msg);
}
/// <summary>
/// Convenience method to deserialize an object graph from a message.
/// </summary>
/// <param name="msg">Message containing serialized state.</param>
/// <param name="hintType">The type to use if not specified in the metadata.</param>
/// <returns>Deserialized object graph.</returns>
public object Deserialize(FudgeMsg msg, Type hintType = null)
{
// Delegate to FudgeDeserializer to do the work
var deserializer = new MessageFudgeDeserializationContext(context, typeMap, TypeMappingStrategy, msg);
return(deserializer.DeserializeGraph(hintType));
}
/// <summary>
/// Convenience method to deserialize an object graph from a message.
/// </summary>
/// <param name="msg">Message containing serialized state.</param>
/// <typeparam name="T">The type to use if not specified in the metadata.</typeparam>
/// <returns>Deserialized object graph.</returns>
public T Deserialize <T>(FudgeMsg msg)
{
// Delegate to FudgeDeserializer to do the work
var deserializer = new MessageFudgeDeserializationContext(context, typeMap, TypeMappingStrategy, msg);
return(deserializer.DeserializeGraph <T>());
}
public void AsQueriesToLongOrdinals()
{
FudgeMsg msg = StandardFudgeMessages.CreateMessageAllOrdinals(fudgeContext);
Assert.Equal((long)((sbyte)5), msg.GetLong((short)3));
Assert.Equal((long)((sbyte)5), msg.GetLong((short)4));
short shortValue = ((short)sbyte.MaxValue) + 5;
Assert.Equal((long)(shortValue), msg.GetLong((short)5));
Assert.Equal((long)(shortValue), msg.GetLong((short)6));
int intValue = ((int)short.MaxValue) + 5;
Assert.Equal((long)(intValue), msg.GetLong((short)7));
Assert.Equal((long)(intValue), msg.GetLong((short)8));
long longValue = ((long)int.MaxValue) + 5;
Assert.Equal(longValue, msg.GetLong((short)9));
Assert.Equal(longValue, msg.GetLong((short)10));
Assert.Equal(0, msg.GetLong((short)11));
Assert.Equal(0, msg.GetLong((short)12));
Assert.Equal(0, msg.GetLong((short)13));
Assert.Equal(0, msg.GetLong((short)14));
}
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 void ToFudgeMsg(IAppendingFudgeFieldContainer message, IFudgeSerializer s)
{
message.Add("name", Name);
if (_uniqueID != null)
{
message.Add("uniqueId", _uniqueID.ToString());
}
s.WriteInline(message, "identifier", PortfolioIdentifier);
s.WriteInline(message, "user", User);
s.WriteInline(message, "resultModelDefinition", ResultModelDefinition);
if (DefaultCurrency != null)
{
message.Add("currency", DefaultCurrency.ISOCode);
}
WriteNullableTimeSpanField(message, "minDeltaCalcPeriod", MinDeltaCalcPeriod);
WriteNullableTimeSpanField(message, "maxDeltaCalcPeriod", MaxDeltaCalcPeriod);
WriteNullableTimeSpanField(message, "fullDeltaCalcPeriod", MinFullCalcPeriod);
WriteNullableTimeSpanField(message, "maxFullCalcPeriod", MaxFullCalcPeriod);
foreach (var calcConfig in CalculationConfigurationsByName.Values)
{
FudgeMsg calcConfigMsg = s.Context.NewMessage();
calcConfig.ToFudgeMsg(calcConfigMsg, s);
message.Add("calculationConfiguration", calcConfigMsg);
}
}
public void LoadCross(FudgeMsg message)
{
var values = new Dictionary <Tuple <Currency, Currency>, CurrencyMatrixValue>();
foreach (IFudgeField field in message)
{
CurrencyMatrixValue cross = CurrencyMatrixValue.Create(Currency.Create(field.Name));
var value = field.Value;
foreach (IFudgeField field2 in (IFudgeFieldContainer)value)
{
Currency source = Currency.Create(field2.Name);
var value2 = field2.Value;
if (value2 is IFudgeFieldContainer)
{
Currency target = Currency.Create(((IFudgeFieldContainer)value2).First().Name);
values.Add(Tuple.Create(source, target), cross);
}
else
{
Currency target = Currency.Create((string)value2);
values.Add(Tuple.Create(source, target), cross);
values.Add(Tuple.Create(target, source), cross);
}
}
foreach (var valueEntry in values)
{
AddConversion(valueEntry.Key.Item1, valueEntry.Key.Item1, valueEntry.Value);
}
}
}
public TRet Put <TRet>(object reqObj, string subMessageField)
{
var reqMsg = _fudgeContext.GetSerializer().SerializeToMsg(reqObj);
FudgeMsg retMsg = FudgeRequestImpl("PUT", reqMsg);
return(ProjectSubMessage <TRet>(retMsg, subMessageField));
}
private T FudgeDeserializedRequestImpl <T>(string method = "GET", FudgeMsg reqMsg = null)
{
return(FudgeMimeRequestImpl(
(response, stream) => _fudgeContext.DeFudgeSerialize <T>(stream),
() => _fudgeContext.DeFudgeSerialize <T>(_fudgeContext.NewMessage()),
default(T), method, reqMsg));
}
public void LongInLongOut()
{
FudgeMsg msg = new FudgeMsg();
msg.Add("test", (long)5);
Assert.Equal((long)5, msg.GetLong("test"));
}
public void Example()
{
var context = new FudgeContext();
// Create a message
var msg = new FudgeMsg(new Field("name", "Eric"),
new Field("age", 14),
new Field("address",
new Field("line1", "29 Acacia Road"),
new Field("city", "London")));
// Serialise it
var stream = new MemoryStream();
context.Serialize(msg, stream);
// Get the raw bytes
var bytes = stream.ToArray();
// Deserialise it
var msg2 = context.Deserialize(bytes).Message;
// Get some data
int age = msg2.GetInt("age") ?? 0;
}
/// <inheritdoc/>
public void StartSubMessage(string name, int? ordinal)
{
msgStack.Push(current);
FudgeMsg newMsg = context.NewMessage();
current.Add(name, ordinal, newMsg);
current = newMsg;
}
public void AllOrdinalsCodecWithTaxonomy()
{
FudgeContext context = new FudgeContext();
FudgeMsg inputMsg = context.NewMessage();
inputMsg.Add(ORDINALS[0], "value1");
inputMsg.Add(ORDINALS[1], "value2");
inputMsg.Add(ORDINALS[2], "value3");
inputMsg.Add(ORDINALS[3], "value4");
var resolverMap = new Dictionary <int, IFudgeTaxonomy>();
resolverMap.Add(45, new MapFudgeTaxonomy(ORDINALS, NAMES));
context.TaxonomyResolver = new ImmutableMapTaxonomyResolver(resolverMap);
FudgeMsg outputMsg = CycleMessage(inputMsg, context, (short)45);
Assert.Equal("value1", outputMsg.GetString(NAMES[0]));
Assert.Equal("value1", outputMsg.GetString(ORDINALS[0]));
Assert.Equal("value2", outputMsg.GetString(NAMES[1]));
Assert.Equal("value2", outputMsg.GetString(ORDINALS[1]));
Assert.Equal("value3", outputMsg.GetString(NAMES[2]));
Assert.Equal("value3", outputMsg.GetString(ORDINALS[2]));
Assert.Equal("value4", outputMsg.GetString(NAMES[3]));
Assert.Equal("value4", outputMsg.GetString(ORDINALS[3]));
}
public void RaisesEventAfterEachMessage()
{
var context = new FudgeContext();
var messages = new FudgeMsg[]
{
new FudgeMsg(context, new Field("test", "data")),
new FudgeMsg(context, new Field("life", 42))
};
var reader = new FudgeMsgStreamReader(context, messages);
var writer = new FudgeMsgStreamWriter(context);
var pipe = new FudgeStreamPipe(reader, writer);
int count = 0;
pipe.MessageProcessed += () =>
{
var message = writer.DequeueMessage();
FudgeUtils.AssertAllFieldsMatch(messages[count], message);
count++;
};
pipe.Process();
Assert.Equal(2, count);
}
/// <summary>
/// Convenience method for writing a <see cref="FudgeMsg"/> to a <see cref="IFudgeStreamWriter"/>.
/// </summary>
/// <param name="writer">Writer to write the data.</param>
/// <param name="msg">Message to write.</param>
public static void WriteMsg(this IFudgeStreamWriter writer, FudgeMsg msg)
{
var reader = new FudgeMsgStreamReader(msg.Context, msg);
var pipe = new FudgeStreamPipe(reader, writer);
pipe.ProcessOne();
}
public void MultipleMessages()
{
// Same as CheckElementsCorrectForSimpleMessage but without using HasNext
var context = new FudgeContext();
var msg1 = context.NewMessage();
msg1.Add("Test", "Bob");
var msg2 = context.NewMessage();
msg2.Add("Test2", "Shirley");
var msgs = new FudgeMsg[] { msg1, msg2 };
var stream = new MemoryStream();
var writer = new FudgeEncodedStreamWriter(context, stream);
new FudgeStreamPipe(new FudgeMsgStreamReader(context, msgs), writer).Process();
stream.Position = 0;
var reader = new FudgeEncodedStreamReader(context, stream);
Assert.Equal(FudgeStreamElement.MessageStart, reader.MoveNext());
Assert.Equal(FudgeStreamElement.SimpleField, reader.MoveNext());
Assert.Equal(FudgeStreamElement.MessageEnd, reader.MoveNext());
Assert.Equal(FudgeStreamElement.MessageStart, reader.MoveNext());
Assert.Equal(FudgeStreamElement.SimpleField, reader.MoveNext());
Assert.Equal(FudgeStreamElement.MessageEnd, reader.MoveNext());
Assert.Equal(FudgeStreamElement.NoElement, reader.MoveNext());
Assert.Equal(FudgeStreamElement.NoElement, reader.MoveNext());
}
protected override void SerializeImpl(ValueProperties obj, IAppendingFudgeFieldContainer msg, IFudgeSerializer serializer)
{
var finite = obj as FiniteValueProperties;
if (finite != null)
{
finite.Serialize(msg, serializer);
}
else
{
if (obj is EmptyValueProperties)
{
return;
}
var withoutMessage = new FudgeMsg(serializer.Context);
if (obj is NearlyInfiniteValueProperties)
{
foreach (var without in ((NearlyInfiniteValueProperties)obj).Without)
{
withoutMessage.Add((string)null, without);
}
}
msg.Add("without", withoutMessage);
}
}
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 void RaisesEventAfterEachMessage()
{
var context = new FudgeContext();
var messages = new FudgeMsg[]
{
new FudgeMsg(context, new Field("test", "data")),
new FudgeMsg(context, new Field("life", 42))
};
var reader = new FudgeMsgStreamReader(context, messages);
var writer = new FudgeMsgStreamWriter(context);
var pipe = new FudgeStreamPipe(reader, writer);
int count = 0;
pipe.MessageProcessed += () =>
{
var message = writer.DequeueMessage();
FudgeUtils.AssertAllFieldsMatch(messages[count], message);
count++;
};
pipe.Process();
Assert.Equal(2, count);
}
/// <inheritdoc/>
public void EndSubMessage()
{
if (msgStack.Count == 0)
{
throw new InvalidOperationException("Ending more sub-messages than started");
}
current = msgStack.Pop();
}
private void Cycle(FudgeTime t)
{
var msg1 = new FudgeMsg(context, new Field("t", t));
var bytes = msg1.ToByteArray();
var msg2 = context.Deserialize(bytes).Message;
Assert.Equal(t, msg2.GetValue <FudgeTime>("t"));
}
public void Minimization()
{
FudgeMsg msg = new FudgeMsg();
msg.Add("int?", 17);
Assert.Same(PrimitiveFieldTypes.SByteType, msg.GetByName("int?").Type);
}
private void Cycle(FudgeTime t)
{
var msg1 = new FudgeMsg(context, new Field("t", t));
var bytes = msg1.ToByteArray();
var msg2 = context.Deserialize(bytes).Message;
Assert.Equal(t, msg2.GetValue<FudgeTime>("t"));
}
public void ToByteArray()
{
FudgeMsg msg = StandardFudgeMessages.CreateMessageAllNames(fudgeContext);
byte[] bytes = msg.ToByteArray();
Assert.NotNull(bytes);
Assert.True(bytes.Length > 10);
}
public void Unknown()
{
FudgeMsg inputMsg = new FudgeMsg(
new Field("unknown", new UnknownFudgeFieldValue(new byte[10], new FudgeTypeDictionary().GetUnknownType(200))));
FudgeMsg outputMsg = CycleMessage(inputMsg, "unknown.dat");
FudgeUtils.AssertAllFieldsMatch(inputMsg, outputMsg);
}
/// <summary>
/// Will output a <see cref="FudgeMsg"/> to <see cref="Console.Out"/> so that you can visually
/// examine it.
/// </summary>
public void OutputToStdoutAllOrdinals()
{
Console.Out.WriteLine("FudgeMsgFormatterTest.OutputToStdoutAllOrdinals()");
FudgeMsg msg = StandardFudgeMessages.CreateMessageAllOrdinals(fudgeContext);
msg.Add("Sub Message", (short)9999, StandardFudgeMessages.CreateMessageAllOrdinals(fudgeContext));
new FudgeMsgFormatter(Console.Out).Format(msg);
}
public bool Finished(FudgeMsg fudgeMsg, int index)
{
Type objectType = GetObjectType(index, null, fudgeMsg, false);
if (objectType != null)
{
DeserializeFromMessageImpl(index, fudgeMsg, objectType);
return true;
}
return false;
}
public void RoundTrip()
{
var d = new FudgeDate(1999, 12, 10);
var msg1 = new FudgeMsg(context, new Field("d", d));
var bytes = msg1.ToByteArray();
var msg2 = context.Deserialize(bytes).Message;
Assert.Equal("1999-12-10", msg2.GetValue<FudgeDate>("d").ToString());
}
public void BindingParams()
{
// Make sure we can handle constants that are coming in from outside the query
var msgs = new FudgeMsg[] { CreateTickMsg(10.3, 11.1, "FOO"), CreateTickMsg(2.4, 3.1, "BAR"), CreateTickMsg(5.2, 5.5, "ZIP") };
double bid = 2.4;
var query = from tick in msgs.AsQueryable<Tick>()
where tick.Bid == bid // bid here comes from outside the query
select tick.Ticker;
var tickers = query.ToArray();
Assert.Equal(new string[] { "BAR" }, tickers);
}
public void FudgeMsgVsIFudgeFieldContainer()
{
// Make sure that we can work with enumerables of IFudgeFieldContainer, enumerables of IFudgeMsg and also arrays directly
var array = new FudgeMsg[] { CreateTickMsg(10.3, 11.1, "FOO"), CreateTickMsg(2.4, 3.1, "BAR") };
IEnumerable<IFudgeFieldContainer> containerList = array;
IEnumerable<FudgeMsg> msgList = array;
var query1 = from tick in containerList.AsQueryable<Tick>() select tick.Ticker;
var query2 = from tick in msgList.AsQueryable<Tick>() select tick.Ticker;
var query3 = from tick in array.AsQueryable<Tick>() select tick.Ticker;
Assert.Equal(query1, query2);
Assert.Equal(query1, query3);
}
public void ToFudgeMsg(IAppendingFudgeFieldContainer a, IFudgeSerializer s)
{
s.WriteTypeHeader(a, GetType());
var fudgeMsg = new FudgeMsg(s.Context);
foreach (var viewCycleExecutionOptionse in _executionSequence)
{
FudgeMsg msg = ((OpenGammaFudgeContext)s.Context).GetSerializer().SerializeToMsg(viewCycleExecutionOptionse);
fudgeMsg.Add(null, null, msg);
}
a.Add("sequence", fudgeMsg);
}
/// <summary>
/// Creates a new <c>FudgeMsgEnvelope</c> around an existing <c>FudgeMsg</c> with a specific encoding schema version. The default
/// schema version is 0.
/// </summary>
/// <param name="message">message contained within the envelope</param>
/// <param name="version">schema version, 0 to 255</param>
public FudgeMsgEnvelope(FudgeMsg message, int version)
{
if (message == null)
{
throw new ArgumentNullException("message", "Must specify a message to wrap.");
}
if ((version < 0) || (version > 255))
{
throw new ArgumentOutOfRangeException("version", "Provided version " + version + " which doesn't fit within one byte.");
}
this.message = message;
this.version = version;
}
public void ComplexSelect()
{
// This code is used in the Fudge.Linq namespace doc example.
var msgs = new FudgeMsg[] { CreateTickMsg(10.3, 11.1, "FOO"), CreateTickMsg(2.4, 3.1, "BAR") };
var query = from tick in msgs.AsQueryable<Tick>()
where tick.Ask > 4.0
select new { tick.Ticker, tick.Ask };
var results = query.ToArray();
Assert.Equal(1, results.Length);
Assert.Equal("FOO", results[0].Ticker);
Assert.Equal(11.1, results[0].Ask);
}
public void FixedWidthByteArrays()
{
FudgeMsg inputMsg = new FudgeMsg(
new Field("byte[4]", CreateRandomArray(4)),
new Field("byte[8]", CreateRandomArray(8)),
new Field("byte[16]", CreateRandomArray(16)),
new Field("byte[20]", CreateRandomArray(20)),
new Field("byte[32]", CreateRandomArray(32)),
new Field("byte[64]", CreateRandomArray(64)),
new Field("byte[128]", CreateRandomArray(128)),
new Field("byte[256]", CreateRandomArray(256)),
new Field("byte[512]", CreateRandomArray(512)),
new Field("byte[28]", CreateRandomArray(28)));
FudgeMsg outputMsg = CycleMessage(inputMsg);
FudgeUtils.AssertAllFieldsMatch(inputMsg, outputMsg);
}
public void CheckSecondaryTypes()
{
var msg = new FudgeMsg(context);
var dt = new DateTime(1987, 1, 13, 8, 6, 5);
var dto = new DateTimeOffset(1822, 7, 20, 13, 2, 15, new TimeSpan(-2, 0, 0));
msg.Add("dt", dt);
msg.Add("dto", dto);
Assert.Same(DateTimeFieldType.Instance, msg.GetByName("dt").Type);
Assert.IsType<FudgeDateTime>(msg.GetByName("dt").Value);
Assert.Same(DateTimeFieldType.Instance, msg.GetByName("dto").Type);
Assert.IsType<FudgeDateTime>(msg.GetByName("dto").Value);
Assert.Equal(dt, msg.GetValue<DateTime>("dt"));
Assert.Equal(dto, msg.GetValue<DateTime>("dto"));
}
public void AddingFieldContainerCopiesFields()
{
var msg = new FudgeMsg();
// Add a normal sub-message (shouldn't copy)
IFudgeFieldContainer sub1 = new FudgeMsg(new Field("age", 37));
msg.Add("sub1", sub1);
Assert.Same(sub1, msg.GetValue("sub1"));
// Add a sub-message that isn't a FudgeMsg (should copy)
IFudgeFieldContainer sub2 = (IFudgeFieldContainer)new Field("dummy", new Field("colour", "blue")).Value;
Assert.IsNotType<FudgeMsg>(sub2); // Just making sure
msg.Add("sub2", sub2);
Assert.NotSame(sub2, msg.GetValue("sub2"));
Assert.IsType<FudgeMsg>(msg.GetValue("sub2"));
Assert.Equal("blue", msg.GetMessage("sub2").GetString("colour"));
}
public void NestedMessages()
{
var msg = new FudgeMsg(new Field("name", "Fred"),
new Field("address",
new Field("number", 17),
new Field("line1", "Our House"),
new Field("line2", "In the middle of our street")));
var sb = new StringBuilder();
var xmlWriter = XmlWriter.Create(sb, new XmlWriterSettings { OmitXmlDeclaration = true });
var writer = new FudgeXmlStreamWriter(context, xmlWriter, "msg");
var reader = new FudgeMsgStreamReader(context, msg);
new FudgeStreamPipe(reader, writer).Process();
xmlWriter.Flush();
string s = sb.ToString();
Assert.Equal("<msg><name>Fred</name><address><number>17</number><line1>Our House</line1><line2>In the middle of our street</line2></address></msg>", s);
}
public void OrderBy()
{
var msgs = new FudgeMsg[] { CreateTickMsg(10.3, 11.1, "FOO"), CreateTickMsg(2.4, 3.1, "BAR"), CreateTickMsg(5.2, 5.5, "ZIP") };
var query = from tick in msgs.AsQueryable<Tick>()
orderby tick.Ask
select tick.Ticker;
string[] tickers = query.ToArray();
Assert.Equal(new string[] { "BAR", "ZIP", "FOO" }, tickers);
// And descending
query = from tick in msgs.AsQueryable<Tick>()
orderby tick.Bid descending
select tick.Ticker;
tickers = query.ToArray();
Assert.Equal(new string[] { "FOO", "ZIP", "BAR" }, tickers);
}
public void Minimsation()
{
var msg = new FudgeMsg(context);
var dt = new DateTime(1990, 2, 1);
var fdt = new FudgeDateTime(1990, 2, 1, 0, 0, 0, 0, FudgeDateTimePrecision.Day);
msg.Add("dt", dt);
msg.Add("fdt", fdt);
Assert.Same(DateFieldType.Instance, msg.GetByName("dt").Type);
Assert.IsType<FudgeDate>(msg.GetByName("dt").Value);
Assert.Same(DateFieldType.Instance, msg.GetByName("fdt").Type);
Assert.IsType<FudgeDate>(msg.GetByName("fdt").Value);
Assert.Equal(dt, msg.GetValue<DateTime>("dt"));
Assert.Equal(fdt, msg.GetValue<FudgeDateTime>("fdt"));
// Error cases
FudgeFieldType type = null;
Assert.Equal(null, DateTimeFieldType.Instance.Minimize(null, ref type));
Assert.Throws<ArgumentException>(() => DateTimeFieldType.Instance.Minimize("fred", ref type));
}
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());
}
public void VariableWidthColumnSizes()
{
FudgeMsg inputMsg = new FudgeMsg();
inputMsg.Add("100", new byte[100]);
inputMsg.Add("1000", new byte[1000]);
inputMsg.Add("10000", new byte[100000]);
FudgeMsg outputMsg = CycleMessage(inputMsg);
Assert.NotNull(outputMsg);
FudgeUtils.AssertAllFieldsMatch(inputMsg, outputMsg);
}
public void RoundTrip()
{
var dt = new FudgeDateTime(1999, 12, 10, 3, 4, 5, 987654321, -75, FudgeDateTimePrecision.Nanosecond);
var msg1 = new FudgeMsg(context, new Field("dt", dt));
var bytes = msg1.ToByteArray();
var msg2 = context.Deserialize(bytes).Message;
Assert.Equal("1999-12-10T03:04:05.987654321-01:15", msg2.GetValue<FudgeDateTime>("dt").ToString());
}
public void WriteIndicatorType()
{
var msg = new FudgeMsg(new Field("blank", IndicatorType.Instance));
var sb = new StringBuilder();
var xmlWriter = XmlWriter.Create(sb, new XmlWriterSettings { OmitXmlDeclaration = true });
var writer = new FudgeXmlStreamWriter(context, xmlWriter, "msg") { AutoFlushOnMessageEnd = true };
var reader = new FudgeMsgStreamReader(context, msg);
new FudgeStreamPipe(reader, writer).Process();
xmlWriter.Flush();
string s = sb.ToString();
Assert.Equal("<msg><blank /></msg>", s);
}
public void Minimization()
{
FudgeMsg msg = new FudgeMsg();
msg.Add("int?", 17);
Assert.Same(PrimitiveFieldTypes.SByteType, msg.GetByName("int?").Type);
}
protected void CheckResultsMatch(FudgeMsg msg)
{
CheckResultsMatch(msg, new FudgeContext());
}
public void Unknown()
{
FudgeMsg inputMsg = new FudgeMsg();
inputMsg.Add("unknown", new UnknownFudgeFieldValue(new byte[10], new FudgeTypeDictionary().GetUnknownType(200)));
FudgeMsg outputMsg = CycleMessage(inputMsg);
FudgeUtils.AssertAllFieldsMatch(inputMsg, outputMsg);
}
public void GetAllNames()
{
var msg = new FudgeMsg();
msg.Add("foo", 3);
msg.Add("bar", 17);
msg.Add("foo", 2); // Deliberately do a duplicate
var names = msg.GetAllFieldNames();
Assert.Equal(2, names.Count);
Assert.Contains("foo", names);
Assert.Contains("bar", names);
}
//throws IOException
protected static FudgeMsg CycleMessage(FudgeMsg msg)
{
byte[] content = fudgeContext.ToByteArray(msg);
// Double-check the size calc was right
Assert.Equal(content.Length, new FudgeMsgEnvelope(msg).ComputeSize(null));
MemoryStream stream2 = new MemoryStream(content);
FudgeMsgEnvelope outputMsgEnvelope = fudgeContext.Deserialize(stream2);
Assert.NotNull(outputMsgEnvelope);
Assert.NotNull(outputMsgEnvelope.Message);
return outputMsgEnvelope.Message;
}
protected FudgeMsgEnvelope CycleMessage(FudgeContext context, FudgeMsg msg)
{
FudgeStreamParser parser = new FudgeStreamParser(context);
byte[] msgAsBytes = context.ToByteArray(msg);
return parser.Parse(new MemoryStream(msgAsBytes));
}
public void HasField_FRN82()
{
var msg = new FudgeMsg();
msg.Add("foo", 3);
msg.Add(17, "bar");
Assert.True(msg.HasField("foo"));
Assert.False(msg.HasField("bar"));
Assert.True(msg.HasField(17));
Assert.False(msg.HasField(3));
}
/**
* @param msg
*/
protected void CheckResultsMatch(FudgeMsg msg, FudgeContext fudgeContext)
{
FudgeMsgEnvelope result = CycleMessage(fudgeContext, msg);
Assert.NotNull(result);
Assert.NotNull(result.Message);
FudgeMsg resultMsg = result.Message;
FudgeUtils.AssertAllFieldsMatch(msg, resultMsg);
}
public ClassWithMessageIn()
{
Message = new FudgeMsg();
}
public void LongInLongOut()
{
FudgeMsg msg = new FudgeMsg();
msg.Add("test", (long)5);
Assert.Equal((long)5, msg.GetLong("test"));
}
