public void CircularReference()
{
var typeMap = new SerializationTypeMap(context);
typeMap.RegisterType(typeof(Explicit.Sibling));
typeMap.RegisterType(typeof(Explicit.Address), new Explicit.AddressSerializer());
var serializer = new FudgeSerializer(context, typeMap);
var bob = new Explicit.Sibling {
Name = "Bob"
};
var shirley = new Explicit.Sibling {
Name = "Shirley"
};
bob.Siblings.Add(shirley);
shirley.Siblings.Add(bob); // Create our cycle
var msg = serializer.SerializeToMsg(bob);
var bob2 = (Explicit.Sibling)serializer.Deserialize(msg);
Assert.NotSame(bob, bob2);
Assert.Equal(1, bob2.Siblings.Count);
var shirley2 = (Explicit.Sibling)bob2.Siblings[0];
Assert.NotSame(shirley, shirley2);
Assert.Equal(1, shirley2.Siblings.Count);
Assert.Same(bob2, shirley2.Siblings[0]);
}
public void ReferencedObject()
{
var typeMap = new SerializationTypeMap(context);
typeMap.RegisterType(typeof(Explicit.Sibling));
typeMap.RegisterType(typeof(Explicit.Address), new Explicit.AddressSerializer());
var serializer = new FudgeSerializer(context, typeMap);
var bob = new Explicit.Sibling {
Name = "Bob"
};
var shirley = new Explicit.Sibling {
Name = "Shirley"
};
bob.Siblings.Add(shirley); // We don't reciprocate yet as that would generate a cycle
var msg = serializer.SerializeToMsg(bob);
var bob2 = (Explicit.Sibling)serializer.Deserialize(msg);
Assert.NotSame(bob, bob2);
Assert.Equal(1, bob2.Siblings.Count);
Assert.NotSame(shirley, bob2.Siblings[0]);
Assert.Equal("Shirley", bob2.Siblings[0].Name);
}
public void AllowTypeDiscoveryBehaviour()
{
var context = new FudgeContext();
var map = new SerializationTypeMap(context);
map.AllowTypeDiscovery = false;
Assert.Null(map.GetSurrogate(typeof(Reflect.Tick)));
Assert.Equal(-1, map.GetTypeId(typeof(Reflect.Tick)));
map.AllowTypeDiscovery = true;
Assert.NotNull(map.GetSurrogate(typeof(Reflect.Tick)));
Assert.NotEqual(-1, map.GetTypeId(typeof(Reflect.Person)));
}
public void PicksUpPropertiesFromContext()
{
var context = new FudgeContext();
var map1 = new SerializationTypeMap(context);
Assert.True(map1.AllowTypeDiscovery);
context.SetProperty(ContextProperties.AllowTypeDiscoveryProperty, false);
var map2 = new SerializationTypeMap(context);
Assert.False(map2.AllowTypeDiscovery);
}
public void SimpleExampleWithSurrogate()
{
var typeMap = new SerializationTypeMap(context);
typeMap.RegisterType(typeof(Explicit.Address), new Explicit.AddressSerializer());
var serializer = new FudgeSerializer(context, typeMap);
var address = new Explicit.Address("Our House", "In the middle of our street", "MD1");
var msg = serializer.SerializeToMsg(address);
var address2 = (Explicit.Address)serializer.Deserialize(msg);
Assert.Equal(address.Line1, address2.Line1);
Assert.Equal(address.Line2, address2.Line2);
Assert.Equal(address.Zip, address2.Zip);
}
public void SimpleExampleWithIFudgeSerializable()
{
var typeMap = new SerializationTypeMap(context);
typeMap.RegisterType(typeof(Explicit.Tick));
var serializer = new FudgeSerializer(context, typeMap);
var tick = new Explicit.Tick {
Ticker = "FOO", Bid = 12.3, Offer = 12.9
};
var msg = serializer.SerializeToMsg(tick);
var tick2 = (Explicit.Tick)serializer.Deserialize(msg);
Assert.Equal(tick.Ticker, tick2.Ticker);
Assert.Equal(tick.Bid, tick2.Bid);
Assert.Equal(tick.Offer, tick2.Offer);
}
public void InlineObject()
{
var typeMap = new SerializationTypeMap(context);
typeMap.RegisterType(typeof(Explicit.Person));
typeMap.RegisterType(typeof(Explicit.Address), new Explicit.AddressSerializer());
var serializer = new FudgeSerializer(context, typeMap);
var person = new Explicit.Person {
Name = "Bob", MainAddress = new Explicit.Address("Foo", "Bar", null)
};
var msg = serializer.SerializeToMsg(person);
var person2 = (Explicit.Person)serializer.Deserialize(msg);
Assert.NotSame(person.MainAddress, person2.MainAddress);
Assert.Equal(person.MainAddress.Line1, person2.MainAddress.Line1);
}
protected T1 DeserializeStandard <T1>(OpenGammaFudgeContext context, IFudgeStreamReader reader, SerializationTypeMap typeMap)
{
//Called just after SubmessageFieldStart for a field containing a T1
//TODO: should handle T1 being stream serializable
FudgeMsg dequeueMessage = ReadOneSubmessage(context, reader);
var fudgeSerializer = new FudgeSerializer(context, typeMap);
return(fudgeSerializer.Deserialize <T1>(dequeueMessage));
}
protected abstract T Deserialize(OpenGammaFudgeContext context, IFudgeStreamReader stream, SerializationTypeMap typeMap);
public TReq Deserialize <TReq>(OpenGammaFudgeContext context, IFudgeStreamReader stream, SerializationTypeMap typeMap)
{
if (typeof(TReq) != typeof(T))
{
throw new ArgumentException(string.Format("Unexpected type {0}", typeof(TReq)));
}
return((TReq)(object)Deserialize(context, stream, typeMap));
}
protected override FudgeListWrapper <T> Deserialize(OpenGammaFudgeContext context, IFudgeStreamReader stream, SerializationTypeMap typeMap)
{
bool inList = false;
var items = new List <T>();
while (stream.HasNext)
{
switch (stream.MoveNext())
{
case FudgeStreamElement.MessageStart:
break;
case FudgeStreamElement.MessageEnd:
return(new FudgeListWrapper <T>(items));
case FudgeStreamElement.SimpleField:
if (stream.FieldName == null && stream.FieldOrdinal == 0)
{
continue;
}
throw new ArgumentException();
case FudgeStreamElement.SubmessageFieldStart:
if (stream.FieldName == "list" && stream.FieldOrdinal == null)
{
if (inList)
{
throw new ArgumentException();
}
inList = true;
}
else if (inList)
{
var deserializeStandard = DeserializeStandard <T>(context, stream, typeMap);
items.Add(deserializeStandard);
}
else
{
throw new ArgumentException();
}
break;
case FudgeStreamElement.SubmessageFieldEnd:
if (!inList)
{
throw new ArgumentException();
}
inList = false;
break;
default:
break; // Unknown
}
}
throw new ArgumentException();
}
public MessageFudgeDeserializationContext(FudgeContext context, SerializationTypeMap typeMap, IFudgeTypeMappingStrategy typeMappingStrategy, FudgeMsg msg) : base(context, typeMap, typeMappingStrategy)
{
this.msg = msg;
}
protected override IDependencyGraph Deserialize(OpenGammaFudgeContext context, IFudgeStreamReader stream, SerializationTypeMap typeMap)
{
string calcConfigName = null;
var nodes = new List <DependencyNode>();
int edgeFrom = -1;
while (stream.HasNext)
{
switch (stream.MoveNext())
{
case FudgeStreamElement.MessageStart:
break;
case FudgeStreamElement.MessageEnd:
return(new DependencyGraph(calcConfigName, nodes));
case FudgeStreamElement.SimpleField:
switch (stream.FieldName)
{
case "edge":
var int32 = Convert.ToInt32(stream.FieldValue);
if (edgeFrom < 0)
{
edgeFrom = int32;
}
else
{
int to = int32;
DependencyNode inputNode = nodes[edgeFrom];
DependencyNode dependentNode = nodes[to];
dependentNode.AddInputNode(inputNode);
edgeFrom = -1;
}
break;
case "calculationConfigurationName":
if (calcConfigName != null)
{
throw new ArgumentException();
}
calcConfigName = (string)stream.FieldValue;
break;
default:
if (stream.FieldOrdinal == 0 && stream.FieldType == StringFieldType.Instance)
{
break;
}
throw new ArgumentException();
}
break;
case FudgeStreamElement.SubmessageFieldStart:
if (stream.FieldName == "dependencyNode" && stream.FieldOrdinal == null)
{
var deserializeStandard = DeserializeStandard <DependencyNode>(context, stream, typeMap);
nodes.Add(deserializeStandard);
}
else
{
throw new ArgumentException();
}
break;
case FudgeStreamElement.SubmessageFieldEnd:
throw new ArgumentException();
default:
break; // Unknown
}
}
throw new ArgumentException();
}
