< Summary

Information
Class: Renci.SshNet.Compression.Compressor
Assembly: Renci.SshNet
File(s): \home\appveyor\projects\ssh-net\src\Renci.SshNet\Compression\Compressor.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 72
Coverable lines: 72
Total lines: 186
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 20
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity Line coverage
get_IsActive()100%10%
get_Session()100%10%
.ctor()100%10%
Init(...)100%10%
Compress(...)100%10%
Compress(...)0%60%
Decompress(...)100%10%
Decompress(...)0%60%
Dispose()100%10%
Dispose(...)0%80%
Finalize()100%10%

File(s)

\home\appveyor\projects\ssh-net\src\Renci.SshNet\Compression\Compressor.cs

#LineLine coverage
 1using System;
 2using System.IO;
 3
 4using Renci.SshNet.Security;
 5
 6namespace Renci.SshNet.Compression
 7{
 8    /// <summary>
 9    /// Represents base class for compression algorithm implementation.
 10    /// </summary>
 11    public abstract class Compressor : Algorithm, IDisposable
 12    {
 13        private readonly ZlibStream _compressor;
 14        private readonly ZlibStream _decompressor;
 15        private MemoryStream _compressorStream;
 16        private MemoryStream _decompressorStream;
 17        private bool _isDisposed;
 18
 19        /// <summary>
 20        /// Gets or sets a value indicating whether compression is active.
 21        /// </summary>
 22        /// <value>
 23        /// <see langword="true"/> if compression is active; otherwise, <see langword="false"/>.
 24        /// </value>
 025        protected bool IsActive { get; set; }
 26
 27        /// <summary>
 28        /// Gets the session.
 29        /// </summary>
 030        protected Session Session { get; private set; }
 31
 32        /// <summary>
 33        /// Initializes a new instance of the <see cref="Compressor"/> class.
 34        /// </summary>
 035        protected Compressor()
 036        {
 037            _compressorStream = new MemoryStream();
 038            _decompressorStream = new MemoryStream();
 39
 040            _compressor = new ZlibStream(_compressorStream, CompressionMode.Compress);
 041            _decompressor = new ZlibStream(_decompressorStream, CompressionMode.Decompress);
 042        }
 43
 44        /// <summary>
 45        /// Initializes the algorithm.
 46        /// </summary>
 47        /// <param name="session">The session.</param>
 48        public virtual void Init(Session session)
 049        {
 050            Session = session;
 051        }
 52
 53        /// <summary>
 54        /// Compresses the specified data.
 55        /// </summary>
 56        /// <param name="data">Data to compress.</param>
 57        /// <returns>
 58        /// The compressed data.
 59        /// </returns>
 60        public virtual byte[] Compress(byte[] data)
 061        {
 062            return Compress(data, 0, data.Length);
 063        }
 64
 65        /// <summary>
 66        /// Compresses the specified data.
 67        /// </summary>
 68        /// <param name="data">Data to compress.</param>
 69        /// <param name="offset">The zero-based byte offset in <paramref name="data"/> at which to begin reading the dat
 70        /// <param name="length">The number of bytes to be compressed. </param>
 71        /// <returns>
 72        /// The compressed data.
 73        /// </returns>
 74        public virtual byte[] Compress(byte[] data, int offset, int length)
 075        {
 076            if (!IsActive)
 077            {
 078                if (offset == 0 && length == data.Length)
 079                {
 080                    return data;
 81                }
 82
 083                var buffer = new byte[length];
 084                Buffer.BlockCopy(data, offset, buffer, 0, length);
 085                return buffer;
 86            }
 87
 088            _compressorStream.SetLength(0);
 89
 090            _compressor.Write(data, offset, length);
 91
 092            return _compressorStream.ToArray();
 093        }
 94
 95        /// <summary>
 96        /// Decompresses the specified data.
 97        /// </summary>
 98        /// <param name="data">Compressed data.</param>
 99        /// <returns>
 100        /// The decompressed data.
 101        /// </returns>
 102        public virtual byte[] Decompress(byte[] data)
 0103        {
 0104            return Decompress(data, 0, data.Length);
 0105        }
 106
 107        /// <summary>
 108        /// Decompresses the specified data.
 109        /// </summary>
 110        /// <param name="data">Compressed data.</param>
 111        /// <param name="offset">The zero-based byte offset in <paramref name="data"/> at which to begin reading the dat
 112        /// <param name="length">The number of bytes to be read from the compressed data. </param>
 113        /// <returns>
 114        /// The decompressed data.
 115        /// </returns>
 116        public virtual byte[] Decompress(byte[] data, int offset, int length)
 0117        {
 0118            if (!IsActive)
 0119            {
 0120                if (offset == 0 && length == data.Length)
 0121                {
 0122                    return data;
 123                }
 124
 0125                var buffer = new byte[length];
 0126                Buffer.BlockCopy(data, offset, buffer, 0, length);
 0127                return buffer;
 128            }
 129
 0130            _decompressorStream.SetLength(0);
 131
 0132            _decompressor.Write(data, offset, length);
 133
 0134            return _decompressorStream.ToArray();
 0135        }
 136
 137        /// <summary>
 138        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
 139        /// </summary>
 140        public void Dispose()
 0141        {
 0142            Dispose(disposing: true);
 0143            GC.SuppressFinalize(this);
 0144        }
 145
 146        /// <summary>
 147        /// Releases unmanaged and - optionally - managed resources.
 148        /// </summary>
 149        /// <param name="disposing"><see langword="true"/> to release both managed and unmanaged resources; <see langwor
 150        protected virtual void Dispose(bool disposing)
 0151        {
 0152            if (_isDisposed)
 0153            {
 0154                return;
 155            }
 156
 0157            if (disposing)
 0158            {
 0159                var compressorStream = _compressorStream;
 0160                if (compressorStream != null)
 0161                {
 0162                    compressorStream.Dispose();
 0163                    _compressorStream = null;
 0164                }
 165
 0166                var decompressorStream = _decompressorStream;
 0167                if (decompressorStream != null)
 0168                {
 0169                    decompressorStream.Dispose();
 0170                    _decompressorStream = null;
 0171                }
 172
 0173                _isDisposed = true;
 0174            }
 0175        }
 176
 177        /// <summary>
 178        /// Releases unmanaged resources and performs other cleanup operations before the <see cref="Compressor"/> is re
 179        /// by garbage collection.
 180        /// </summary>
 181        ~Compressor()
 0182        {
 0183            Dispose(disposing: false);
 0184        }
 185    }
 186}
Generated by: ReportGenerator 5.2.0.0
11/29/2023 - 11:22:39 AM
GitHub | reportgenerator.io

Methods/Properties

get_IsActive()
get_Session()
.ctor()
Init(Renci.SshNet.Session)
Compress(System.Byte[])
Compress(System.Byte[],System.Int32,System.Int32)
Decompress(System.Byte[])
Decompress(System.Byte[],System.Int32,System.Int32)
Dispose()
Dispose(System.Boolean)
Finalize()