ValueCollection.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace JSONstat.IO;

/// <summary>
/// The dataset <c>value</c> property, which on the wire is either a dense
/// array (with <c>null</c> holes) or a sparse object keyed by linear index.
/// See <c>../wiki/sparse-cubes.md</c>.
/// </summary>
[JsonConverter(typeof(ValueCollectionConverter))]
public sealed class ValueCollection
{
    private readonly double?[]? _dense;
    private readonly Dictionary<string, double?>? _sparse;

    private ValueCollection(double?[]? dense, Dictionary<string, double?>? sparse)
    {
        _dense = dense;
        _sparse = sparse;
        IsSparse = dense is null;
    }

    /// <summary>True when the value is stored as a sparse object.</summary>
    public bool IsSparse { get; }

    /// <summary>The dense array, when not sparse; otherwise <c>null</c>.</summary>
    internal double?[]? DenseValues => _dense;

    /// <summary>The sparse map, when sparse; otherwise <c>null</c>.</summary>
    internal IReadOnlyDictionary<string, double?>? SparseValues => _sparse;

    /// <summary>Builds a dense value collection.</summary>
    public static ValueCollection DenseOf(double?[] values) => new ValueCollection(values, null);

    /// <summary>Builds a sparse value collection.</summary>
    public static ValueCollection SparseOf(Dictionary<string, double?> values) => new ValueCollection(null, values);

    /// <summary>Builds an empty dense value collection.</summary>
    public static ValueCollection Empty() => new ValueCollection(System.Array.Empty<double?>(), null);

    /// <summary>Returns the value at the given linear index, or <c>null</c> when missing.</summary>
    public double? GetValue(int linear)
    {
        if (IsSparse)
        {
            return _sparse != null && _sparse.TryGetValue(linear.ToString(CultureInfo.InvariantCulture), out var d)
                ? d
                : (double?)null;
        }
        if (_dense is null) return null;
        return linear >= 0 && linear < _dense.Length ? _dense[linear] : (double?)null;
    }

    /// <summary>Enumerates <paramref name="count"/> values in linear order.</summary>
    public IEnumerable<double?> Enumerate(int count)
    {
        for (int i = 0; i < count; i++) yield return GetValue(i);
    }

    /// <summary>Converts this collection to dense form (used by Dice).</summary>
    public ValueCollection ToDense(int count)
    {
        if (!IsSparse) return this;
        var arr = new double?[count];
        for (int i = 0; i < count; i++) arr[i] = GetValue(i);
        return DenseOf(arr);
    }
}

/// <summary>Reads/writes <see cref="ValueCollection"/> (array or object).</summary>
internal sealed class ValueCollectionConverter : JsonConverter<ValueCollection>
{
    public override ValueCollection Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        if (reader.TokenType == JsonTokenType.StartArray)
        {
            var list = new List<double?>();
            while (reader.Read() && reader.TokenType != JsonTokenType.EndArray)
            {
                list.Add(reader.TokenType == JsonTokenType.Null ? (double?)null : reader.GetDouble());
            }
            return ValueCollection.DenseOf(list.ToArray());
        }

        if (reader.TokenType == JsonTokenType.StartObject)
        {
            var dict = new Dictionary<string, double?>();
            while (reader.Read())
            {
                if (reader.TokenType == JsonTokenType.EndObject) break;
                string key = reader.GetString()!;
                if (!reader.Read()) throw new JsonException("Unexpected end of value object.");
                dict[key] = reader.TokenType == JsonTokenType.Null ? (double?)null : reader.GetDouble();
            }
            return ValueCollection.SparseOf(dict);
        }

        throw new JsonException("JSON-stat 'value' must be an array or an object.");
    }

    public override void Write(Utf8JsonWriter writer, ValueCollection value, JsonSerializerOptions options)
    {
        if (value.IsSparse && value.SparseValues != null)
        {
            writer.WriteStartObject();
            foreach (var kv in value.SparseValues.OrderBy(p => ParseKey(p.Key)))
            {
                writer.WritePropertyName(kv.Key);
                WriteNumber(writer, kv.Value);
            }
            writer.WriteEndObject();
            return;
        }

        writer.WriteStartArray();
        if (value.DenseValues != null)
        {
            foreach (var v in value.DenseValues) WriteNumber(writer, v);
        }
        writer.WriteEndArray();
    }

    private static int ParseKey(string key) =>
        int.TryParse(key, NumberStyles.Integer, CultureInfo.InvariantCulture, out var n) ? n : 0;

    private static void WriteNumber(Utf8JsonWriter writer, double? v)
    {
        if (v.HasValue) writer.WriteNumberValue(v.Value);
        else writer.WriteNullValue();
    }
}