/// <summary> /// Initializes a new instance of the BlockCacheStream class. /// </summary> /// <param name="toWrap">The stream to wrap</param> /// <param name="ownership">Whether to assume ownership of <c>toWrap</c></param> /// <param name="settings">The cache settings</param> public BlockCacheStream(SparseStream toWrap, Ownership ownership, BlockCacheSettings settings) { if (!toWrap.CanRead) { throw new ArgumentException("The wrapped stream does not support reading", "toWrap"); } if (!toWrap.CanSeek) { throw new ArgumentException("The wrapped stream does not support seeking", "toWrap"); } _wrappedStream = toWrap; _ownWrapped = ownership; _settings = new BlockCacheSettings(settings); if (_settings.OptimumReadSize % _settings.BlockSize != 0) { throw new ArgumentException("Invalid settings, OptimumReadSize must be a multiple of BlockSize", "settings"); } _readBuffer = new byte[_settings.OptimumReadSize]; _blocksInReadBuffer = _settings.OptimumReadSize / _settings.BlockSize; int totalBlocks = (int)(_settings.ReadCacheSize / _settings.BlockSize); _cache = new BlockCache<Block>(_settings.BlockSize, totalBlocks); _stats = new BlockCacheStatistics(); _stats.FreeReadBlocks = totalBlocks; }
/// <summary> /// Initializes a new instance of the ThreadSafeStream class. /// </summary> /// <param name="toWrap">The stream to wrap</param> /// <param name="ownership">Whether to transfer ownership of <c>toWrap</c> to the new instance</param> /// <remarks>Do not directly modify <c>toWrap</c> after wrapping it, unless the thread-safe views /// will no longer be used.</remarks> public ThreadSafeStream(SparseStream toWrap, Ownership ownership) { if (!toWrap.CanSeek) { throw new ArgumentException("Wrapped stream must support seeking", "toWrap"); } _common = new CommonState { WrappedStream = toWrap, WrappedStreamOwnership = ownership }; _ownsCommon = true; }
/// <summary> /// Initializes a new instance of the StreamBuffer class. /// </summary> /// <param name="stream">The stream to wrap</param> /// <param name="ownership">Whether to dispose stream, when this object is disposed</param> public StreamBuffer(Stream stream, Ownership ownership) { if (stream == null) { throw new ArgumentNullException("stream"); } _stream = stream as SparseStream; if (_stream == null) { _stream = SparseStream.FromStream(stream, ownership); _ownership = Ownership.Dispose; } else { _ownership = ownership; } }
public BuilderSparseStreamExtent(long start, SparseStream stream) : base(start, stream.Length) { _stream = stream; }
/// <summary> /// Gets the content of this extent. /// </summary> /// <param name="parent">The parent stream (if any)</param> /// <param name="ownsParent">Controls ownership of the parent stream</param> /// <returns>The content as a stream</returns> public abstract MappedStream OpenContent(SparseStream parent, Ownership ownsParent);
/// <summary> /// Adds a sparse disk image to the XVA file. /// </summary> /// <param name="label">The admin-visible name of the disk</param> /// <param name="content">The content of the disk</param> /// <param name="ownsContent">Indicates if ownership of content is transfered</param> public void AddDisk(string label, SparseStream content, Ownership ownsContent) { _disks.Add(new DiskRecord(label, content, ownsContent)); }
protected override void Dispose(bool disposing) { try { if (disposing && _ownsWrapped == Ownership.Dispose && _wrapped != null) { _wrapped.Dispose(); _wrapped = null; } } finally { base.Dispose(disposing); } }
public SparseReadOnlyWrapperStream(SparseStream wrapped, Ownership ownsWrapped) { _wrapped = wrapped; _ownsWrapped = ownsWrapped; }
/// <summary> /// Wraps a sparse stream in a read-only wrapper, preventing modification. /// </summary> /// <param name="toWrap">The stream to make read-only</param> /// <param name="ownership">Whether to transfer responsibility for calling Dispose on <c>toWrap</c></param> /// <returns>The read-only stream.</returns> public static SparseStream ReadOnly(SparseStream toWrap, Ownership ownership) { return new SparseReadOnlyWrapperStream(toWrap, ownership); }
/// <summary> /// Initializes a new instance of the BlockCacheStream class. /// </summary> /// <param name="toWrap">The stream to wrap</param> /// <param name="ownership">Whether to assume ownership of <c>toWrap</c></param> public BlockCacheStream(SparseStream toWrap, Ownership ownership) : this(toWrap, ownership, new BlockCacheSettings()) { }
/// <summary> /// Disposes of this instance, freeing up associated resources. /// </summary> /// <param name="disposing"><c>true</c> if invoked from <c>Dispose</c>, else <c>false</c>.</param> protected override void Dispose(bool disposing) { if (disposing) { if (_wrappedStream != null && _ownWrapped == Ownership.Dispose) { _wrappedStream.Dispose(); } _wrappedStream = null; } base.Dispose(disposing); }
/// <summary> /// Disposes of this instance. /// </summary> public void Dispose() { if (_ownership == Ownership.Dispose) { if (_stream != null) { _stream.Dispose(); _stream = null; } } }
/// <summary> /// Initializes a new instance of the ThreadSafeStream class. /// </summary> /// <param name="toWrap">The stream to wrap</param> /// <remarks>Do not directly modify <c>toWrap</c> after wrapping it, unless the thread-safe views /// will no longer be used.</remarks> public ThreadSafeStream(SparseStream toWrap) : this(toWrap, Ownership.None) { }
public void Dispose() { WrappedStream = null; }