/// <summary> /// Returns a new CloseableReference to the same underlying /// SharedReference or null if invalid. The SharedReference /// ref-count is incremented. /// </summary> public EncodedImage CloneOrNull() { EncodedImage encodedImage; if (_inputStreamSupplier != null) { encodedImage = new EncodedImage(_inputStreamSupplier, StreamSize); } else { CloseableReference <IPooledByteBuffer> pooledByteBufferRef = CloseableReference <IPooledByteBuffer> .CloneOrNull(_pooledByteBufferRef); try { encodedImage = (pooledByteBufferRef == null) ? null : new EncodedImage(pooledByteBufferRef); } finally { // Close the recently created reference since it will be // cloned again in the constructor. CloseableReference <IPooledByteBuffer> .CloseSafely(pooledByteBufferRef); } } if (encodedImage != null) { encodedImage.CopyMetaDataFrom(this); } return(encodedImage); }
private void UpdateSourceImageRef( CloseableReference <CloseableImage> sourceImageRef, bool isLast) { CloseableReference <CloseableImage> oldSourceImageRef; bool shouldSubmit; lock (_gate) { if (_isClosed) { return; } oldSourceImageRef = _sourceImageRef; _sourceImageRef = CloseableReference <CloseableImage> .CloneOrNull(sourceImageRef); _isLast = isLast; _isDirty = true; shouldSubmit = SetRunningIfDirtyAndNotRunning(); } CloseableReference <CloseableImage> .CloseSafely(oldSourceImageRef); if (shouldSubmit) { SubmitPostprocessing(); } }
private Entry(K key, CloseableReference <V> valueRef, IEntryStateObserver <K> observer) { Key = Preconditions.CheckNotNull(key); ValueRef = Preconditions.CheckNotNull(CloseableReference <V> .CloneOrNull(valueRef)); ClientCount = 0; Orphan = false; Observer = observer; }
/// <summary> /// Creates a new instance of a CloseableStaticBitmap from an existing /// CloseableReference. The CloseableStaticBitmap will hold a reference /// to the bitmap until it's closed. /// </summary> public CloseableStaticBitmap( CloseableReference <SoftwareBitmap> bitmapReference, IQualityInfo qualityInfo, int rotationAngle) { _bitmapReference = Preconditions.CheckNotNull(bitmapReference.CloneOrNull()); _bitmap = _bitmapReference.Get(); _qualityInfo = qualityInfo; _rotationAngle = rotationAngle; }
private void SetSourceImageRef(CloseableReference <CloseableImage> sourceImageRef) { CloseableReference <CloseableImage> oldSourceImageRef; lock (_gate) { if (_isClosed) { return; } oldSourceImageRef = _sourceImageRef; _sourceImageRef = CloseableReference <CloseableImage> .CloneOrNull(sourceImageRef); } CloseableReference <CloseableImage> .CloseSafely(oldSourceImageRef); }
/// <summary> /// Clients should override this method only if the post-processed /// bitmap has to be of a different size than the source bitmap. /// If the post-processed bitmap is of the same size, clients should /// override one of the other two methods. /// /// <para />The source bitmap must not be modified as it may be shared /// by the other clients. The implementation must create a new bitmap /// that is safe to be modified and return a reference to it. /// Clients should use <code>bitmapFactory</code> to create a new bitmap. /// </summary> /// <param name="sourceBitmap">The source bitmap.</param> /// <param name="bitmapFactory"> /// The factory to create a destination bitmap. /// </param> /// <param name="flexByteArrayPool"> /// The memory pool used for post process. /// </param> /// <returns> /// A reference to the newly created bitmap. /// </returns> public CloseableReference <SoftwareBitmap> Process( SoftwareBitmap sourceBitmap, PlatformBitmapFactory bitmapFactory, FlexByteArrayPool flexByteArrayPool) { CloseableReference <SoftwareBitmap> destBitmapRef = bitmapFactory.CreateBitmapInternal( sourceBitmap.PixelWidth, sourceBitmap.PixelHeight, sourceBitmap.BitmapPixelFormat); try { Process(destBitmapRef.Get(), sourceBitmap, flexByteArrayPool); return(CloseableReference <SoftwareBitmap> .CloneOrNull(destBitmapRef)); } finally { CloseableReference <SoftwareBitmap> .CloseSafely(destBitmapRef); } }
private void UpdateInternal() { CloseableReference <CloseableImage> sourceImageRef; lock (_gate) { if (_isClosed) { return; } sourceImageRef = CloseableReference <CloseableImage> .CloneOrNull(_sourceImageRef); } try { Consumer.OnNewResult(sourceImageRef, false /* isLast */); } finally { CloseableReference <CloseableImage> .CloseSafely(sourceImageRef); } }
/// <summary> /// Returns a stream from the internal stream supplier if it's not null. /// Otherwise returns an stream for the internal buffer reference if /// valid and null otherwise. /// /// <para />The caller has to close the stream after using it. /// </summary> public Stream GetInputStream() { if (_inputStreamSupplier != null) { return(_inputStreamSupplier.Get()); } CloseableReference <IPooledByteBuffer> pooledByteBufferRef = CloseableReference <IPooledByteBuffer> .CloneOrNull(_pooledByteBufferRef); if (pooledByteBufferRef != null) { try { return(new PooledByteBufferInputStream(pooledByteBufferRef.Get())); } finally { CloseableReference <IPooledByteBuffer> .CloseSafely(pooledByteBufferRef); } } return(null); }
/// <summary> /// Gets the result if any, null otherwise. /// /// <para />Value will be cloned and it's the caller's responsibility /// to close the returned value. /// </summary> public override CloseableReference <T> GetResult() { return(CloseableReference <T> .CloneOrNull(base.GetResult())); }
/// <summary> /// Sets the value of this data source. /// /// <para />This method will return <code> true</code> if the /// value was successfully set, or <code>false</code> if the /// data source has already been set, failed or closed. /// /// <para />Passed CloseableReference is cloned, caller of this /// method still owns passed reference after the method returns. /// </summary> /// <param name="valueRef"> /// Closeable reference to the value the data source should hold. /// </param> /// <returns>true if the value was successfully set.</returns> public bool Set(CloseableReference <T> valueRef) { CloseableReference <T> clonedRef = CloseableReference <T> .CloneOrNull(valueRef); return(SetResult(clonedRef, /* isLast */ true)); }
/// <summary> /// OnNewResult implementation. /// </summary> protected override void OnNewResultImpl(CloseableReference <T> result, bool isLast) { base.OnNewResultImpl(CloseableReference <T> .CloneOrNull(result), isLast); }
/// <summary> /// Clones the result. /// </summary> public override CloseableReference <CloseableImage> CloneOrNull( CloseableReference <CloseableImage> closeableImage) { return(CloseableReference <CloseableImage> .CloneOrNull(closeableImage)); }
/// <summary> /// Returns a cloned reference to the stored encoded bytes. /// /// <para />The caller has to close the reference once it has finished /// using it. /// </summary> public CloseableReference <IPooledByteBuffer> GetByteBufferRef() { return(CloseableReference <IPooledByteBuffer> .CloneOrNull(_pooledByteBufferRef)); }