/// <summary>
/// Instantiate a new LZ4 codec handler.
/// </summary>
/// <param name="blockSize">Block size to compress against.</param>
/// <param name="highCompression">Whether to use high compression mode.</param>
/// <param name="memoryStreamManager">RecyclableMemoryStreamManager to allocate buffers from.</param>
/// <param name="codecProvider">Which codec provider to use.</param>
public LZ4Codec(int blockSize, bool highCompression, RecyclableMemoryStreamManager memoryStreamManager,
CodecProvider codecProvider)
{
if (blockSize < 1 << 12 || blockSize > 1 << 28)
{
throw new ArgumentOutOfRangeException(nameof(blockSize),
"Block size must be between 4KB and 256MB inclusive.");
}
if (memoryStreamManager == null)
{
throw new ArgumentNullException(nameof(memoryStreamManager));
}
switch (codecProvider)
{
case CodecProvider.LZ4Net:
this.provider = new LZ4NetCodecProvider();
break;
default:
throw new ArgumentOutOfRangeException(nameof(codecProvider));
}
this.BlockSize = blockSize;
this.HighCompression = highCompression;
this.Codec = codecProvider;
this.memoryStreamManager = memoryStreamManager;
}
/// <summary>
/// Instantiate a new LZ4 codec handler.
/// </summary>
/// <param name="blockSize">Block size to compress against.</param>
/// <param name="highCompression">Whether to use high compression mode.</param>
/// <param name="memoryStreamManager">RecyclableMemoryStreamManager to allocate buffers from.</param>
/// <param name="codecProvider">Which codec provider to use.</param>
public LZ4Codec(int blockSize, bool highCompression, RecyclableMemoryStreamManager memoryStreamManager,
CodecProvider codecProvider)
{
if (blockSize < 1 << 12 || blockSize > 1 << 28)
{
throw new ArgumentOutOfRangeException(nameof(blockSize),
"Block size must be between 4KB and 256MB inclusive.");
}
if (memoryStreamManager == null)
{
throw new ArgumentNullException(nameof(memoryStreamManager));
}
switch (codecProvider)
{
case CodecProvider.LZ4Net:
this.provider = new LZ4NetCodecProvider();
break;
default:
throw new ArgumentOutOfRangeException(nameof(codecProvider));
}
this.BlockSize = blockSize;
this.HighCompression = highCompression;
this.Codec = codecProvider;
this.memoryStreamManager = memoryStreamManager;
}
public SerializerSessionPoolPolicy(TypeCodec typeCodec, WellKnownTypeCollection wellKnownTypes, CodecProvider codecProvider, Action <SerializerSession> onSessionDisposed)
{
_typeCodec = typeCodec;
_wellKnownTypes = wellKnownTypes;
_codecProvider = codecProvider;
_onSessionDisposed = onSessionDisposed;
}
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>();
}
protected CopierTester()
{
var services = new ServiceCollection();
_ = services.AddSerializer(builder => builder.Configure(config => config.Copiers.Add(typeof(TCopier))));
if (!typeof(TCopier).IsAbstract && !typeof(TCopier).IsInterface)
{
_ = services.AddSingleton <TCopier>();
}
_ = services.AddSerializer(Configure);
_serviceProvider = services.BuildServiceProvider();
_codecProvider = _serviceProvider.GetRequiredService <CodecProvider>();
}
public GrainReferenceShared(
GrainType grainType,
GrainInterfaceType grainInterfaceType,
ushort interfaceVersion,
IGrainReferenceRuntime runtime,
InvokeMethodOptions invokeMethodOptions,
CodecProvider codecProvider,
CopyContextPool copyContextPool,
IServiceProvider serviceProvider)
{
this.GrainType = grainType;
this.InterfaceType = grainInterfaceType;
this.Runtime = runtime;
this.InvokeMethodOptions = invokeMethodOptions;
this.CodecProvider = codecProvider;
this.CopyContextPool = copyContextPool;
this.ServiceProvider = serviceProvider;
this.InterfaceVersion = interfaceVersion;
}
public static void AddCodecProvider(CodecProvider provider)
{
providers.Add(provider);
}
/// <summary>
/// Adds a codec
/// </summary>
/// <param name="provider">
/// A <see cref="CodecProvider"/>
/// </param>
/// <remarks>
/// A <see cref="CodecProvider" /> delegate is used to add
/// support for new <see cref="Codec" /> subclasses in <see
/// cref="GetCodec" />.
/// </remarks>
/// <seealso cref="CodecProvider" />
public static void AddCodecProvider (CodecProvider provider)
{
providers.Insert (0, provider);
}
/// <summary>
/// Instantiate a new LZ4 codec handler using the default settings for block size and high compression.
/// </summary>
/// <param name="memoryStreamManager">RecyclableMemoryStreamManager to allocate buffers from.</param>
public LZ4Codec(RecyclableMemoryStreamManager memoryStreamManager, CodecProvider codecProvider)
: this(DefaultBlockSize, DefaultHighCompression, memoryStreamManager, codecProvider) { }
/// <summary>
/// Adds a codec
/// </summary>
/// <param name="provider">
/// A <see cref="CodecProvider"/>
/// </param>
/// <remarks>
/// A <see cref="CodecProvider" /> delegate is used to add
/// support for new <see cref="Codec" /> subclasses in <see
/// cref="GetCodec" />.
/// </remarks>
/// <seealso cref="CodecProvider" />
public static void AddCodecProvider(CodecProvider provider)
{
providers.Insert(0, provider);
}
public static void AddCodecProvider (CodecProvider provider)
{
providers.Add (provider);
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializerSessionPool"/> class.
/// </summary>
/// <param name="typeCodec">The type codec.</param>
/// <param name="wellKnownTypes">The well known type collection.</param>
/// <param name="codecProvider">The codec provider.</param>
public SerializerSessionPool(TypeCodec typeCodec, WellKnownTypeCollection wellKnownTypes, CodecProvider codecProvider)
{
var sessionPoolPolicy = new SerializerSessionPoolPolicy(typeCodec, wellKnownTypes, codecProvider, ReturnSession);
_sessionPool = new ConcurrentObjectPool <SerializerSession, SerializerSessionPoolPolicy>(sessionPoolPolicy);
}
/// <summary>
/// Instantiate a new LZ4 codec handler using the default settings for block size and high compression.
/// </summary>
/// <param name="memoryStreamManager">RecyclableMemoryStreamManager to allocate buffers from.</param>
public LZ4Codec(RecyclableMemoryStreamManager memoryStreamManager, CodecProvider codecProvider)
: this(DefaultBlockSize, DefaultHighCompression, memoryStreamManager, codecProvider)
{
}
public SerializerSession(TypeCodec typeCodec, WellKnownTypeCollection wellKnownTypes, CodecProvider codecProvider)
{
TypeCodec = typeCodec;
WellKnownTypes = wellKnownTypes;
CodecProvider = codecProvider;
}
