private static void AssertAlgorithm(ICompressionAlgorithm algorithm, string text)
{
Assert.AreEqual(text,
Encoding.UTF8.GetString(algorithm.Decompress(algorithm.Compress(Encoding.UTF8.GetBytes(text)))));
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(text)))
using (var compressed = algorithm.Compress(stream))
using (var decompressed = algorithm.Decompress(compressed))
using (var decompressedStream = new MemoryStream())
{
decompressed.CopyTo(decompressedStream);
Assert.AreEqual(text, Encoding.UTF8.GetString(decompressedStream.ToArray()));
}
}
public Message Compress(ICompressionAlgorithm packer)
{
var result = packer.Compress(Content);
Size = 0;
AddBytes(result);
return(this);
}
public static Stream Compress(this ICompressionAlgorithm algorithm, Stream stream)
{
Guard.AgainstNull(algorithm, nameof(algorithm));
Guard.AgainstNull(stream, nameof(stream));
using (var ms = new MemoryStream())
{
stream.CopyTo(ms);
return(new MemoryStream(algorithm.Compress(ms.ToArray())));
}
}
public (int firstPosition, int lastPosition, int numBytes) Write(ExtendedBinaryWriter writer)
{
var compressedLength = _compressionAlgorithm.Compress(_uncompressedBlock, BlockOffset,
_compressedBlock, _compressedBlock.Length);
writer.WriteOpt(compressedLength);
writer.WriteOpt(_firstPosition);
//writer.WriteOpt(_lastPosition);
writer.WriteOpt(_count);
writer.Write(_compressedBlock, 0, compressedLength);
_writer.BaseStream.Position = 0;
return(_firstPosition, _lastPosition, compressedLength);
}
internal void WriteInterval(PhylopInterval interval, ExtendedBinaryWriter writer)
{
if (_scoreCount == 0)
{
return;
}
ScoresToBytes(_scoreBytes, _scores, _scoreCount);
var compressedSize = _compressor.Compress(_scoreBytes, _scoreCount * 2, _compressedBuffer, _compressedBuffer.Length);
// finalizing the file position for this chromosome interval
interval.FilePosition = _writer.BaseStream.Position;
_currentInterval.Length = _scoreCount;
ChromosomeIntervals.Add(interval);
_scoreCount = 0;
WriteScores(writer, _compressedBuffer, compressedSize);
}
/// <summary>
/// Writes the current compression block to a stream.
/// </summary>
/// <param name="stream">The stream that will write the compressed data.</param>
public void Write(Stream stream)
{
_header.NumUncompressedBytes = Offset;
_header.NumCompressedBytes = _compressionAlgorithm.Compress(_uncompressedBlock, _header.NumUncompressedBytes,
_compressedBlock, _compressedBlockSize);
if (_header.NumCompressedBytes > _header.NumUncompressedBytes)
{
_header.NumCompressedBytes = -1;
_header.Write(stream);
stream.Write(_uncompressedBlock, 0, _header.NumUncompressedBytes);
}
else
{
_header.Write(stream);
stream.Write(_compressedBlock, 0, _header.NumCompressedBytes);
}
Offset = 0;
}
public IMemoryOwner <byte>?Compress(ReadOnlyMemory <byte> input, IRequestSpan parentSpan)
{
if (!_clusterOptions.Compression || input.Length < _clusterOptions.CompressionMinSize)
{
LogSkipLength(_logger, input.Length, _clusterOptions.CompressionMinSize, null);
return(null);
}
using var compressionSpan = parentSpan.CompressionSpan();
var compressed = _compressionAlgorithm.Compress(input);
try
{
var compressedMemory = compressed.Memory;
var compressionRatio = compressedMemory.Length == 0
? 1f
: (float)compressedMemory.Length / input.Length;
if (compressionRatio > _clusterOptions.CompressionMinRatio)
{
AddCompressionTags(compressionSpan, compressionRatio, false);
LogSkipCompressionRatio(_logger, compressionRatio, _clusterOptions.CompressionMinRatio, null);
// Insufficient compression, so drop it
compressed.Dispose();
return(null);
}
AddCompressionTags(compressionSpan, compressionRatio, true);
return(compressed);
}
catch
{
compressed.Dispose();
throw;
}
}
private async Task <bool> PerformArchiveOperations(ICompressionAlgorithm compressionAlgorithm, string fileType, WriterOptions options)
{
return(await Task.Run(async() =>
{
var tempFile = await _workingDir.CreateFileAsync("tempFile");
using (var streamWriter = new StreamWriter(await tempFile.OpenStreamForWriteAsync()))
{
streamWriter.AutoFlush = true;
streamWriter.WriteLine(FileText);
}
_files = await _workingDir.GetFilesAsync();
Assert.IsNotNull(_files);
Assert.AreEqual(_files.Count, 1); // check if file exists
var archive = await _workingDir.CreateFileAsync(ArchiveName + fileType);
Assert.IsTrue(await compressionAlgorithm.Compress(_files, archive, _workingDir, options));
return await ArchiveExtraction(compressionAlgorithm, fileType); // extract archive after creation
}));
}
public IMemoryOwner <byte>?Compress(ReadOnlyMemory <byte> input)
{
if (!_clusterOptions.Compression || input.Length < _clusterOptions.CompressionMinSize)
{
_logger.LogTrace("Skipping operation compression because length {length} < {compressionMinSize}",
input.Length, _clusterOptions.CompressionMinSize);
return(null);
}
var compressed = _compressionAlgorithm.Compress(input);
try
{
var compressedMemory = compressed.Memory;
var compressionRatio = compressedMemory.Length == 0
? 1f
: (float)compressedMemory.Length / input.Length;
if (compressionRatio > _clusterOptions.CompressionMinRatio)
{
_logger.LogTrace("Skipping operation compression because compressed size {compressionRatio} > {compressionMinRatio}",
compressionRatio, _clusterOptions.CompressionMinRatio);
// Insufficient compression, so drop it
compressed.Dispose();
return(null);
}
return(compressed);
}
catch
{
compressed.Dispose();
throw;
}
}
public void Compress(string source, string destination)
{
strategy.Compress(source, destination);
}