public ListCodec(IFieldCodec <T> fieldCodec, IFieldCodec <int> intCodec, IUntypedCodecProvider codecProvider, ListActivator <T> activator)
{
this.fieldCodec = fieldCodec;
this.intCodec = intCodec;
this.codecProvider = codecProvider;
this.activator = activator;
}
public SubTypeSerializer(IPartialSerializer <BaseType> baseTypeSerializer, IFieldCodec <string> stringCodec, IFieldCodec <int> intCodec, IFieldCodec <object> objectCodec)
{
_baseTypeSerializer = HagarGeneratedCodeHelper.UnwrapService(this, baseTypeSerializer);
_stringCodec = HagarGeneratedCodeHelper.UnwrapService(this, stringCodec);
_intCodec = HagarGeneratedCodeHelper.UnwrapService(this, intCodec);
_objectCodec = HagarGeneratedCodeHelper.UnwrapService(this, objectCodec);
}
public ManualVersionToleranceTests(ITestOutputHelper log)
{
_log = log;
var serviceCollection = new ServiceCollection();
_serviceCollection = serviceCollection;
_ = _serviceCollection.AddHagar(builder =>
{
_ = builder.Configure(configuration =>
{
_ = configuration.Serializers.Add(typeof(SubTypeSerializer));
_ = configuration.Serializers.Add(typeof(BaseTypeSerializer));
_ = configuration.Serializers.Add(typeof(ObjectWithNewFieldTypeSerializer));
_ = configuration.Serializers.Add(typeof(ObjectWithoutNewFieldTypeSerializer));
});
});
//serviceCollection.AddSingleton<IGeneralizedCodec, DotNetSerializableCodec>();
//serviceCollection.AddSingleton<IGeneralizedCodec, JsonCodec>();
_serviceProvider = _serviceCollection.BuildServiceProvider();
var codecProvider = _serviceProvider.GetRequiredService <CodecProvider>();
_serializer = codecProvider.GetCodec <SubType>();
_objectWithNewFieldSerializer = codecProvider.GetCodec <ObjectWithNewField>();
_objectWithoutNewFieldSerializer = codecProvider.GetCodec <ObjectWithoutNewField>();
}
static void Test <T>(Func <SerializerSession> getSession, IFieldCodec <T> serializer, T expected)
{
var session = getSession();
var pipe = new Pipe();
var writer = new Writer <PipeWriter>(pipe.Writer, session);
serializer.WriteField(ref writer, 0, typeof(T), expected);
Console.WriteLine($"Size: {writer.Position} bytes.");
Console.WriteLine($"Wrote References:\n{GetWriteReferenceTable(session)}");
pipe.Writer.FlushAsync().GetAwaiter().GetResult();
pipe.Writer.Complete();
pipe.Reader.TryRead(out var readResult);
var reader = new Reader(readResult.Buffer, getSession());
var initialHeader = reader.ReadFieldHeader();
//Console.WriteLine(initialHeader);
var actual = serializer.ReadValue(ref reader, initialHeader);
pipe.Reader.AdvanceTo(readResult.Buffer.End);
pipe.Reader.Complete();
Console.WriteLine($"Expect: {expected}\nActual: {actual}");
var references = GetReadReferenceTable(reader.Session);
Console.WriteLine($"Read references:\n{references}");
}
public DotNetSerializableCodec(
IFieldCodec <Type> typeCodec,
IFieldCodec <string> stringCodec,
IFieldCodec <object> objectCodec,
IUntypedCodecProvider untypedCodecProvider)
{
this.typeCodec = typeCodec;
this.untypedCodecProvider = untypedCodecProvider;
var entrySerializer = new SerializationEntryCodec(stringCodec, objectCodec);
var constructorFactory = new SerializationConstructorFactory();
var serializationCallbacks = new SerializationCallbacksFactory();
var formatterConverter = new FormatterConverter();
this.objectSerializer = new ObjectSerializer(
entrySerializer,
constructorFactory,
serializationCallbacks,
formatterConverter,
this.streamingContext);
this.valueTypeSerializerFactory = new ValueTypeSerializerFactory(
entrySerializer,
constructorFactory,
serializationCallbacks,
formatterConverter,
this.streamingContext);
}
public ManualVersionToleranceTests(ITestOutputHelper log)
{
_log = log;
var serviceCollection = new ServiceCollection();
_serviceCollection = serviceCollection;
_ = _serviceCollection.AddSerializer(builder =>
{
_ = builder.Configure(configuration =>
{
_ = configuration.Serializers.Add(typeof(SubTypeSerializer));
_ = configuration.Serializers.Add(typeof(BaseTypeSerializer));
_ = configuration.Serializers.Add(typeof(ObjectWithNewFieldTypeSerializer));
_ = configuration.Serializers.Add(typeof(ObjectWithoutNewFieldTypeSerializer));
// Intentionally remove the generated serializer for these type. It will be added back during tests.
configuration.Serializers.RemoveWhere(s => typeof(IFieldCodec <ObjectWithNewField>).IsAssignableFrom(s));
configuration.Serializers.RemoveWhere(s => typeof(IFieldCodec <ObjectWithoutNewField>).IsAssignableFrom(s));
});
});
_serviceProvider = _serviceCollection.BuildServiceProvider();
_codecProvider = _serviceProvider.GetRequiredService <CodecProvider>();
_serializer = _codecProvider.GetCodec <SubType>();
}
private void GetGeneratedSerializer <T>(out IFieldCodec <T> serializer)
{
var services = new ServiceCollection().AddSerializer();
var serviceProvider = services.BuildServiceProvider();
var codecProvider = serviceProvider.GetRequiredService <CodecProvider>();
serializer = codecProvider.GetCodec <T>();
}
public DictionaryCodec(
IFieldCodec <KeyValuePair <TKey, TValue> > pairCodec,
IFieldCodec <IEqualityComparer <TKey> > comparerCodec,
DictionaryActivator <TKey, TValue> activator)
{
_pairCodec = pairCodec;
_comparerCodec = comparerCodec;
_activator = activator;
}
public DictionaryCodec(
IFieldCodec <KeyValuePair <TKey, TValue> > pairCodec,
IUntypedCodecProvider codecProvider,
IFieldCodec <IEqualityComparer <TKey> > comparerCodec,
DictionaryActivator <TKey, TValue> activator)
{
this.pairCodec = pairCodec;
this.codecProvider = codecProvider;
this.comparerCodec = comparerCodec;
this.activator = activator;
}
private void SwitchToGeneratedSerializer <T>(out IFieldCodec <T> serializer)
{
_ = _serviceCollection.AddHagar(builder =>
{
_ = builder.AddAssembly(typeof(T).Assembly);
});
_serviceProvider = _serviceCollection.BuildServiceProvider();
var codecProvider = _serviceProvider.GetRequiredService <CodecProvider>();
serializer = codecProvider.GetCodec <T>();
}
static void TestSkip(Func <SerializerSession> getSession, IFieldCodec <SubType> serializer, SubType expected)
{
var session = getSession();
var writer = new Writer();
serializer.WriteField(writer, session, 0, typeof(SubType), expected);
var reader = new Reader(writer.ToBytes());
var deserializationContext = getSession();
var initialHeader = reader.ReadFieldHeader(session);
var skipCodec = new SkipFieldCodec();
skipCodec.ReadValue(reader, deserializationContext, initialHeader);
Console.WriteLine($"Skipped {reader.CurrentPosition}/{reader.Length} bytes.");
}
public ExceptionCodec(
IServiceProvider serviceProvider,
TypeConverter typeConverter,
IFieldCodec <Dictionary <object, object> > dictionaryCodec,
IDeepCopier <Dictionary <object, object> > dictionaryCopier,
IDeepCopier <Exception> exceptionCopier)
{
_streamingContext = new StreamingContext(StreamingContextStates.All);
_formatterConverter = new FormatterConverter();
var constructorFactory = new SerializationConstructorFactory();
_createConstructorDelegate = constructorFactory.GetSerializationConstructorDelegate;
_baseExceptionConstructor = _createConstructorDelegate(typeof(Exception));
_serviceProvider = serviceProvider;
_typeConverter = typeConverter;
_dictionaryCodec = dictionaryCodec;
_dictionaryCopier = dictionaryCopier;
_exceptionCopier = exceptionCopier;
}
static void TestSkip(Func <SerializerSession> getSession, IFieldCodec <SubType> serializer, SubType expected)
{
var session = getSession();
var pipe = new Pipe();
var writer = new Writer <PipeWriter>(pipe.Writer, session);
serializer.WriteField(ref writer, 0, typeof(SubType), expected);
pipe.Writer.FlushAsync().GetAwaiter().GetResult();
pipe.Writer.Complete();
pipe.Reader.TryRead(out var readResult);
var reader = new Reader(readResult.Buffer, getSession());
var initialHeader = reader.ReadFieldHeader();
var skipCodec = new SkipFieldCodec();
skipCodec.ReadValue(ref reader, initialHeader);
pipe.Reader.AdvanceTo(readResult.Buffer.End);
pipe.Reader.Complete();
Console.WriteLine($"Skipped {reader.Position} bytes.");
}
private static void Test <T>(Func <SerializerSession> getSession, IFieldCodec <T> serializer, T expected)
{
using var writerSession = getSession();
var pipe = new Pipe();
var writer = Writer.Create(pipe.Writer, writerSession);
serializer.WriteField(ref writer, 0, typeof(T), expected);
writer.Commit();
Console.WriteLine($"Size: {writer.Position} bytes.");
Console.WriteLine($"Wrote References:\n{GetWriteReferenceTable(writerSession)}");
_ = pipe.Writer.FlushAsync().AsTask().GetAwaiter().GetResult();
pipe.Writer.Complete();
_ = pipe.Reader.TryRead(out var readResult);
{
using var readerSesssion = getSession();
var reader = Reader.Create(readResult.Buffer, readerSesssion);
var result = BitStreamFormatter.Format(ref reader);
Console.WriteLine(result);
}
{
using var readerSesssion = getSession();
var reader = Reader.Create(readResult.Buffer, readerSesssion);
var initialHeader = reader.ReadFieldHeader();
Console.WriteLine("Header:");
Console.WriteLine(initialHeader.ToString());
var actual = serializer.ReadValue(ref reader, initialHeader);
pipe.Reader.AdvanceTo(readResult.Buffer.End);
pipe.Reader.Complete();
Console.WriteLine($"Expect: {expected}\nActual: {actual}");
var references = GetReadReferenceTable(reader.Session);
Console.WriteLine($"Read references:\n{references}");
}
}
public ManualVersionToleranceTests(ITestOutputHelper log)
{
this.log = log;
var serviceCollection = new ServiceCollection();
serviceCollection.AddHagar(builder =>
{
builder.Configure(configuration =>
{
configuration.Serializers.Add(typeof(SubTypeSerializer));
configuration.Serializers.Add(typeof(BaseTypeSerializer));
});
});
//serviceCollection.AddSingleton<IGeneralizedCodec, DotNetSerializableCodec>();
//serviceCollection.AddSingleton<IGeneralizedCodec, JsonCodec>();
this.serviceProvider = serviceCollection.BuildServiceProvider();
var codecProvider = this.serviceProvider.GetRequiredService <CodecProvider>();
this.serializer = codecProvider.GetCodec <SubType>();
}
public DotNetSerializableCodec(
IFieldCodec <Type> typeCodec)
{
this.typeCodec = typeCodec;
var entrySerializer = new SerializationEntryCodec();
var constructorFactory = new SerializationConstructorFactory();
var serializationCallbacks = new SerializationCallbacksFactory();
var formatterConverter = new FormatterConverter();
this.objectSerializer = new ObjectSerializer(
entrySerializer,
constructorFactory,
serializationCallbacks,
formatterConverter,
this.streamingContext);
this.valueTypeSerializerFactory = new ValueTypeSerializerFactory(
entrySerializer,
constructorFactory,
serializationCallbacks,
formatterConverter,
this.streamingContext);
}
static void Test <T>(Func <SerializerSession> getSession, IFieldCodec <T> serializer, T expected)
{
var session = getSession();
var writer = new Writer();
serializer.WriteField(writer, session, 0, typeof(T), expected);
Console.WriteLine($"Size: {writer.CurrentOffset} bytes.");
Console.WriteLine($"Wrote References:\n{GetWriteReferenceTable(session)}");
//Console.WriteLine("TokenStream: " + string.Join(" ", TokenStreamParser.Parse(new Reader(writer.ToBytes()), getSession())));
var reader = new Reader(writer.ToBytes());
var deserializationContext = getSession();
var initialHeader = reader.ReadFieldHeader(session);
//Console.WriteLine(initialHeader);
var actual = serializer.ReadValue(reader, deserializationContext, initialHeader);
Console.WriteLine($"Expect: {expected}\nActual: {actual}");
var references = GetReadReferenceTable(deserializationContext);
Console.WriteLine($"Read references:\n{references}");
}
/// <summary>
/// Initializes a new instance of the <see cref="MultiDimensionalArrayCodec{T}"/> class.
/// </summary>
/// <param name="intArrayCodec">The int array codec.</param>
/// <param name="elementCodec">The element codec.</param>
public MultiDimensionalArrayCodec(IFieldCodec <int[]> intArrayCodec, IFieldCodec <T> elementCodec)
{
_intArrayCodec = OrleansGeneratedCodeHelper.UnwrapService(this, intArrayCodec);
_elementCodec = OrleansGeneratedCodeHelper.UnwrapService(this, elementCodec);
}
public ListCodec(IFieldCodec <T> fieldCodec, ListActivator <T> activator)
{
this.fieldCodec = HagarGeneratedCodeHelper.UnwrapService(this, fieldCodec);
this.activator = activator;
}
public MultiDimensionalArrayCodec(IFieldCodec <int[]> intArrayCodec, IFieldCodec <T> elementCodec)
{
this.intArrayCodec = HagarGeneratedCodeHelper.UnwrapService(this, intArrayCodec);
this.elementCodec = HagarGeneratedCodeHelper.UnwrapService(this, elementCodec);
}
public UntypedCodecWrapper(IFieldCodec <object> codec)
{
_codec = codec;
}
/// <summary> /// Converts an untyped codec into a strongly-typed codec. /// </summary> public static IFieldCodec <TField> CreateTypedFromUntyped <TField>(IFieldCodec <object> untypedCodec) => new UntypedCodecWrapper <TField>(untypedCodec);
public ArrayCodec(IFieldCodec <T> fieldCodec)
{
this.fieldCodec = HagarGeneratedCodeHelper.UnwrapService(this, fieldCodec);
}
public QueueCodec(IFieldCodec <T> fieldCodec)
{
_fieldCodec = HagarGeneratedCodeHelper.UnwrapService(this, fieldCodec);
}
public Serializer(ITypedCodecProvider codecProvider)
{
this.expectedType = typeof(T);
this.codec = HagarGeneratedCodeHelper.UnwrapService(null, codecProvider.GetCodec <T>());
}
/// <summary>
/// Initializes a new instance of the <see cref="ListCodec{T}"/> class.
/// </summary>
/// <param name="fieldCodec">The field codec.</param>
/// <param name="activator">The activator.</param>
public ListCodec(IFieldCodec <T> fieldCodec, ListActivator <T> activator)
{
_fieldCodec = OrleansGeneratedCodeHelper.UnwrapService(this, fieldCodec);
_activator = activator;
}
public BaseTypeSerializer(IFieldCodec <string> stringCodec)
{
this.stringCodec = stringCodec;
}
public Serializer(ITypedCodecProvider codecProvider)
{
this.CodecProvider = codecProvider;
this.codec = codecProvider.GetCodec <T>();
}
public KeyValuePairCodec(IFieldCodec <TKey> keyCodec, IFieldCodec <TValue> valueCodec)
{
_keyCodec = HagarGeneratedCodeHelper.UnwrapService(this, keyCodec);
_valueCodec = HagarGeneratedCodeHelper.UnwrapService(this, valueCodec);
}
public TupleCodec(IFieldCodec <T> valueCodec)
{
_valueCodec = HagarGeneratedCodeHelper.UnwrapService(this, valueCodec);
}
