public async Task ProduceToMultiplePartitions(int numberOfPartitions, int numberOfKeys, int numberOfMessages)
{
var keySerializer = new Int32Serializer();
var valueSerializer = new StringSerializer();
var messagePartitioner = new Int32Partitioner();
using (var temporaryTopic = testCluster.CreateTemporaryTopic(partitions: 2))
using (var brokers = new KafkaBrokers(testCluster.CreateBrokerUris()))
{
var topic = temporaryTopic.Name;
{
var producer = KafkaProducer.Create(brokers, keySerializer, valueSerializer, messagePartitioner);
var messages =
Enumerable
.Range(0, numberOfMessages)
.Select(i => KeyedMessage.Create(topic, i % numberOfKeys, i % numberOfPartitions, "Message " + i));
await producer.SendAsync(messages, CancellationToken.None);
}
{
var selectors =
Enumerable
.Range(0, numberOfPartitions)
.Select(partition => new TopicSelector {
Partition = partition, Topic = topic
})
.ToArray();
var consumer = KafkaConsumer.Create(defaultConsumerGroup, brokers, keySerializer, valueSerializer, selectors);
var responses = await consumer.ReceiveAsync(CancellationToken.None);
Assert.That(responses, Has.Count.EqualTo(numberOfMessages));
var received = new bool[numberOfMessages];
var offsets = new long[numberOfPartitions];
foreach (var response in responses)
{
var split = response.Value.Split(' ');
Assert.That(split, Has.Length.EqualTo(2));
Assert.That(split[0], Is.EqualTo("Message"));
int messageNumber;
var parsed = Int32.TryParse(split[1], out messageNumber);
Assert.That(parsed, Is.True);
Assert.That(messageNumber, Is.InRange(0, numberOfMessages - 1));
var key = messageNumber % numberOfKeys;
Assert.That(response.Key, Is.EqualTo(key));
var partition = messageNumber % numberOfPartitions;
Assert.That(response.Partition, Is.EqualTo(partition));
Assert.That(received[messageNumber], Is.False);
received[messageNumber] = true;
Assert.That(response.Offset, Is.EqualTo(offsets[response.Partition]));
offsets[response.Partition] += 1;
Assert.That(response.Topic, Is.EqualTo(topic));
}
}
}
}
public override ValueSerializer BuildSerializer(Serializer serializer, Type type,
ConcurrentDictionary <Type, ValueSerializer> typeMapping)
{
var preserveObjectReferences = serializer.Options.PreserveObjectReferences;
var ser = new ObjectSerializer(type);
typeMapping.TryAdd(type, ser);
var elementSerializer = serializer.GetSerializerByType(typeof(DictionaryEntry));
ObjectReader reader = (stream, session) =>
{
throw new NotSupportedException("Generic IDictionary<TKey,TValue> are not yet supported");
#pragma warning disable CS0162 // Unreachable code detected
var instance = Activator.CreateInstance(type);
#pragma warning restore CS0162 // Unreachable code detected
if (preserveObjectReferences)
{
session.TrackDeserializedObject(instance);
}
var count = stream.ReadInt32(session);
var entries = new DictionaryEntry[count];
for (var i = 0; i < count; i++)
{
var entry = (DictionaryEntry)stream.ReadObject(session);
entries[i] = entry;
}
//TODO: populate dictionary
return(instance);
};
ObjectWriter writer = (stream, obj, session) =>
{
if (preserveObjectReferences)
{
session.TrackSerializedObject(obj);
}
var dict = obj as IDictionary;
/*
* if (dict == null)
* {
* Console.ForegroundColor = ConsoleColor.Yellow;
* Console.WriteLine(obj.GetType().FullName);
* return;
* }
* //*/
// ReSharper disable once PossibleNullReferenceException
Int32Serializer.WriteValueImpl(stream, dict.Count, session);
foreach (var item in dict)
{
stream.WriteObject(item, typeof(DictionaryEntry), elementSerializer,
serializer.Options.PreserveObjectReferences, session);
// elementSerializer.WriteValue(stream,item,session);
}
};
ser.Initialize(reader, writer);
return(ser);
}
public void TestReset()
{
var classMap = new BsonClassMap <TestClass>(cm =>
{
var mm = cm.MapMember(c => c.Property);
});
var originalSerializer = new Int32Serializer();
var memberMap = classMap.GetMemberMap(x => x.Property);
memberMap.SetDefaultValue(42);
memberMap.SetElementName("oops");
memberMap.SetIdGenerator(new GuidGenerator());
memberMap.SetIgnoreIfDefault(true);
memberMap.SetIsRequired(true);
memberMap.SetOrder(21);
memberMap.SetSerializer(originalSerializer);
memberMap.SetShouldSerializeMethod(o => false);
memberMap.Reset();
Assert.AreEqual(0, (int)memberMap.DefaultValue);
Assert.AreEqual("Property", memberMap.ElementName);
Assert.IsNull(memberMap.IdGenerator);
Assert.IsFalse(memberMap.IgnoreIfDefault);
Assert.IsFalse(memberMap.IgnoreIfNull);
Assert.IsFalse(memberMap.IsRequired);
Assert.AreEqual(int.MaxValue, memberMap.Order);
Assert.AreNotSame(originalSerializer, memberMap.GetSerializer());
Assert.IsNull(memberMap.ShouldSerializeMethod);
}
public void Pack(Packer packer, object obj)
{
var buffer = (ME.ECS.Collections.IBufferArray)obj;
var arr = buffer.GetArray();
if (arr == null)
{
packer.WriteByte((byte)TypeValue.Null);
var int32 = new Int32Serializer();
int32.Pack(packer, packer.GetMetaTypeId(obj.GetType().GenericTypeArguments[0]));
}
else
{
packer.WriteByte((byte)TypeValue.ObjectArray);
var length = buffer.Count;
var int32 = new Int32Serializer();
int32.Pack(packer, length);
int32.Pack(packer, packer.GetMetaTypeId(arr.GetType().GetElementType()));
for (var i = 0; i < length; ++i)
{
packer.PackInternal(arr.GetValue(i));
}
}
}
public void SerializeThrowsWhenBufferIsWrongSize(int badSize)
{
Int32Serializer serializer = new Int32Serializer();
Assert.ThrowsException <ArgumentException>(() => {
serializer.Serialize(0, new byte[badSize]);
});
}
public void SerializeThrowsWhenBufferIsNull()
{
Int32Serializer serializer = new Int32Serializer();
Assert.ThrowsException <ArgumentNullException>(() => {
serializer.Serialize(0, null);
});
}
public async Task ProduceToMultiplePartitions(int numberOfPartitions, int numberOfKeys, int numberOfMessages)
{
var keySerializer = new Int32Serializer();
var valueSerializer = new StringSerializer();
var messagePartitioner = new Int32Partitioner();
using (var temporaryTopic = testCluster.CreateTemporaryTopic(partitions: 2))
using (var brokers = new KafkaBrokers(testCluster.CreateBrokerUris()))
{
var topic = temporaryTopic.Name;
{
var producer = KafkaProducer.Create(brokers, keySerializer, valueSerializer, messagePartitioner);
var messages =
Enumerable
.Range(0, numberOfMessages)
.Select(i => KeyedMessage.Create(topic, i % numberOfKeys, i % numberOfPartitions, "Message " + i));
await producer.SendAsync(messages, CancellationToken.None);
}
{
var selectors =
Enumerable
.Range(0, numberOfPartitions)
.Select(partition => new TopicSelector { Partition = partition, Topic = topic })
.ToArray();
var consumer = KafkaConsumer.Create(defaultConsumerGroup, brokers, keySerializer, valueSerializer, selectors);
var responses = await consumer.ReceiveAsync(CancellationToken.None);
Assert.That(responses, Has.Count.EqualTo(numberOfMessages));
var received = new bool[numberOfMessages];
var offsets = new long[numberOfPartitions];
foreach (var response in responses)
{
var split = response.Value.Split(' ');
Assert.That(split, Has.Length.EqualTo(2));
Assert.That(split[0], Is.EqualTo("Message"));
int messageNumber;
var parsed = Int32.TryParse(split[1], out messageNumber);
Assert.That(parsed, Is.True);
Assert.That(messageNumber, Is.InRange(0, numberOfMessages - 1));
var key = messageNumber % numberOfKeys;
Assert.That(response.Key, Is.EqualTo(key));
var partition = messageNumber % numberOfPartitions;
Assert.That(response.Partition, Is.EqualTo(partition));
Assert.That(received[messageNumber], Is.False);
received[messageNumber] = true;
Assert.That(response.Offset, Is.EqualTo(offsets[response.Partition]));
offsets[response.Partition] += 1;
Assert.That(response.Topic, Is.EqualTo(topic));
}
}
}
}
public void SerializeThenDeserializeWorks(bool littleEndian)
{
int[] numbers = new int[] {
int.MinValue,
int.MinValue + 1,
int.MinValue + 2,
int.MinValue + 3,
int.MinValue / 2,
-65537,
-65536,
-65535,
-65534,
-257,
-256,
-255,
-254
- 126,
-127,
-128
- 5,
-4,
-3,
-2,
-1,
0,
int.MaxValue,
int.MaxValue - 1,
int.MaxValue - 2,
int.MaxValue - 3,
int.MaxValue / 2,
65537,
65536,
65535,
65534,
257,
256,
255,
254,
126,
127,
128,
5,
4,
3,
2,
1,
};
Int32Serializer serializer = new Int32Serializer(littleEndian);
for (int i = 0; i < numbers.Length; i++)
{
byte[] buffer = new byte[serializer.DataSize];
serializer.Serialize(numbers[i], buffer);
Assert.AreEqual(numbers[i], serializer.Deserialize(buffer));
}
}
public void SerializeAndDeserializeToTheSameObject(int originalValue)
{
Serializer <int> serializer = new Int32Serializer();
byte[] serializedValue = serializer.Serialize(originalValue);
int deserializedValue = serializer.Deserialize(serializedValue);
Assert.Equal(originalValue, deserializedValue);
}
public TestDocumentClassSerializer()
{
var itemSerializer = new Int32Serializer(BsonType.String);
var listSerializer = new EnumerableInterfaceImplementerSerializer <List <int> >(itemSerializer);
this.RegisterMember("Id", "_id", new ObjectIdSerializer());
this.RegisterMember("Name", "name", new StringSerializer());
this.RegisterMember("Colors", "colors", listSerializer);
this.RegisterMember("Colors2", "colors2", listSerializer);
}
private static void WriteValues <T>(T[] array, Stream stream, Type elementType, ValueSerializer elementSerializer, SerializerSession session)
{
Int32Serializer.WriteValueImpl(stream, array.Length, session);
var preserveObjectReferences = session.Serializer.Options.PreserveObjectReferences;
foreach (var value in array)
{
stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session);
}
}
private static void WriteValues <T>(LinkedList <T> list, Stream stream, Type elementType, ValueSerializer elementSerializer, SerializerSession session)
{
Int32Serializer.WriteValueImpl(stream, list.Count, session);
var preserveObjectReferences = session.Serializer.Options.PreserveObjectReferences;
foreach (var value in list)
{
stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session);
}
}
public override ValueSerializer BuildSerializer(Serializer serializer, Type type,
ConcurrentDictionary <Type, ValueSerializer> typeMapping)
{
var ser = new ObjectSerializer(type);
if (serializer.Options.KnownTypesDict.TryGetValue(type, out var index))
{
var wrapper = new KnownTypeObjectSerializer(ser, index);
typeMapping.TryAdd(type, wrapper);
}
else
{
typeMapping.TryAdd(type, ser);
}
var elementSerializer = serializer.GetSerializerByType(typeof(DictionaryEntry));
var preserveObjectReferences = serializer.Options.PreserveObjectReferences;
ObjectReader reader = (stream, session) =>
{
var count = stream.ReadInt32(session);
var instance = (IDictionary)Activator.CreateInstance(type, count);
if (preserveObjectReferences)
{
session.TrackDeserializedObject(instance);
}
for (var i = 0; i < count; i++)
{
var entry = (DictionaryEntry)stream.ReadObject(session);
instance.Add(entry.Key, entry.Value);
}
return(instance);
};
ObjectWriter writer = (stream, obj, session) =>
{
if (preserveObjectReferences)
{
session.TrackSerializedObject(obj);
}
var dict = obj as IDictionary;
// ReSharper disable once PossibleNullReferenceException
Int32Serializer.WriteValueImpl(stream, dict.Count, session);
foreach (DictionaryEntry item in dict)
{
stream.WriteObject(item, typeof(DictionaryEntry), elementSerializer,
serializer.Options.PreserveObjectReferences, session);
// elementSerializer.WriteValue(stream,item,session);
}
};
ser.Initialize(reader, writer);
return(ser);
}
private static void WriteValues(Array array, Stream stream, Type elementType, ValueSerializer elementSerializer, SerializerSession session)
{
for (var i = 0; i < array.Rank; i++)
{
Int32Serializer.WriteValueImpl(stream, array.GetLength(i), session);
}
var preserveObjectReferences = session.Serializer.Options.PreserveObjectReferences;
foreach (var value in array)
{
stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session);
}
}
private static bool TryTranslateDateTimeProperty(MemberExpression expression, AggregationExpression container, MemberInfo memberInfo, out AggregationExpression result)
{
result = null;
if (container.Expression.Type == typeof(DateTime) && memberInfo is PropertyInfo propertyInfo)
{
AstExpression ast;
IBsonSerializer serializer;
if (propertyInfo.Name == "DayOfWeek")
{
ast = AstExpression.Subtract(AstExpression.DatePart(AstDatePart.DayOfWeek, container.Ast), 1);
serializer = new EnumSerializer <DayOfWeek>(BsonType.Int32);
}
else
{
AstDatePart datePart;
switch (propertyInfo.Name)
{
case "Day": datePart = AstDatePart.DayOfMonth; break;
case "DayOfWeek": datePart = AstDatePart.DayOfWeek; break;
case "DayOfYear": datePart = AstDatePart.DayOfYear; break;
case "Hour": datePart = AstDatePart.Hour; break;
case "Millisecond": datePart = AstDatePart.Millisecond; break;
case "Minute": datePart = AstDatePart.Minute; break;
case "Month": datePart = AstDatePart.Month; break;
case "Second": datePart = AstDatePart.Second; break;
case "Week": datePart = AstDatePart.Week; break;
case "Year": datePart = AstDatePart.Year; break;
default: return(false);
}
ast = AstExpression.DatePart(datePart, container.Ast);
serializer = new Int32Serializer();
}
result = new AggregationExpression(expression, ast, serializer);
return(true);
}
return(false);
}
private static void WriteValues <T>(T[] array, Stream stream, Type elementType, ValueSerializer elementSerializer,
SerializerSession session, bool preserveObjectReferences)
{
if (preserveObjectReferences)
{
session.TrackSerializedObject(array);
}
Int32Serializer.WriteValueImpl(stream, array.Length, session);
foreach (var value in array)
{
stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session);
}
}
private static void WriteValues <T>(LinkedList <T> llist, Stream stream, Type elementType, ValueSerializer elementSerializer,
SerializerSession session, bool preserveObjectReferences)
{
if (preserveObjectReferences)
{
session.TrackSerializedObject(llist);
}
Int32Serializer.WriteValueImpl(stream, llist.Count, session);
foreach (var value in llist)
{
stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session);
}
}
public override ValueSerializer BuildSerializer(Serializer serializer, Type type,
ConcurrentDictionary <Type, ValueSerializer> typeMapping)
{
var preserveObjectReferences = serializer.Options.PreserveObjectReferences;
var ser = new ObjectSerializer(type);
typeMapping.TryAdd(type, ser);
var elementSerializer = serializer.GetSerializerByType(typeof(DictionaryEntry));
object Reader(Stream stream, DeserializerSession session)
{
var instance = (IDictionary <string, object>)Activator.CreateInstance(type) !;
if (preserveObjectReferences)
{
session.TrackDeserializedObject(instance);
}
var count = stream.ReadInt32(session);
for (var i = 0; i < count; i++)
{
var entry = (KeyValuePair <string, object>)stream.ReadObject(session);
instance.Add(entry);
}
return(instance);
}
void Writer(Stream stream, object obj, SerializerSession session)
{
if (preserveObjectReferences)
{
session.TrackSerializedObject(obj);
}
var dict = (IDictionary <string, object>)obj;
// ReSharper disable once PossibleNullReferenceException
Int32Serializer.WriteValueImpl(stream, dict.Count, session);
foreach (var item in dict)
{
stream.WriteObject(item, typeof(DictionaryEntry), elementSerializer,
serializer.Options.PreserveObjectReferences, session);
}
// elementSerializer.WriteValue(stream,item,session);
}
ser.Initialize(Reader, Writer);
return(ser);
}
private static void WriteHashSet <T>(HashSet <T> set, Stream stream, SerializerSession session, Type elementType,
ValueSerializer elementSerializer, bool preserveObjectReferences)
{
if (preserveObjectReferences)
{
session.TrackSerializedObject(set);
}
// ReSharper disable once PossibleNullReferenceException
Int32Serializer.WriteValueImpl(stream, set.Count, session);
foreach (var item in set)
{
stream.WriteObject(item, elementType, elementSerializer, preserveObjectReferences, session);
}
}
public object Unpack(Packer packer)
{
int arrayTypeId = -1;
int typeId = -1;
object p1 = null;
object p2 = null;
var type = packer.ReadByte();
if (type == (byte)TypeValue.Null)
{
var int32 = new Int32Serializer();
arrayTypeId = (int)int32.Unpack(packer);
typeId = (int)int32.Unpack(packer);
p1 = null;
p2 = 0;
}
else
{
var int32 = new Int32Serializer();
arrayTypeId = (int)int32.Unpack(packer);
var length = (int)int32.Unpack(packer);
typeId = (int)int32.Unpack(packer);
var elementType = packer.GetMetaType(typeId);
var poolArrayType = typeof(PoolArray <>).MakeGenericType(elementType);
var spawnMethod = poolArrayType.GetMethod("Spawn", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
var bufferArray = (ME.ECS.Collections.IBufferArray)spawnMethod.Invoke(null, new object[] { length, false });
var arr = bufferArray.GetArray();
for (var i = 0; i < length; ++i)
{
arr.SetValue(packer.UnpackInternal(), i);
}
p1 = arr;
p2 = length;
}
var arrayType = packer.GetMetaType(arrayTypeId);
var constructedType = arrayType.MakeGenericType(packer.GetMetaType(typeId));
var instance = (ME.ECS.Collections.IBufferArray)System.Activator.CreateInstance(constructedType,
System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic,
null, new object[] {
p1, p2, -1,
}, System.Globalization.CultureInfo.InvariantCulture);
return(instance);
}
public async Task ProduceToTwoPartitions()
{
var keySerializer = new Int32Serializer();
var valueSerializer = new StringSerializer();
var messagePartitioner = new Int32Partitioner();
using (var temporaryTopic = testCluster.CreateTemporaryTopic(partitions: 2))
using (var brokers = new KafkaBrokers(testCluster.CreateBrokerUris()))
{
var topic = temporaryTopic.Name;
var producer = KafkaProducer.Create(brokers, keySerializer, valueSerializer, messagePartitioner);
var consumers = new[] {
KafkaConsumer.Create(defaultConsumerGroup, brokers, keySerializer, valueSerializer,
new TopicSelector {
Partition = 0, Topic = topic
}),
KafkaConsumer.Create(defaultConsumerGroup, brokers, keySerializer, valueSerializer,
new TopicSelector {
Partition = 1, Topic = topic
})
};
await producer.SendAsync(new[] {
KeyedMessage.Create(topic, 0, "Message to partition 0"),
KeyedMessage.Create(topic, 1, "Message to partition 1")
}, CancellationToken.None);
for (var i = 0; i < consumers.Length; i++)
{
var responses = await consumers[i].ReceiveAsync(CancellationToken.None);
Assert.That(responses, Is.Not.Null);
Assert.That(responses, Has.Count.EqualTo(1));
var first = responses.First();
Assert.That(first.Offset, Is.EqualTo(0));
Assert.That(first.Partition, Is.EqualTo(i));
Assert.That(first.Key, Is.EqualTo(i));
Assert.That(first.Topic, Is.EqualTo(topic));
Assert.That(first.Value, Is.EqualTo("Message to partition " + i));
}
}
}
public object Unpack(Packer packer)
{
int typeId = -1;
object p1 = null;
object p2 = null;
var type = packer.ReadByte();
if (type == (byte)TypeValue.Null)
{
var int32 = new Int32Serializer();
typeId = (int)int32.Unpack(packer);
p1 = null;
p2 = 0;
}
else
{
var int32 = new Int32Serializer();
var length = (int)int32.Unpack(packer);
typeId = (int)int32.Unpack(packer);
var elementType = packer.GetMetaType(typeId);
var arr = System.Array.CreateInstance(elementType, PoolArrayUtilities.GetArrayLengthPot(length));
for (var i = 0; i < length; ++i)
{
arr.SetValue(packer.UnpackInternal(), i);
}
p1 = arr;
p2 = length;
}
var constructedType = typeof(ME.ECS.Collections.BufferArray <>).MakeGenericType(packer.GetMetaType(typeId));
var instance = (ME.ECS.Collections.IBufferArray)System.Activator.CreateInstance(constructedType,
System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic,
null, new object[] {
p1, p2
}, System.Globalization.CultureInfo.InvariantCulture);
return(instance);
}
public WKTSerializers(ISerializerStorage serializerStorage, IValueTypeObjectsDictionary objectCache)
{
Boolean = new BooleanSerializer(serializerStorage);
Byte = new ByteSerializer(serializerStorage);
Char = new CharSerializer(serializerStorage);
DateTime = new DateTimeSerializer(serializerStorage);
DateTimeOffset = new DateTimeOffsetSerializer(serializerStorage);
Decimal = new DecimalSerializer(serializerStorage);
Double = new DoubleSerializer(serializerStorage);
Guid = new GuidSerializer(serializerStorage);
Int16 = new Int16Serializer(serializerStorage);
Int32 = new Int32Serializer(serializerStorage);
Int64 = new Int64Serializer(serializerStorage);
Object = new ObjectSerializer(serializerStorage);
SByte = new SByteSerializer(serializerStorage);
Single = new SingleSerializer(serializerStorage);
String = new StringSerializer(serializerStorage, objectCache);
TimeSpan = new TimeSpanSerializer(serializerStorage);
UInt16 = new UInt16Serializer(serializerStorage);
UInt32 = new UInt32Serializer(serializerStorage);
}
public async Task ProduceToTwoPartitions()
{
var keySerializer = new Int32Serializer();
var valueSerializer = new StringSerializer();
var messagePartitioner = new Int32Partitioner();
using (var temporaryTopic = testCluster.CreateTemporaryTopic(partitions:2))
using (var brokers = new KafkaBrokers(testCluster.CreateBrokerUris()))
{
var topic = temporaryTopic.Name;
var producer = KafkaProducer.Create(brokers, keySerializer, valueSerializer, messagePartitioner);
var consumers = new[] {
KafkaConsumer.Create(defaultConsumerGroup, brokers, keySerializer, valueSerializer,
new TopicSelector { Partition = 0, Topic = topic }),
KafkaConsumer.Create(defaultConsumerGroup, brokers, keySerializer, valueSerializer,
new TopicSelector { Partition = 1, Topic = topic })
};
await producer.SendAsync(new[] {
KeyedMessage.Create(topic, 0, "Message to partition 0"),
KeyedMessage.Create(topic, 1, "Message to partition 1")
}, CancellationToken.None);
for (var i = 0; i < consumers.Length; i++)
{
var responses = await consumers[i].ReceiveAsync(CancellationToken.None);
Assert.That(responses, Is.Not.Null);
Assert.That(responses, Has.Count.EqualTo(1));
var first = responses.First();
Assert.That(first.Offset, Is.EqualTo(0));
Assert.That(first.Partition, Is.EqualTo(i));
Assert.That(first.Key, Is.EqualTo(i));
Assert.That(first.Topic, Is.EqualTo(topic));
Assert.That(first.Value, Is.EqualTo("Message to partition " + i));
}
}
}
public override ValueSerializer BuildSerializer(Serializer serializer, Type type,
ConcurrentDictionary <Type, ValueSerializer> typeMapping)
{
var x = new ObjectSerializer(serializer.Options.FieldSelector, type);
typeMapping.TryAdd(type, x);
var preserveObjectReferences = serializer.Options.PreserveObjectReferences;
var elementType = GetEnumerableType(type) ?? typeof(object);
var elementSerializer = serializer.GetSerializerByType(elementType);
var typeName = type.Name;
var genericSufixIdx = typeName.IndexOf('`');
typeName = genericSufixIdx != -1 ? typeName.Substring(0, genericSufixIdx) : typeName;
var creatorType =
Type.GetType(
ImmutableCollectionsNamespace + "." + typeName + ", " + ImmutableCollectionsAssembly, true);
var genericTypes = elementType.IsGenericType()
? elementType.GetGenericArguments()
: new[] { elementType };
var createRange = creatorType.GetMethods(BindingFlags.Public | BindingFlags.Static)
.First(methodInfo => methodInfo.Name == "CreateRange" && methodInfo.GetParameters().Length == 1)
.MakeGenericMethod(genericTypes);
ObjectWriter writer = (stream, o, session) =>
{
var enumerable = o as ICollection;
if (enumerable == null)
{
// object can be IEnumerable but not ICollection i.e. ImmutableQueue
var e = (IEnumerable)o;
var list = e.Cast <object>().ToList(); //
enumerable = list;
}
Int32Serializer.WriteValueImpl(stream, enumerable.Count, session);
foreach (var value in enumerable)
{
stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session);
}
if (preserveObjectReferences)
{
session.TrackSerializedObject(o);
}
};
ObjectReader reader = (stream, session) =>
{
var count = stream.ReadInt32(session);
var items = Array.CreateInstance(elementType, count);
for (var i = 0; i < count; i++)
{
var value = stream.ReadObject(session);
items.SetValue(value, i);
}
var instance = createRange.Invoke(null, new object[] { items });
if (preserveObjectReferences)
{
session.TrackDeserializedObject(instance);
}
return(instance);
};
x.Initialize(reader, writer);
return(x);
}
public override ValueSerializer BuildSerializer(Serializer serializer, Type type,
ConcurrentDictionary <Type, ValueSerializer> typeMapping)
{
var x = new ObjectSerializer(type);
typeMapping.TryAdd(type, x);
var preserveObjectReferences = serializer.Options.PreserveObjectReferences;
var elementType = GetEnumerableType(type) ?? typeof(object);
var elementSerializer = serializer.GetSerializerByType(elementType);
var typeName = type.Name;
var genericSufixIdx = typeName.IndexOf('`');
typeName = genericSufixIdx != -1 ? typeName.Substring(0, genericSufixIdx) : typeName;
var creatorType =
Type.GetType(ImmutableCollectionsNamespace + "." + typeName + ", " + ImmutableCollectionsAssembly);
var genericTypes = elementType.GetTypeInfo().IsGenericType
? elementType.GetTypeInfo().GetGenericArguments()
: new[] { elementType };
// if creatorType == null it means that type is probably an interface
// we propagate null to create mock serializer - it won't be used anyway
var stackTypeDef = Type.GetType(ImmutableCollectionsNamespace + ".IImmutableStack`1, " + ImmutableCollectionsAssembly, true);
var stackInterface = stackTypeDef.MakeGenericType(genericTypes[0]);
var isStack = stackInterface.IsAssignableFrom(type);
var createRange = creatorType != null
? creatorType.GetTypeInfo().GetMethods(BindingFlags.Public | BindingFlags.Static)
.First(methodInfo => methodInfo.Name == "CreateRange" && methodInfo.GetParameters().Length == 1)
.MakeGenericMethod(genericTypes)
: null;
ObjectWriter writer = (stream, o, session) =>
{
var enumerable = o as ICollection;
if (enumerable == null)
{
// object can be IEnumerable but not ICollection i.e. ImmutableQueue
var e = (IEnumerable)o;
var list = e.Cast <object>().ToList();//
enumerable = list;
}
Int32Serializer.WriteValueImpl(stream, enumerable.Count, session);
foreach (var value in enumerable)
{
stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session);
}
if (preserveObjectReferences)
{
session.TrackSerializedObject(o);
}
};
ObjectReader reader;
if (isStack)
{
// if we are dealing with stack, we need to apply arguments in reverse order
reader = (stream, session) =>
{
var count = stream.ReadInt32(session);
var items = Array.CreateInstance(elementType, count);
for (var i = 0; i < count; i++)
{
var value = stream.ReadObject(session);
items.SetValue(value, count - i - 1);
}
var instance = createRange.Invoke(null, new object[] { items });
if (preserveObjectReferences)
{
session.TrackDeserializedObject(instance);
}
return(instance);
};
}
else
{
reader = (stream, session) =>
{
var count = stream.ReadInt32(session);
var items = Array.CreateInstance(elementType, count);
for (var i = 0; i < count; i++)
{
var value = stream.ReadObject(session);
items.SetValue(value, i);
}
var instance = createRange.Invoke(null, new object[] { items });
if (preserveObjectReferences)
{
session.TrackDeserializedObject(instance);
}
return(instance);
};
}
x.Initialize(reader, writer);
return(x);
}
public override ValueSerializer BuildSerializer(Serializer serializer, Type type,
ConcurrentDictionary <Type, ValueSerializer> typeMapping)
{
var x = new ObjectSerializer(type);
typeMapping.TryAdd(type, x);
var preserveObjectReferences = serializer.Options.PreserveObjectReferences;
var elementType = GetEnumerableType(type) ?? typeof(object);
var elementSerializer = serializer.GetSerializerByType(elementType);
var countProperty = type.GetTypeInfo().GetProperty("Count");
var addMethod = type.GetTypeInfo().GetMethod("Add", BindingFlagsEx.All);
var enumerableConstructor = GetEnumerableConstructor(type);
Func <object, int> countGetter = o => (int)countProperty.GetValue(o);
ObjectReader reader = null;
if (HasParameterlessConstructor(type) && addMethod != null)
{
var add = CompileMethodToDelegate(addMethod, type, elementType);
reader = (stream, session) =>
{
var instance = Activator.CreateInstance(type, true);
if (preserveObjectReferences)
{
session.TrackDeserializedObject(instance);
}
var count = stream.ReadInt32(session);
for (var i = 0; i < count; i++)
{
var value = stream.ReadObject(session);
add(instance, value);
}
return(instance);
};
}
else if (enumerableConstructor != null)
{
var construct = CompileCtorToDelegate(enumerableConstructor, elementType.MakeArrayType());
reader = (stream, session) =>
{
var count = stream.ReadInt32(session);
var items = Array.CreateInstance(elementType, count);
for (var i = 0; i < count; i++)
{
var value = stream.ReadObject(session);
items.SetValue(value, i);
}
var instance = construct(items);
if (preserveObjectReferences)
{
session.TrackDeserializedObject(instance);
}
return(instance);
};
}
ObjectWriter writer = (stream, o, session) =>
{
if (preserveObjectReferences)
{
session.TrackSerializedObject(o);
}
Int32Serializer.WriteValueImpl(stream, countGetter(o), session);
var enumerable = o as IEnumerable;
// ReSharper disable once PossibleNullReferenceException
foreach (var value in enumerable)
{
stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session);
}
};
x.Initialize(reader, writer);
return(x);
}
public static void WriteLengthEncodedByteArray(this Stream self, byte[] bytes, SerializerSession session)
{
Int32Serializer.WriteValueImpl(self, bytes.Length, session);
self.Write(bytes, 0, bytes.Length);
}
public override ValueSerializer BuildSerializer(Serializer serializer, Type type,
CachedReadConcurrentDictionary <Type, ValueSerializer> typeMapping)
{
var preserveObjectReferences = serializer.Options.PreserveObjectReferences;
var ser = new ObjectSerializer(type);
typeMapping.TryAdd(type, ser);
var dictionaryTypes = GetKeyValuePairType(type);
var elementSerializer = serializer.GetSerializerByType(dictionaryTypes.KeyValuePairType);
ObjectReader reader = (stream, session) =>
{
object instance;
try
{
instance = Activator.CreateInstance(type, true); // IDictionary<TKey, TValue>
}
catch (Exception)
{
instance = Activator.CreateInstance(type); // IDictionary<TKey, TValue>
}
if (preserveObjectReferences)
{
session.TrackDeserializedObject(instance);
}
var count = stream.ReadInt32(session);
for (var i = 0; i < count; i++)
{
var entry = stream.ReadObject(session); // KeyValuePair<TKey, TValue>
// Get entry.Key and entry.Value
var key = dictionaryTypes.KeyValuePairType.GetProperty(nameof(KeyValuePair <object, object> .Key)).GetValue(entry, null);
var value = dictionaryTypes.KeyValuePairType.GetProperty(nameof(KeyValuePair <object, object> .Value)).GetValue(entry, null);
// Same as: instance.Add(key, value)
dictionaryTypes.DictionaryInterfaceType
.GetMethod(nameof(IDictionary <object, object> .Add), new[] { dictionaryTypes.KeyType, dictionaryTypes.ValueType })
.Invoke(instance, new[] { key, value });
}
return(instance);
};
void writer(System.IO.Stream stream, object obj, SerializerSession session)
{
if (preserveObjectReferences)
{
session.TrackSerializedObject(obj);
}
var dict = obj as IEnumerable; // IDictionary<T, V> is IEnumerable<KeyValuePair<T, V>>
var count = dict.Cast <object>().Count();
// ReSharper disable once PossibleNullReferenceException
Int32Serializer.WriteValueImpl(stream, count, session);
foreach (var item in dict)
{
stream.WriteObject(item, dictionaryTypes.KeyValuePairType, elementSerializer, serializer.Options.PreserveObjectReferences, session);
}
}
ser.Initialize(reader, writer);
return(ser);
}
public override ValueSerializer BuildSerializer(Serializer serializer, Type type,
ConcurrentDictionary <Type, ValueSerializer> typeMapping)
{
var x = new ObjectSerializer(type);
typeMapping.TryAdd(type, x);
var preserveObjectReferences = serializer.Options.PreserveObjectReferences;
var elementType = GetEnumerableType(type) ?? typeof(object);
var elementSerializer = serializer.GetSerializerByType(elementType);
var countProperty = type.GetTypeInfo().GetProperty("Count");
var addRange = type.GetTypeInfo().GetMethod("AddRange");
var add = type.GetTypeInfo().GetMethod("Add");
Func <object, int> countGetter = o => (int)countProperty.GetValue(o);
ObjectReader reader = (stream, session) =>
{
var instance = Activator.CreateInstance(type);
if (preserveObjectReferences)
{
session.TrackDeserializedObject(instance);
}
var count = stream.ReadInt32(session);
if (addRange != null)
{
var items = Array.CreateInstance(elementType, count);
for (var i = 0; i < count; i++)
{
var value = stream.ReadObject(session);
items.SetValue(value, i);
}
//HACK: this needs to be fixed, codegenerated or whatever
addRange.Invoke(instance, new object[] { items });
return(instance);
}
if (add != null)
{
for (var i = 0; i < count; i++)
{
var value = stream.ReadObject(session);
add.Invoke(instance, new[] { value });
}
}
return(instance);
};
ObjectWriter writer = (stream, o, session) =>
{
if (preserveObjectReferences)
{
session.TrackSerializedObject(o);
}
Int32Serializer.WriteValueImpl(stream, countGetter(o), session);
var enumerable = o as IEnumerable;
// ReSharper disable once PossibleNullReferenceException
foreach (var value in enumerable)
{
stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session);
}
};
x.Initialize(reader, writer);
return(x);
}
public void ConstructorWorks(bool littleEndian)
{
Int32Serializer serializer = new Int32Serializer(littleEndian);
Assert.AreEqual(littleEndian, serializer.StoreAsLittleEndian);
}
public void ShouldThrowIfDeserializingLessThanFourBytes(byte[] data)
{
Serializer <int> serializer = new Int32Serializer();
Assert.Throws <ArgumentOutOfRangeException>(() => serializer.Deserialize(data));
}
