< Summary

Class:Kemocade.Vrc.Data.Extensions.DataDictionaryExtensions
Assembly:Kemocade.Vrc.Data.Extensions
File(s):File 1: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/GetValue.cs
File 2: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/GetValues.cs
File 3: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/SelectValues.cs
File 4: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/Shared.cs
File 5: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/TryGetValue.cs
File 6: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/TryGetValues.cs
File 7: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/TryGetValueToken.cs
File 8: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/TrySerializeToJson.cs
File 9: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/WhereValueDoesNotEqual.cs
File 10: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/WhereValueEquals.cs
File 11: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/WhereValuesContain.cs
File 12: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/WhereValuesContainAll.cs
File 13: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/WhereValuesContainAny.cs
File 14: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/WhereValuesContainNone.cs
File 15: /github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/WhereValuesDoNotContain.cs
Covered lines:134
Uncovered lines:0
Coverable lines:134
Total lines:328
Line coverage:100% (134 of 134)
Covered branches:0
Total branches:0
Covered methods:19
Total methods:19
Method coverage:100% (19 of 19)

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
File 1: GetValue[T](...)0%000100%
File 2: GetValues[T](...)0%000100%
File 3: SelectValues[T](...)0%00086.67%
File 4: Fit[T](...)0%000100%
File 4: Contains[T](...)0%000100%
File 4: ContainsNone[T](...)0%000100%
File 4: ContainsAll[T](...)0%000100%
File 4: ContainsAny[T](...)0%000100%
File 5: TryGetValue[T](...)0%000100%
File 6: TryGetValues[T](...)0%000100%
File 7: TryGetValueToken(...)0%000100%
File 8: TrySerializeToJson(...)0%000100%
File 9: WhereValueDoesNotEqual[T](...)0%000100%
File 10: WhereValueEquals[T](...)0%000100%
File 11: WhereValuesContain[T](...)0%000100%
File 12: WhereValuesContainAll[T](...)0%00088.89%
File 13: WhereValuesContainAny[T](...)0%00088.89%
File 14: WhereValuesContainNone[T](...)0%00088.89%
File 15: WhereValuesDoNotContain[T](...)0%000100%

File(s)

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/GetValue.cs

#LineLine coverage
 1using VRC.SDK3.Data;
 2using static Kemocade.Vrc.Data.Extensions.Shared;
 3
 4namespace Kemocade.Vrc.Data.Extensions
 5{
 6    public static partial class DataDictionaryExtensions
 7    {
 8        public static T GetValue<T>
 9        (this DataDictionary source, string key, char split = DOT) =>
 210            source.TryGetValue(key, out T result, split) ?
 11            result : ForceException<T>();
 12    }
 13}

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/GetValues.cs

#LineLine coverage
 1using VRC.SDK3.Data;
 2using static Kemocade.Vrc.Data.Extensions.Shared;
 3
 4namespace Kemocade.Vrc.Data.Extensions
 5{
 6  public static partial class DataDictionaryExtensions
 7  {
 8    public static T[] GetValues<T>
 9    (this DataDictionary source, string key, char split = DOT) =>
 210      source.TryGetValues(key, out T[] result, split) ?
 11      result : ForceException<T[]>();
 12  }
 13}

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/SelectValues.cs

#LineLine coverage
 1using VRC.SDK3.Data;
 2
 3namespace Kemocade.Vrc.Data.Extensions
 4{
 5    public static partial class DataDictionaryExtensions
 6    {
 7        public static T[] SelectValues<T>
 8        (this DataDictionary[] dicts, string key, char split = DOT)
 39        {
 310            T[] matches = new T[dicts.Length];
 311            int matchesCount = 0;
 2912            foreach (DataDictionary dict in dicts)
 1013            {
 1014                if (!dict.TryGetValue(key, out T child, split)) { continue; }
 1015                matches[matchesCount++] = child;
 1016            }
 17
 318            return Fit(matches, matchesCount);
 319        }
 20    }
 21}

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/Shared.cs

#LineLine coverage
 1using VRC.Core;
 2
 3namespace Kemocade.Vrc.Data.Extensions
 4{
 5    public static partial class DataDictionaryExtensions
 6    {
 7        const char DOT = '.';
 8        private static T[] Fit<T>(T[] source, int count)
 169        {
 10            // No need to make a copy
 2411            if (source.Length == count) { return source; }
 12
 13            // Shrink the array if needed
 1214            T[] copy = new T[count];
 1215            System.Array.Copy(source, copy, count);
 1216            return copy;
 1617        }
 18
 19        private static bool Contains<T>(T[] source, T target)
 4620        {
 26321            foreach (T t in source)
 7422            {
 12023                if (t.Equals(target)) { return true; }
 5124            }
 2325            return false;
 4626        }
 27
 28        private static bool ContainsNone<T>(T[] source, T[] targets)
 2929        {
 14430            foreach (T target in targets)
 3831            {
 7632                if (Contains(source, target)) { return false; }
 1933            }
 1034            return true;
 2935        }
 36
 37        private static bool ContainsAll<T>(T[] source, T[] targets)
 538        {
 2739            foreach (T target in targets)
 840            {
 1641                if (!Contains(source, target)) { return false; }
 442            }
 143            return true;
 544        }
 45
 46        private static bool ContainsAny<T>(T[] source, T[] targets) =>
 1947            !ContainsNone(source, targets);
 48    }
 49}

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/TryGetValue.cs

#LineLine coverage
 1using VRC.SDK3.Data;
 2
 3namespace Kemocade.Vrc.Data.Extensions
 4{
 5    public static partial class DataDictionaryExtensions
 6    {
 7        public static bool TryGetValue<T>
 8        (this DataDictionary source, string key, out T result, char split = DOT)
 439        {
 4310            if (!source.TryGetValueToken(key, out DataToken token, split))
 711            {
 712                result = default;
 713                return false;
 14            }
 15
 3616            return token.TryCast(out result);
 4317        }
 18    }
 19}

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/TryGetValues.cs

#LineLine coverage
 1using VRC.SDK3.Data;
 2
 3namespace Kemocade.Vrc.Data.Extensions
 4{
 5    public static partial class DataDictionaryExtensions
 6    {
 7        public static bool TryGetValues<T>
 8        (this DataDictionary root, string key, out T[] result, char split = DOT)
 539        {
 5310            if (!root.TryGetValueToken(key, out DataToken token, split))
 211            {
 212                result = default;
 213                return false;
 14            }
 15
 5116            return token.TryCastArray(out result);
 5317        }
 18    }
 19}

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/TryGetValueToken.cs

#LineLine coverage
 1using VRC.SDK3.Data;
 2
 3namespace Kemocade.Vrc.Data.Extensions
 4{
 5    public static partial class DataDictionaryExtensions
 6    {
 7        public static bool TryGetValueToken
 8        (this DataDictionary root, string key, out DataToken result, char split = DOT)
 979        {
 9710            string[] keys = key.Split(split);
 11
 12            // Process multiple keys if present
 9713            if ( keys.Length > 1)
 714            {
 15                // If more than one key is provided, move down sub-dictionaries
 2016                for (int i = 0; i < keys.Length - 1; i++)
 717                {
 718                    if (!root.TryGetValue(keys[i], TokenType.DataDictionary, out DataToken next))
 419                    {
 420                        result = default;
 421                        return false;
 22                    }
 323                    root = next.DataDictionary;
 324                }
 25
 26                // Get the final key
 327                key = keys[keys.Length - 1];
 328            }
 29
 30            // Get the final value
 9331            return root.TryGetValue(key, out result);
 9732        }
 33    }
 34}

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/TrySerializeToJson.cs

#LineLine coverage
 1using VRC.SDK3.Data;
 2using static VRC.SDK3.Data.JsonExportType;
 3
 4namespace Kemocade.Vrc.Data.Extensions
 5{
 6    public static partial class DataDictionaryExtensions
 7    {
 8        public static bool TrySerializeToJson(this DataDictionary[] dicts, out string result)
 29        {
 210            DataList dictsList = new DataList();
 3611            foreach (DataDictionary dict in dicts) { dictsList.Add(dict); }
 12
 213            if (!VRCJson.TrySerializeToJson(dictsList, Beautify, out DataToken resultToken))
 114            {
 115                result = null;
 116                return false;
 17            }
 18
 119            result = resultToken.String;
 120            return true;
 221        }
 22    }
 23}

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/WhereValueDoesNotEqual.cs

#LineLine coverage
 1using VRC.SDK3.Data;
 2
 3namespace Kemocade.Vrc.Data.Extensions
 4{
 5    public static partial class DataDictionaryExtensions
 6    {
 7        public static DataDictionary[] WhereValueDoesNotEqual<T>
 8        (this DataDictionary[] dicts, string key, T target, char split = DOT)
 19        {
 110            DataDictionary[] matches = new DataDictionary[dicts.Length];
 111            int matchesCount = 0;
 1312            foreach (DataDictionary dict in dicts)
 513            {
 514                if
 15                (
 16                    !dict.TryGetValue(key, out T child, split) ||
 17                    child.Equals(target)
 18                )
 219                { continue; }
 420                matches[matchesCount++] = dict;
 421            }
 22
 123            return Fit(matches, matchesCount);
 124        }
 25    }
 26}

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/WhereValueEquals.cs

#LineLine coverage
 1using VRC.SDK3.Data;
 2
 3namespace Kemocade.Vrc.Data.Extensions
 4{
 5    public static partial class DataDictionaryExtensions
 6    {
 7        public static DataDictionary[] WhereValueEquals<T>
 8        (this DataDictionary[] dicts, string key, T target, char split = DOT)
 49        {
 410            DataDictionary[] matches = new DataDictionary[dicts.Length];
 411            int matchesCount = 0;
 4412            foreach (DataDictionary dict in dicts)
 1613            {
 1614                if
 15                (
 16                    !dict.TryGetValue(key, out T child, split) ||
 17                    !child.Equals(target)
 18                )
 2219                { continue; }
 520                matches[matchesCount++] = dict;
 521            }
 22
 423            return Fit(matches, matchesCount);
 424        }
 25    }
 26}

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/WhereValuesContain.cs

#LineLine coverage
 1using VRC.SDK3.Data;
 2
 3namespace Kemocade.Vrc.Data.Extensions
 4{
 5    public static partial class DataDictionaryExtensions
 6    {
 7        public static DataDictionary[] WhereValuesContain<T>
 8        (this DataDictionary[] dicts, string key, T target, char split = DOT) =>
 39            dicts.WhereValuesContainAny(key, new T[] { target }, split);
 10    }
 11}

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/WhereValuesContainAll.cs

#LineLine coverage
 1using VRC.SDK3.Data;
 2
 3namespace Kemocade.Vrc.Data.Extensions
 4{
 5    public static partial class DataDictionaryExtensions
 6    {
 7        public static DataDictionary[] WhereValuesContainAll<T>
 8        (this DataDictionary[] dicts, string key, T[] targets, char split = DOT)
 19        {
 110            DataDictionary[] matches = new DataDictionary[dicts.Length];
 111            int matchesCount = 0;
 1312            foreach (DataDictionary dict in dicts)
 513            {
 514                if (!dict.TryGetValues(key, out T[] children, split)) { continue; }
 815                if (ContainsAll(children, targets)) { matches[matchesCount++] = dict; }
 516            }
 17
 118            return Fit(matches, matchesCount);
 119        }
 20    }
 21}

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/WhereValuesContainAny.cs

#LineLine coverage
 1using VRC.SDK3.Data;
 2
 3namespace Kemocade.Vrc.Data.Extensions
 4{
 5    public static partial class DataDictionaryExtensions
 6    {
 7        public static DataDictionary[] WhereValuesContainAny<T>
 8        (this DataDictionary[] dicts, string key, T[] targets, char split = DOT)
 59        {
 510            DataDictionary[] matches = new DataDictionary[dicts.Length];
 511            int matchesCount = 0;
 5312            foreach (DataDictionary dict in dicts)
 1913            {
 1914                if (!dict.TryGetValues(key, out T[] children, split)) { continue; }
 5815                if (ContainsAny(children, targets)) { matches[matchesCount++] = dict; }
 1916            }
 17
 518            return Fit(matches, matchesCount);
 519        }
 20    }
 21}

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/WhereValuesContainNone.cs

#LineLine coverage
 1using VRC.SDK3.Data;
 2
 3namespace Kemocade.Vrc.Data.Extensions
 4{
 5    public static partial class DataDictionaryExtensions
 6    {
 7        public static DataDictionary[] WhereValuesContainNone<T>
 8        (this DataDictionary[] dicts, string key, T[] targets, char split = DOT)
 29        {
 210            DataDictionary[] matches = new DataDictionary[dicts.Length];
 211            int matchesCount = 0;
 2612            foreach (DataDictionary dict in dicts)
 1013            {
 1014                if (!dict.TryGetValues(key, out T[] children, split)) { continue; }
 2215                if (ContainsNone(children, targets)) { matches[matchesCount++] = dict; }
 1016            }
 17
 218            return Fit(matches, matchesCount);
 219        }
 20    }
 21}

/github/workspace/TestProject/Assets/com.kemocade.vrc.data.extensions/Runtime/DataDictionaryExtensions/WhereValuesDoNotContain.cs

#LineLine coverage
 1using VRC.SDK3.Data;
 2
 3namespace Kemocade.Vrc.Data.Extensions
 4{
 5    public static partial class DataDictionaryExtensions
 6    {
 7        public static DataDictionary[] WhereValuesDoNotContain<T>
 8        (this DataDictionary[] dicts, string key, T target, char split = DOT) =>
 19            dicts.WhereValuesContainNone(key, new T[] { target }, split);
 10    }
 11}