< Summary

Information
Class: Ice.Internal.RequestHandlerCache
Assembly: Ice
File(s): /home/runner/work/ice/ice/csharp/src/Ice/Internal/RequestHandlerCache.cs
Tag: 71_18251537082
Line coverage
100%
Covered lines: 30
Uncovered lines: 0
Coverable lines: 30
Total lines: 87
Line coverage: 100%
Branch coverage
100%
Covered branches: 16
Total branches: 16
Branch coverage: 100%
Method coverage
100%
Covered methods: 4
Total methods: 4
Method coverage: 100%

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
get_requestHandler()100%88100%
get_cachedConnection()100%44100%
.ctor(...)100%11100%
clearCachedRequestHandler(...)100%44100%

File(s)

/home/runner/work/ice/ice/csharp/src/Ice/Internal/RequestHandlerCache.cs

#LineLine coverage
 1// Copyright (c) ZeroC, Inc.
 2
 3#nullable enable
 4
 5using System.Diagnostics;
 6
 7namespace Ice.Internal;
 8
 9internal sealed class RequestHandlerCache
 10{
 11    internal RequestHandler? requestHandler
 12    {
 13        get
 14        {
 115            if (_cacheConnection)
 16            {
 117                lock (_mutex)
 18                {
 119                    if (_cachedRequestHandler != null)
 20                    {
 121                        return _cachedRequestHandler;
 22                    }
 123                }
 24            }
 25
 126            RequestHandler handler = _reference.getRequestHandler();
 127            if (_cacheConnection)
 28            {
 129                lock (_mutex)
 30                {
 131                    _cachedRequestHandler ??= handler;
 32                    // else ignore handler
 133                    return _cachedRequestHandler;
 34                }
 35            }
 36            else
 37            {
 138                return handler;
 39            }
 140        }
 41    }
 42
 43    internal Connection? cachedConnection
 44    {
 45        get
 46        {
 147            if (_cacheConnection)
 48            {
 49                RequestHandler? handler;
 150                lock (_mutex)
 51                {
 152                    handler = _cachedRequestHandler;
 153                }
 154                if (handler is not null)
 55                {
 156                    return handler.getConnection();
 57                }
 58            }
 159            return null;
 60        }
 61    }
 62
 63    private readonly Reference _reference;
 64    private readonly bool _cacheConnection;
 165    private readonly object _mutex = new();
 66    private RequestHandler? _cachedRequestHandler;
 67
 168    internal RequestHandlerCache(Reference reference)
 69    {
 170        _reference = reference;
 171        _cacheConnection = reference.getCacheConnection();
 172    }
 73
 74    internal void clearCachedRequestHandler(RequestHandler handler)
 75    {
 176        if (_cacheConnection)
 77        {
 178            lock (_mutex)
 79            {
 180                if (handler == _cachedRequestHandler)
 81                {
 182                    _cachedRequestHandler = null;
 83                }
 184            }
 85        }
 186    }
 87}