5906957651

Committed 18 Aug 2023 08:47PM UTC coverage: 95.495% (-0.2%) from 95.678%

Build # 5906957651

Build Type

push

github

Committed by

web-flow

Commit Message

fix typo (#380)

Run Details

752 of 838 branches covered (89.74%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

8 existing lines in 2 files now uncovered.

3424 of 3535 relevant lines covered (96.86%)

3376336.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.94

/BitFaster.Caching/Scoped.cs

﻿using System;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Threading;

namespace BitFaster.Caching
{
    /// <summary>
    /// A lifetime scope for IDisposable objects stored in a cache. If the object is used in a long
    /// running operation and disposed by a cache, the scope can create a lifetime that prevents
    /// the wrapped object from being diposed until the calling code completes.
    /// </summary>
    /// <typeparam name="T">The type of scoped value.</typeparam>
    [DebuggerTypeProxy(typeof(Scoped<>.ScopedDebugView))]
    [DebuggerDisplay("{FormatDebug(),nq}")]
    public sealed class Scoped<T> : IScoped<T>, IDisposable where T : IDisposable
    {
        private ReferenceCount<T> refCount;
        private bool isDisposed;

        /// <summary>
        /// Initializes a new Scoped value.
        /// </summary>
        /// <param name="value">The value to scope.</param>
        public Scoped(T value)
        {
            this.refCount = new ReferenceCount<T>(value);
        }

        /// <summary>
        /// Gets a value indicating whether the scope is disposed.
        /// </summary>
        public bool IsDisposed => isDisposed;

        /// <summary>
        /// Attempts to create a lifetime for the scoped value. The lifetime guarantees the value is alive until 
        /// the lifetime is disposed.
        /// </summary>
        /// <param name="lifetime">When this method returns, contains the Lifetime that was created, or the default value of the type if the operation failed.</param>
        /// <returns>true if the Lifetime was created; otherwise false.</returns>
        public bool TryCreateLifetime(out Lifetime<T> lifetime)
        {
            while (true)
            {
                var oldRefCount = this.refCount;

                // If old ref count is 0, the scoped object has been disposed and there was a race.
                if (this.isDisposed || oldRefCount.Count == 0)
                {
                    lifetime = default;
                    return false;
                }

                if (oldRefCount == Interlocked.CompareExchange(ref this.refCount, oldRefCount.IncrementCopy(), oldRefCount))
                {
                    // When Lifetime is disposed, it calls DecrementReferenceCount
                    lifetime = new Lifetime<T>(oldRefCount, this.DecrementReferenceCount);
                    return true;
                }
            }
        }

        /// <summary>
        /// Creates a lifetime for the scoped value. The lifetime guarantees the value is alive until 
        /// the lifetime is disposed.
        /// </summary>
        /// <returns>A value lifetime.</returns>
        /// <exception cref="ObjectDisposedException">The scope is disposed.</exception>
        public Lifetime<T> CreateLifetime()
        {
            if (!TryCreateLifetime(out var lifetime))
            {
                Throw.Disposed<T>();
            }

            return lifetime;
        }

        private void DecrementReferenceCount()
        {
            while (true)
            {
                var oldRefCount = this.refCount;

                if (oldRefCount == Interlocked.CompareExchange(ref this.refCount, oldRefCount.DecrementCopy(), oldRefCount))
                {
                    if (this.refCount.Count == 0)
                    {
                        this.refCount.Value?.Dispose();
                    }

                    break;
                }
            }
        }

        /// <summary>
        /// Terminates the scope and disposes the value. Once the scope is terminated, it is no longer
        /// possible to create new lifetimes for the value.
        /// </summary>
        public void Dispose()
        {
            if (!this.isDisposed)
            {
                this.DecrementReferenceCount();
                this.isDisposed = true;
            }
        }

        [ExcludeFromCodeCoverage]
        internal string FormatDebug()
        {
            if (IsDisposed)
            {
                return "[Disposed Scope]";
            }

            return this.refCount.Value?.ToString();
        }

        [ExcludeFromCodeCoverage]
        internal class ScopedDebugView
        {
            private readonly Scoped<T> scoped;

            public ScopedDebugView(Scoped<T> scoped)
            {
                if (scoped is null)
                {
                    Throw.ArgNull(ExceptionArgument.scoped);
                }

                this.scoped = scoped;
            }

            public bool IsDisposed => this.scoped.IsDisposed;

            public T Value => this.scoped.refCount.Value;
        }
    }
}

1	using System;
2	using System.Diagnostics;
3	using System.Diagnostics.CodeAnalysis;
4	using System.Threading;
5
6	namespace BitFaster.Caching
7	{
8	/// <summary>
9	/// A lifetime scope for IDisposable objects stored in a cache. If the object is used in a long
10	/// running operation and disposed by a cache, the scope can create a lifetime that prevents
11	/// the wrapped object from being diposed until the calling code completes.
12	/// </summary>
13	/// <typeparam name="T">The type of scoped value.</typeparam>
14	[DebuggerTypeProxy(typeof(Scoped<>.ScopedDebugView))]
15	[DebuggerDisplay("{FormatDebug(),nq}")]
16	public sealed class Scoped<T> : IScoped<T>, IDisposable where T : IDisposable
17	{
18	private ReferenceCount<T> refCount;
19	private bool isDisposed;
20
21	/// <summary>
22	/// Initializes a new Scoped value.
23	/// </summary>
24	/// <param name="value">The value to scope.</param>
25	public Scoped(T value)	302✔
26	{	302✔
27	this.refCount = new ReferenceCount<T>(value);	302✔
28	}	302✔
29
30	/// <summary>
31	/// Gets a value indicating whether the scope is disposed.
32	/// </summary>
33	public bool IsDisposed => isDisposed;	82✔
34
35	/// <summary>
36	/// Attempts to create a lifetime for the scoped value. The lifetime guarantees the value is alive until
37	/// the lifetime is disposed.
38	/// </summary>
39	/// <param name="lifetime">When this method returns, contains the Lifetime that was created, or the default value of the type if the operation failed.</param>
40	/// <returns>true if the Lifetime was created; otherwise false.</returns>
41	public bool TryCreateLifetime(out Lifetime<T> lifetime)
42	{	222✔
43	while (true)	222✔
44	{	222✔
45	var oldRefCount = this.refCount;	222✔
46
47	// If old ref count is 0, the scoped object has been disposed and there was a race.
48	if (this.isDisposed \|\| oldRefCount.Count == 0)	222✔
49	{	58✔
50	lifetime = default;	58✔
51	return false;	58✔
52	}
53
54	if (oldRefCount == Interlocked.CompareExchange(ref this.refCount, oldRefCount.IncrementCopy(), oldRefCount))	164!
55	{	164✔
56	// When Lifetime is disposed, it calls DecrementReferenceCount
57	lifetime = new Lifetime<T>(oldRefCount, this.DecrementReferenceCount);	164✔
58	return true;	164✔
59	}
UNCOV 60	}	×
61	}	222✔
62
63	/// <summary>
64	/// Creates a lifetime for the scoped value. The lifetime guarantees the value is alive until
65	/// the lifetime is disposed.
66	/// </summary>
67	/// <returns>A value lifetime.</returns>
68	/// <exception cref="ObjectDisposedException">The scope is disposed.</exception>
69	public Lifetime<T> CreateLifetime()
70	{	40✔
71	if (!TryCreateLifetime(out var lifetime))	40✔
72	{	2✔
73	Throw.Disposed<T>();	2✔
74	}	×
75
76	return lifetime;	38✔
77	}	38✔
78
79	private void DecrementReferenceCount()
80	{	136✔
81	while (true)	136✔
82	{	136✔
83	var oldRefCount = this.refCount;	136✔
84
85	if (oldRefCount == Interlocked.CompareExchange(ref this.refCount, oldRefCount.DecrementCopy(), oldRefCount))	136!
86	{	136✔
87	if (this.refCount.Count == 0)	136✔
88	{	110✔
89	this.refCount.Value?.Dispose();	110✔
90	}	110✔
91
92	break;	136✔
93	}
94	}	×
95	}	136✔
96
97	/// <summary>
98	/// Terminates the scope and disposes the value. Once the scope is terminated, it is no longer
99	/// possible to create new lifetimes for the value.
100	/// </summary>
101	public void Dispose()
102	{	124✔
103	if (!this.isDisposed)	124✔
104	{	118✔
105	this.DecrementReferenceCount();	118✔
106	this.isDisposed = true;	118✔
107	}	118✔
108	}	124✔
109
110	[ExcludeFromCodeCoverage]
111	internal string FormatDebug()
112	{
113	if (IsDisposed)
114	{
115	return "[Disposed Scope]";
116	}
117
118	return this.refCount.Value?.ToString();
119	}
120
121	[ExcludeFromCodeCoverage]
122	internal class ScopedDebugView
123	{
124	private readonly Scoped<T> scoped;
125
126	public ScopedDebugView(Scoped<T> scoped)
127	{
128	if (scoped is null)
129	{
130	Throw.ArgNull(ExceptionArgument.scoped);
131	}
132
133	this.scoped = scoped;
134	}
135
136	public bool IsDisposed => this.scoped.IsDisposed;
137
138	public T Value => this.scoped.refCount.Value;
139	}
140	}
141	}

bitfaster / BitFaster.Caching / 5906957651

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous