public static async Task CopyToAsync( this Stream istream, Stream ostream, IBufferProvider bufferProvider, CancellationToken token, Action <long> progressIncreased) { var buffer = await bufferProvider.AllocBufferAsync(); try { while (!token.IsCancellationRequested) { int readLen = await istream.ReadAsync(buffer, 0, buffer.Length, token); if (readLen <= 0) { break; } await ostream.WriteAsync(buffer, 0, readLen, token); progressIncreased(readLen); } } catch (TaskCanceledException) { } finally { bufferProvider.ReleaseBuffer(buffer); } }
/// <summary> /// Construct a HttpParallelDownloader. /// </summary> /// <param name="task">Download task, must with HttpRangedTarget.</param> /// <param name="folderProvider">Folder provider must not be null.</param> /// <param name="cacheProvider">Cache provider must not be null.</param> /// <param name="bufferProvider">Buffer provider must not be null.</param> /// <param name="checkPoint">Set the downloader to start at given checkPoint.</param> /// <param name="threadNum">Number of threads used.</param> /// <param name="threadSegmentSize">Downloading task is divided as segments /// before assigned to each thread. Segment size defines the approximate /// size of each segment.</param> public HttpParallelDownloader( DownloadTask task, IFolderProvider folderProvider, ICacheStorageProvider cacheProvider, IBufferProvider bufferProvider, byte[] checkPoint = null, int threadNum = 8, long threadSegmentSize = 8 * 1024 * 1024 ) : base(task) { Ensure.That(task.Target is HttpRangableTarget, null, opts => opts.WithMessage( $"type of {nameof(task.Target)} must be {nameof(HttpRangableTarget)}") ).IsTrue(); Ensure.That(folderProvider, nameof(folderProvider)).IsNotNull(); Ensure.That(cacheProvider, nameof(cacheProvider)).IsNotNull(); Ensure.That(bufferProvider, nameof(bufferProvider)).IsNotNull(); Ensure.That(threadNum, nameof(threadNum)).IsGte(1); Ensure.That(threadSegmentSize, nameof(threadSegmentSize)).IsGt(1024 * 1024); this.folderProvider = folderProvider; this.cacheProvider = cacheProvider; this.bufferProvider = bufferProvider; this.threadNum = threadNum; this.threadSegmentSize = threadSegmentSize; Progress = new CompositeProgress((task.Target as HttpRangableTarget).DataLength); Speed = SharedSpeedCalculatorFactory.NewSpeedCalculator(); Progress.ProgressChanged += (sender, arg) => Speed.CurrentValue = Progress.DownloadedSize; if (checkPoint != null) { ApplyCheckPoint(checkPoint); } }
bool IBufferProvider.Compare(IBufferProvider Other) { if (Other == null) return false; if (object.ReferenceEquals(this, Other)) return true; BufferWrapper autre = Other as BufferWrapper; if (autre == null) return false; if (object.ReferenceEquals(_IPP, autre._IPP)) return true; using (Stream st = _IPP.GetBuffer()) { using (Stream st2 = autre._IPP.GetBuffer()) { if ((st2 == null) || (st == null)) return object.ReferenceEquals(st2, st); return st.Compare(st2); } } }
/// <summary> /// Changes a old bond wrapper for a new bond type to represent its new bond value /// as blob data /// </summary> /// <typeparam name="TWrapper">the wrapper (an old bond type)</typeparam> /// <typeparam name="TValue">the wrapped value type (an new bond type)</typeparam> /// <param name="wrapper">the wrapper for the new bond type</param> /// <param name="bufferProvider">the buffer provider which provides buffers used during serialization</param> public static void Adapt <TWrapper, TValue>(TWrapper wrapper, IBufferProvider bufferProvider) where TWrapper : DataWrapper, IBondWrapper <TValue> { if (wrapper != null && wrapper.Value != null && (wrapper.Data == null || wrapper.Data.Count == 0)) { wrapper.Data = ToBlob(wrapper.Value, bufferProvider); } }
/// <summary> /// Serializes a new bond value to an old bond blob /// </summary> /// <typeparam name="T">the type of the value</typeparam> /// <param name="value">the new bond value</param> /// <param name="bufferProvider">the buffer provider which provides buffers used during serialization</param> /// <returns>the old bond blow representing the new bond value</returns> public static Microsoft.Bond.BondBlob ToBlob <T>(T value, IBufferProvider bufferProvider) { OutputBuffer buffer = bufferProvider.GetOutputBuffer(); var startPosition = buffer.Position; CompactBinaryWriter <OutputBuffer> writer = new CompactBinaryWriter <OutputBuffer>(buffer); Serialize.To(writer, value); bufferProvider.ReleaseOutputBuffer(); return(new Microsoft.Bond.BondBlob(buffer.Data.Array, (int)startPosition, (int)(buffer.Position - startPosition))); }
/// <summary> /// Changes a list of old bond wrappers for an new bond type to represent their new bond values /// as blob data /// </summary> /// <typeparam name="TWrapper">the wrapper (an old bond type)</typeparam> /// <typeparam name="TValue">the wrapped value type (an new bond type)</typeparam> /// <param name="list">the list of wrappers for the new bond type</param> /// <param name="bufferProvider">the buffer provider which provides buffers used during serialization</param> public static void Adapt <TWrapper, TValue>(List <TWrapper> list, IBufferProvider bufferProvider) where TWrapper : DataWrapper, IBondWrapper <TValue> { if (list != null) { foreach (var item in list) { Adapt <TWrapper, TValue>(item, bufferProvider); } } }
/// <summary> /// Changes a list of old bond wrappers for a new bond type to represent their new bond values /// as blob data /// </summary> /// <typeparam name="TAdaptable">the wrapper (an old bond type)</typeparam> /// <param name="list">the list of wrappers for the new bond type</param> /// <param name="bufferProvider">the buffer provider which provides buffers used during serialization</param> public static void Adapt <TAdaptable>(List <TAdaptable> list, IBufferProvider bufferProvider) where TAdaptable : IBondAdaptable { if (list != null) { foreach (var item in list) { item.Adapt(bufferProvider); } } }
/// <summary> /// Construct a HttpDownloader with given task and configurations. /// </summary> /// <param name="task">Download task, must with HttpTarget.</param> /// <param name="folderProvider">Folder provider must not be null.</param> /// <param name="cacheProvider">Cache provider must not be null.</param> /// <param name="bufferProvider">Buffer provider must not be null.</param> public HttpDownloader( DownloadTask task, IFolderProvider folderProvider, ICacheStorageProvider cacheProvider, IBufferProvider bufferProvider ) : base(task) { Ensure.That(task.Target is HttpTarget, null, opts => opts.WithMessage($"type of {nameof(task.Target)} must be {nameof(HttpTarget)}") ).IsTrue(); Ensure.That(folderProvider, nameof(folderProvider)).IsNotNull(); Ensure.That(cacheProvider, nameof(cacheProvider)).IsNotNull(); Ensure.That(bufferProvider, nameof(bufferProvider)).IsNotNull(); this.folderProvider = folderProvider; this.cacheProvider = cacheProvider; this.bufferProvider = bufferProvider; Progress = new BaseProgress(); Speed = SharedSpeedCalculatorFactory.NewSpeedCalculator(); Progress.ProgressChanged += (sender, arg) => Speed.CurrentValue = Progress.DownloadedSize; }
/// <nodoc/> public virtual void Adapt(IBufferProvider bufferProvider) { }
//internal void AfterLoad() //{ // CachedImage.AfterLoad(false); //} private ImageCache InitFromBuffer(IBufferProvider ibp) { if (_ImageCache != null) return _ImageCache; //check buffer equality _ImageCache = new ImageCache(this, ibp); return _ImageCache; }
internal AImage(IBufferProvider ImageBuffer, int iid) { _Buffer = ImageBuffer; _ID = iid; }
/// <nodoc/> public void Adapt(IBufferProvider bufferProvider) { DistributionTypeExtension.Adapt <DistributionPipGraphCacheDescriptor, PipGraphCacheDescriptor>(CachedGraphDescriptor, bufferProvider); DistributionTypeExtension.Adapt <DistributionContentHash, BondContentHash>(SymlinkFileContentHash, bufferProvider); }
/// <nodoc/> public void Adapt(IBufferProvider bufferProvider) { DistributionTypeExtension.Adapt(CompletedPips, bufferProvider); }
/// <nodoc/> public void Adapt(IBufferProvider bufferProvider) { }
/// <nodoc/> public void Adapt(IBufferProvider bufferProvider) { DistributionTypeExtension.Adapt <DistributionContentHash, BondContentHash>(ContentHash, bufferProvider); }
/// <nodoc/> public void Adapt(IBufferProvider bufferProvider) { DistributionTypeExtension.Adapt <DistributionCacheFingerprint, BondFingerprint>(Fingerprint, bufferProvider); }
/// <nodoc/> public void Adapt(IBufferProvider bufferProvider) { DistributionTypeExtension.Adapt(Pips, bufferProvider); DistributionTypeExtension.Adapt(Hashes, bufferProvider); }
/// <nodoc/> public override void Adapt(IBufferProvider bufferProvider) { DistributionTypeExtension.Adapt <DistributionPipGraphCacheDescriptor, PipGraphCacheDescriptor>(this, bufferProvider); }
internal void Update(bool force=false) { AlbumImage newim = _Father.RawFrontImage; if (!force && (object.ReferenceEquals(_ImageCached, newim))) return; IPersistentBufferProvider ibp = newim == null ? null : newim.CreateJpgThumbnail(Dimension); _Buffer = ibp; if (ibp != null) { ibp.DefaultExtension = ".jpg"; //ibp.Save(Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString())); } CachedImage = null; _ImageCached = newim; }
internal ImageCache(Album Father, IBufferProvider iBp) { _Father = Father; _Buffer = iBp; }