< Summary

Information
Class: Hertzole.ScriptableValues.Generator.CallbackData
Assembly: Hertzole.ScriptableValues.Generator
File(s): Generator/Hertzole.ScriptableValues.Generator/Data/CallbackData.cs
Tag: 52_28197466029
Line coverage
50%
Covered lines: 62
Uncovered lines: 60
Coverable lines: 122
Total lines: 251
Line coverage: 50.8%
Branch coverage
25%
Covered branches: 16
Total branches: 63
Branch coverage: 25.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.ctor(...)50%22100%
AppendParameterTypes(...)30%101033.33%
AppendParameterDescriptions(...)16.66%6630.76%
CreateMaskName(...)100%11100%
CreateCachedFieldName(...)42.85%7766.66%
CreateRegisterMethodName(...)55.55%9968.75%
CreateTargetEventName(...)42.85%7766.66%
Equals(...)0%20200%
Equals(...)0%220%
GetHashCode()100%110%
op_Equality(...)100%110%
op_Inequality(...)100%110%

File(s)

Generator/Hertzole.ScriptableValues.Generator/Data/CallbackData.cs

#LineLine coverage
 1using System;
 2using System.Runtime.InteropServices;
 3using Microsoft.CodeAnalysis;
 4
 5namespace Hertzole.ScriptableValues.Generator;
 6
 7[StructLayout(LayoutKind.Auto)]
 8internal readonly struct CallbackData : IEquatable<CallbackData>
 9{
 10    public readonly string Name;
 11    public readonly CallbackType CallbackType;
 12    public readonly CallbackFlags Flags;
 13    public readonly ScriptableType ScriptableType;
 14    public readonly ITypeSymbol GenericType;
 15
 41516    public string MaskName { get; }
 017    public string CachedFieldName { get; }
 18
 4819    public string TargetEvent { get; }
 20
 12021    public string CallbackName { get; }
 022    public string RegisterCallbackMethod { get; }
 23
 024    public string UnregisterCallbackMethod { get; }
 25
 26    public CallbackData(string name,
 27        CallbackType callbackType,
 28        CallbackFlags flags,
 29        ISymbol memberType,
 30        ScriptableType scriptableType,
 31        ITypeSymbol genericType,
 32        string? callbackName)
 33    {
 32034        Name = name;
 32035        CallbackType = callbackType;
 32036        Flags = flags;
 32037        ScriptableType = scriptableType;
 32038        GenericType = genericType;
 32039        MaskName = CreateMaskName(name, in scriptableType, in flags);
 32040        CachedFieldName = CreateCachedFieldName(name, in scriptableType, in flags);
 32041        TargetEvent = CreateTargetEventName(in scriptableType, in flags);
 32042        RegisterCallbackMethod = CreateRegisterMethodName(true, in scriptableType, in flags);
 32043        UnregisterCallbackMethod = CreateRegisterMethodName(false, in scriptableType, in flags);
 32044        CallbackName = string.IsNullOrEmpty(callbackName) ? Naming.CreateCallbackName(name, in scriptableType, in flags)
 32045    }
 46
 47    public void AppendParameterTypes(in ArrayBuilder<(string name, string type)> builder)
 48    {
 2449        string genericType = string.Empty;
 2450        if (ScriptableType != ScriptableType.Event)
 51        {
 2452            genericType = GenericType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
 53        }
 54
 2455        switch (CallbackType)
 56        {
 57            case CallbackType.Value:
 2458                builder.Add(("oldValue", genericType));
 2459                builder.Add(("newValue", genericType));
 2460                break;
 61            case CallbackType.Event:
 062                builder.Add(("sender", "object"));
 063                builder.Add(("args", ScriptableType == ScriptableType.GenericEvent ? genericType : "global::System.Event
 064                break;
 65            case CallbackType.Collection:
 066                using (ArrayBuilder<char> nameBuilder = new ArrayBuilder<char>(57 + genericType.Length))
 67                {
 068                    nameBuilder.AddRange("global::Hertzole.ScriptableValues.CollectionChangedArgs<");
 069                    nameBuilder.AddRange(genericType);
 070                    nameBuilder.Add('>');
 71
 072                    builder.Add(("args", nameBuilder.ToString()));
 073                }
 74
 75                break;
 76            case CallbackType.Pool:
 077                builder.Add(("action", "global::Hertzole.ScriptableValues.PoolAction"));
 078                builder.Add(("item", genericType));
 079                break;
 80            default:
 081                throw new ArgumentOutOfRangeException();
 82        }
 083    }
 84
 85    public void AppendParameterDescriptions(in ArrayBuilder<(string name, string description)> builder)
 86    {
 2487        switch (CallbackType)
 88        {
 89            case CallbackType.Value:
 2490                builder.Add(("oldValue", DocumentationHelper.GetOldValueDescription(Flags)));
 2491                builder.Add(("newValue", DocumentationHelper.GetNewValueDescription(Flags)));
 2492                break;
 93            case CallbackType.Event:
 094                builder.Add(("sender", DocumentationHelper.EVENT_SENDER));
 095                builder.Add(("args", DocumentationHelper.EVENT_ARGS));
 096                break;
 97            case CallbackType.Collection:
 098                builder.Add(("args", DocumentationHelper.COLLECTION_ARGS));
 099                break;
 100            case CallbackType.Pool:
 0101                builder.Add(("action", DocumentationHelper.POOL_ACTION));
 0102                builder.Add(("item", DocumentationHelper.POOL_ITEM));
 0103                break;
 104            default:
 0105                throw new ArgumentOutOfRangeException();
 106        }
 107    }
 108
 109    private static string CreateMaskName(string name, in ScriptableType scriptableType, in CallbackFlags flags)
 110    {
 320111        using ArrayBuilder<char> builder = new ArrayBuilder<char>(32);
 112
 320113        builder.AddRange(name);
 320114        Naming.AppendFlagSuffix(in builder, in scriptableType, in flags);
 115
 320116        return builder.ToString();
 320117    }
 118
 119    private static string CreateCachedFieldName(string name, in ScriptableType scriptableType, in CallbackFlags flags)
 120    {
 320121        using ArrayBuilder<char> builder = new ArrayBuilder<char>(32);
 122
 320123        builder.AddRange(name);
 124
 320125        switch (scriptableType)
 126        {
 127            case ScriptableType.Value:
 25128                builder.AddRange("ScriptableValueCallback");
 25129                Naming.AppendFlagSuffix(in builder, in scriptableType, in flags);
 25130                break;
 131            case ScriptableType.Event:
 132            case ScriptableType.GenericEvent:
 295133                builder.AddRange("ScriptableEventCallback");
 295134                break;
 135            case ScriptableType.List:
 136            case ScriptableType.Dictionary:
 0137                builder.AddRange("ScriptableCollectionChanged");
 0138                break;
 139            case ScriptableType.Pool:
 0140                builder.AddRange("ScriptablePoolCallback");
 0141                break;
 142            default:
 0143                throw new ArgumentOutOfRangeException(nameof(scriptableType), scriptableType, null);
 144        }
 145
 320146        return builder.ToString();
 320147    }
 148
 149    private static string CreateRegisterMethodName(bool subscribe, in ScriptableType scriptableType, in CallbackFlags fl
 150    {
 640151        using ArrayBuilder<char> builder = new ArrayBuilder<char>(32);
 152
 640153        builder.AddRange(subscribe ? "Register" : "Unregister");
 640154        switch (scriptableType)
 155        {
 156            case ScriptableType.Value:
 50157                builder.AddRange("Value");
 50158                Naming.AppendFlagSuffix(in builder, in scriptableType, in flags);
 50159                builder.AddRange("Listener");
 50160                break;
 161            case ScriptableType.Event:
 162            case ScriptableType.GenericEvent:
 590163                builder.AddRange("InvokedListener");
 590164                break;
 165            case ScriptableType.List:
 166            case ScriptableType.Dictionary:
 0167                builder.AddRange("ChangedListener");
 0168                break;
 169            case ScriptableType.Pool:
 0170                builder.AddRange("ChangedCallback");
 0171                break;
 172            default:
 0173                throw new ArgumentOutOfRangeException(nameof(scriptableType), scriptableType, null);
 174        }
 175
 640176        return builder.ToString();
 640177    }
 178
 179    private static string CreateTargetEventName(in ScriptableType scriptableType, in CallbackFlags flags)
 180    {
 320181        using ArrayBuilder<char> builder = new ArrayBuilder<char>(32);
 320182        builder.AddRange("On");
 320183        switch (scriptableType)
 184        {
 185            case ScriptableType.Event:
 186            case ScriptableType.GenericEvent:
 295187                builder.AddRange("Invoked");
 295188                break;
 189            case ScriptableType.Value:
 25190                builder.AddRange("Value");
 25191                Naming.AppendFlagSuffix(in builder, in scriptableType, in flags);
 25192                break;
 193            case ScriptableType.Pool:
 0194                builder.AddRange("PoolChanged");
 0195                break;
 196            case ScriptableType.List:
 197            case ScriptableType.Dictionary:
 0198                builder.AddRange("CollectionChanged");
 0199                break;
 200            default:
 0201                throw new ArgumentOutOfRangeException(nameof(scriptableType), scriptableType, null);
 202        }
 203
 320204        return builder.ToString();
 320205    }
 206
 207    /// <inheritdoc />
 208    public bool Equals(CallbackData other)
 209    {
 0210        return CallbackType == other.CallbackType && Flags == other.Flags && ScriptableType == other.ScriptableType && N
 0211               GenericType.Equals(other.GenericType, SymbolEqualityComparer.Default) && MaskName == other.MaskName &&
 0212               CachedFieldName == other.CachedFieldName && TargetEvent == other.TargetEvent && CallbackName == other.Cal
 0213               RegisterCallbackMethod == other.RegisterCallbackMethod && UnregisterCallbackMethod == other.UnregisterCal
 214    }
 215
 216    /// <inheritdoc />
 217    public override bool Equals(object? obj)
 218    {
 0219        return obj is CallbackData other && Equals(other);
 220    }
 221
 222    /// <inheritdoc />
 223    public override int GetHashCode()
 224    {
 225        unchecked
 226        {
 0227            int hashCode = Name.GetHashCode();
 0228            hashCode = (hashCode * 397) ^ (int) CallbackType;
 0229            hashCode = (hashCode * 397) ^ (int) Flags;
 0230            hashCode = (hashCode * 397) ^ (int) ScriptableType;
 0231            hashCode = (hashCode * 397) ^ SymbolEqualityComparer.Default.GetHashCode(GenericType);
 0232            hashCode = (hashCode * 397) ^ MaskName.GetHashCode();
 0233            hashCode = (hashCode * 397) ^ CachedFieldName.GetHashCode();
 0234            hashCode = (hashCode * 397) ^ TargetEvent.GetHashCode();
 0235            hashCode = (hashCode * 397) ^ CallbackName.GetHashCode();
 0236            hashCode = (hashCode * 397) ^ RegisterCallbackMethod.GetHashCode();
 0237            hashCode = (hashCode * 397) ^ UnregisterCallbackMethod.GetHashCode();
 0238            return hashCode;
 239        }
 240    }
 241
 242    public static bool operator ==(CallbackData left, CallbackData right)
 243    {
 0244        return left.Equals(right);
 245    }
 246
 247    public static bool operator !=(CallbackData left, CallbackData right)
 248    {
 0249        return !left.Equals(right);
 250    }
 251}
Generated by: ReportGenerator 5.5.10.0
06/25/2026 - 20:21:10
GitHub | reportgenerator.io

Methods/Properties

MaskName()
CachedFieldName()
TargetEvent()
CallbackName()
RegisterCallbackMethod()
UnregisterCallbackMethod()
.ctor(System.String,Hertzole.ScriptableValues.Generator.CallbackType,Hertzole.ScriptableValues.Generator.CallbackFlags,Microsoft.CodeAnalysis.ISymbol,Hertzole.ScriptableValues.Generator.ScriptableType,Microsoft.CodeAnalysis.ITypeSymbol,System.String)
AppendParameterTypes(Hertzole.ScriptableValues.Generator.ArrayBuilder`1<System.ValueTuple`2<System.String,System.String>>&)
AppendParameterDescriptions(Hertzole.ScriptableValues.Generator.ArrayBuilder`1<System.ValueTuple`2<System.String,System.String>>&)
CreateMaskName(System.String,Hertzole.ScriptableValues.Generator.ScriptableType&,Hertzole.ScriptableValues.Generator.CallbackFlags&)
CreateCachedFieldName(System.String,Hertzole.ScriptableValues.Generator.ScriptableType&,Hertzole.ScriptableValues.Generator.CallbackFlags&)
CreateRegisterMethodName(System.Boolean,Hertzole.ScriptableValues.Generator.ScriptableType&,Hertzole.ScriptableValues.Generator.CallbackFlags&)
CreateTargetEventName(Hertzole.ScriptableValues.Generator.ScriptableType&,Hertzole.ScriptableValues.Generator.CallbackFlags&)
Equals(Hertzole.ScriptableValues.Generator.CallbackData)
Equals(System.Object)
GetHashCode()
op_Equality(Hertzole.ScriptableValues.Generator.CallbackData,Hertzole.ScriptableValues.Generator.CallbackData)
op_Inequality(Hertzole.ScriptableValues.Generator.CallbackData,Hertzole.ScriptableValues.Generator.CallbackData)