public virtual void Dispose()
{
if (m_disposeCompression && m_compression != null)
{
m_compression.Dispose();
m_compression = null;
}
}
public bool TryGetCompressionFromRequest(HttpRequestBase request, out ICompression compression)
{
var acceptEncodingHeader = request.Headers["Accept-Encoding"];
if (string.IsNullOrEmpty(acceptEncodingHeader))
{
compression = null;
return false;
}
compression = m_compressions.FirstOrDefault(c => acceptEncodingHeader.IndexOf(c.ContentEncoding, StringComparison.InvariantCultureIgnoreCase) > -1);
return compression != null;
}
public virtual void Dispose()
{
if (m_compression != null)
try { m_compression.Dispose(); }
finally { m_compression = null; }
if (m_localfile != null)
try { m_localfile.Dispose(); }
finally { m_localfile = null; }
m_volumename = null;
}
public VolumeWriterBase(Options options, DateTime timestamp)
: base(options)
{
m_localfile = new Library.Utility.TempFile();
m_volumename = GenerateFilename(this.FileType, options.Prefix, GenerateGuid(options), timestamp, options.CompressionModule, options.NoEncryption ? null : options.EncryptionModule);
m_compression = DynamicLoader.CompressionLoader.GetModule(options.CompressionModule, m_localfile, options.RawOptions);
if(m_compression == null)
throw new Exception(string.Format("Unsupported compression module: {0}", options.CompressionModule));
if ((this is IndexVolumeWriter || this is FilesetVolumeWriter) && m_compression is Library.Interface.ICompressionHinting)
((Library.Interface.ICompressionHinting)m_compression).LowOverheadMode = true;
AddManifestfile();
}
public static IEnumerable<string> ReadBlocklist(ICompression compression, string filename, long hashsize)
{
var buffer = new byte[hashsize];
using(var fs = compression.OpenRead(filename))
{
int s;
while ((s = Library.Utility.Utility.ForceStreamRead(fs, buffer, buffer.Length)) != 0)
{
if (s != buffer.Length)
throw new InvalidDataException("Premature End-of-stream encountered while reading blocklist hashes");
yield return Convert.ToBase64String(buffer);
}
}
}
public VolumeReaderBase(ICompression compression, Options options)
: base(options)
{
m_compression = compression;
if (!options.DontReadManifests)
{
using (var s = m_compression.OpenRead(MANIFEST_FILENAME))
{
if (s == null)
throw new InvalidManifestException("No manifest file found in volume");
using (var fs = new StreamReader(s, ENCODING))
ManifestData.VerifyManifest(fs.ReadToEnd(), m_blocksize, options.BlockHashAlgorithm, options.FileHashAlgorithm);
}
}
}
public DataCompressor(ICompression compression)
{
Ensure.ArgumentNotNull(compression, "compression");
_compression = compression;
}
public DocumentOverload(IAes aes, ISecureHash secureHash, ICompression compression, IPassword password, IFileProxy fileProxy)
: base(aes, secureHash, compression, password, fileProxy)
{
}
public void SetStrategy(ICompression compression)
{
this.Compression = compression;
}
public BasicClient(ITableGenerator tableGenerator, IBasicService basicService, ISerialisation serialisation, ICompression compression, IEncryption encryption, TokenTableSet tokenTableSet)
{
_tableGenerator = tableGenerator;
_basicService = basicService;
_serialisation = serialisation;
_compression = compression;
_encryption = encryption;
if (tokenTableSet == null)
{
_tokenTableSet = GenerateTokenTable();
}
else
{
_tokenTableSet = tokenTableSet;
}
}
public ControlFileEnumerable(ICompression compression)
{
m_compression = compression;
}
public InMemorySerializer(ICompression encoder)
{
this.Encoder = encoder;
}
public ChunkReadStream(Stream baseStream, ICompression compression)
{
_baseStream = baseStream;
_compression = compression;
}
private void StartCompression(string algorithm)
{
_compression = Static.CompressionRegistry.GetCompression(algorithm);
_isCompressionEnabled = true;
}
/**
* Set the delegate implementation.
*
* @param _delegate The delegate implementing platform specific functions.
*/
public void SetDelegate(ICompression _delegate)
{
this._delegate = _delegate;
}
public State(IReadable readable, ICompression compressor)
{
_readable = readable;
Compressor = compressor;
Temp = new TempStream();
}
/**
* Constructor with delegate.
*
* @param _delegate The delegate implementing platform specific functions.
*/
public CompressionBridge(ICompression _delegate) : base()
{
this._delegate = _delegate;
}
/// <summary>
/// </summary>
/// <param name="algorithm"></param>
public void StartCompression(string algorithm)
{
_compression = CompressionRegistry.GetCompression(algorithm);
_compressed = true;
}
private static void TestStubsForDocument(out IAes aes, out ISecureHash hash, out IPassword password, out IFileProxy fileProxy, out ICompression compression)
{
aes = new TestAES();
hash = new TestSecureHash();
password = new Password("password", "password");
fileProxy = new TestFileProxy();
compression = new TestCompression();
}
public FileEntryEnumerable(ICompression compression)
{
m_compression = compression;
}
public PhotoProcessor(IFilter filter, ICompression compression)
{
this._compression = compression;
this._filter = filter;
}
public ControlFileEnumerator(ICompression compression)
{
m_compression = compression;
this.Reset();
}
public DataCompressor(ICompression compression)
{
Ensure.ArgumentNotNull(compression, "compression");
_compression = compression;
}
public FilesetVolumeReader(ICompression compression, Options options)
: base(compression, options)
{
}
public IndexVolumeReader(ICompression compression, Options options, long hashsize)
: base(compression, options)
{
m_hashsize = hashsize;
}
public OSPSuiteExecutionContext(IOSPSuiteXmlSerializerRepository modelingXmlSerializerRepository, ICompression compress, IEventPublisher eventPublisher)
{
_modelingXmlSerializerRepository = modelingXmlSerializerRepository;
_compress = compress;
_eventPublisher = eventPublisher;
Project = new TestProject();
}
private void StartCompression(string algorithm)
{
_compression = Static.CompressionRegistry.GetCompression(algorithm);
_isCompressionEnabled = true;
}
public CompressionContext(ICompression compression)
{
this.Compression = Compression;
}
/// <summary>
/// Create a new POST request.
/// </summary>
/// <param name="route">The route.</param>
/// <param name="content">The content of the request.</param>
/// <param name="formatter">The formatter use to serialize the content.</param>
/// <param name="compression">Add compresion system use to compress content.</param>
/// <returns>The new request.</returns>
public IParameterRequest PostRequest <TContent>(string route, TContent content, IFormatter formatter = null, ICompression compression = null)
{
return(new Request(HttpMethod.Post, route, this).
AddContent <TContent>(content, formatter, compression));
}
/// <summary>
/// </summary>
/// <param name="algorithm"></param>
public void StartCompression(string algorithm)
{
_compression = CompressionRegistry.GetCompression(algorithm);
_compressed = true;
}
public BasicClientFactory(ISerialisation serialisation, ICompression compression, IEncryption encryption)
{
_serialisation = serialisation;
_compression = compression;
_encryption = encryption;
}
public virtual void Close()
{
if (m_compression != null)
try { m_compression.Dispose(); }
finally { m_compression = null; }
}
public MessageEncoding(ICompression compression)
{
this._compression = compression;
}
protected override void ProcessCompression(ICompression compression, Stream input, Stream output)
{
compression.Compress(input, output);
}
/// <summary>
/// Create a new PATCH request.
/// </summary>
/// <param name="route">The route.</param>
/// <param name="content">The content of the request</param>
/// <param name="serializer">The serializer use to serialize it</param>
/// <param name="compression">Add compresion system use ton compress content</param>
/// <returns>The new request.</returns>
public IParameterRequest PatchRequest <TContent>(string route, TContent content, IFormatter serializer = null, ICompression compression = null)
{
return(new Request(_PatchMethod, route, this).
AddContent <TContent>(content, serializer, compression));
}
/// <summary>
/// Create a new PUT request.
/// </summary>
/// <param name="content">The content of the request.</param>
/// <param name="formatter">The formatter use to serialize the content.</param>
/// <param name="compression">Add compresion system use to compress content.</param>
/// <returns>The new request.</returns>
public IParameterRequest PutRequest <TContent>(TContent content, IFormatter formatter = null, ICompression compression = null)
{
return(new Request(HttpMethod.Put, null, this).
AddContent <TContent>(content, formatter, compression));
}
public BlockVolumeReader(ICompression compression, Options options)
: base(compression, options)
{
}
public VolumeReaderBase(ICompression compression, Options options)
: base(options)
{
m_compression = compression;
ReadManifests(options);
}
public string ReadText(Structure structure)
{
if (this._disposed)
{
throw new ObjectDisposedException("stream");
}
if (structure is null)
{
throw new ArgumentNullException(nameof(structure));
}
var decompressedByteList = new List <byte>();
ICompression compression = null;
Encoding encoding = Encoding.UTF8;
ushort maxRecordSize = 4096;
if (structure.PalmDOCHeader != null)
{
if (structure.PalmDOCHeader.RecordSize > 0)
{
maxRecordSize = structure.PalmDOCHeader.RecordSize;
}
switch (structure.PalmDOCHeader.Compression)
{
case CompressionType.PalmDOC:
{
compression = new PalmDocCompression();
}
break;
case CompressionType.HUFF_CDIC:
{
compression = CreateHuffCdicCompression(structure.MobiHeader);
}
break;
default:
{
compression = new NoneCompression();
}
break;
}
}
if (structure.MobiHeader != null)
{
var firstTextRecordIndex = this.FindFirstTextRecordIndex(structure.MobiHeader);
var firstNonTextRecordIndex = this.FindFirstNonTextRecordIndex(structure.MobiHeader);
for (int i = firstTextRecordIndex; i < firstNonTextRecordIndex; i++)
{
var recordBytes = this.ReadPalmDBRecord(this._palmDBRecordList[i]);
var decompressedBytes = compression.Decompress(recordBytes);
var fixedDecompressedBytes = decompressedBytes.Length > maxRecordSize?
decompressedBytes.Take(maxRecordSize) :
decompressedBytes;
decompressedByteList.AddRange(fixedDecompressedBytes);
}
}
return(encoding.GetString(decompressedByteList.ToArray()));
}
public BlockVolumeReader(ICompression compression, Options options)
: base(compression, options)
{
}
public ChunkWriteStream(Stream stream, ICompression compression)
{
_flusher = new ChunkWriteStreamFlusher(stream, compression);
_flusher.Start();
}
