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); }