ShardKeyValue.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;

namespace kinetica.Records;

    public enum ShardKeyValueType
    {
        Null,
        Int,
        Long,
        Float,
        Double,
        String,
        Date,
        DateTime,
        Time,
        Ipv4,
        Decimal,
        Boolean,
        Int8,
        Int16,
        Timestamp,
        Uuid,
        Ulong
    }

    public readonly struct ShardKeyValue : IEquatable<ShardKeyValue>
    {
        private readonly ShardKeyValueType _type;
        private readonly long _intValue;
        private readonly double _floatValue;
        private readonly string? _stringValue;

        private ShardKeyValue(ShardKeyValueType type, long intValue = 0, double floatValue = 0, string? stringValue = null)
        {
            _type = type;
            _intValue = intValue;
            _floatValue = floatValue;
            _stringValue = stringValue;
        }

        public ShardKeyValueType Type => _type;

        public bool IsNull => _type == ShardKeyValueType.Null;

        #region Factory Methods (Equivalent to Rust enum variants)

        public static ShardKeyValue Null() => new(ShardKeyValueType.Null);

        public static ShardKeyValue Int(int value) => new(ShardKeyValueType.Int, value);

        public static ShardKeyValue Long(long value) => new(ShardKeyValueType.Long, value);

        public static ShardKeyValue Float(float value) => new(ShardKeyValueType.Float, floatValue: value);

        public static ShardKeyValue Double(double value) => new(ShardKeyValueType.Double, floatValue: value);

        public static ShardKeyValue String(string value) => new(ShardKeyValueType.String, stringValue: value);

        public static ShardKeyValue Date(string value) => new(ShardKeyValueType.Date, stringValue: value);

        public static ShardKeyValue DateTime(string value) => new(ShardKeyValueType.DateTime, stringValue: value);

        public static ShardKeyValue Time(string value) => new(ShardKeyValueType.Time, stringValue: value);

        public static ShardKeyValue Ipv4(string value) => new(ShardKeyValueType.Ipv4, stringValue: value);

        public static ShardKeyValue Decimal(string value) => new(ShardKeyValueType.Decimal, stringValue: value);

        public static ShardKeyValue Boolean(bool value) => new(ShardKeyValueType.Boolean, value ? 1 : 0);

        public static ShardKeyValue Int8(sbyte value) => new(ShardKeyValueType.Int8, value);

        public static ShardKeyValue Int16(short value) => new(ShardKeyValueType.Int16, value);

        public static ShardKeyValue Timestamp(long value) => new(ShardKeyValueType.Timestamp, value);

        public static ShardKeyValue Uuid(string value) => new(ShardKeyValueType.Uuid, stringValue: value);

        public static ShardKeyValue Ulong(string value) => new(ShardKeyValueType.Ulong, stringValue: value);

        #endregion

        #region Value Accessors

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public int AsInt()
        {
            return _type switch
            {
                ShardKeyValueType.Int or ShardKeyValueType.Int8 or ShardKeyValueType.Int16 or ShardKeyValueType.Boolean
                    => (int)_intValue,
                _ => throw new InvalidOperationException($"Cannot convert {_type} to Int")
            };
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public long AsLong()
        {
            return _type switch
            {
                ShardKeyValueType.Long or ShardKeyValueType.Timestamp or
                ShardKeyValueType.Int or ShardKeyValueType.Int8 or ShardKeyValueType.Int16 or ShardKeyValueType.Boolean
                    => _intValue,
                _ => throw new InvalidOperationException($"Cannot convert {_type} to Long")
            };
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public float AsFloat()
        {
            return _type switch
            {
                ShardKeyValueType.Float => (float)_floatValue,
                _ => throw new InvalidOperationException($"Cannot convert {_type} to Float")
            };
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public double AsDouble()
        {
            return _type switch
            {
                ShardKeyValueType.Double or ShardKeyValueType.Float => _floatValue,
                _ => throw new InvalidOperationException($"Cannot convert {_type} to Double")
            };
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public string? AsString()
        {
            return _type switch
            {
                ShardKeyValueType.String or ShardKeyValueType.Date or ShardKeyValueType.DateTime or
                ShardKeyValueType.Time or ShardKeyValueType.Ipv4 or ShardKeyValueType.Decimal or
                ShardKeyValueType.Uuid or ShardKeyValueType.Ulong
                    => _stringValue,
                ShardKeyValueType.Null => null,
                _ => throw new InvalidOperationException($"Cannot convert {_type} to String")
            };
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool AsBool()
        {
            return _type switch
            {
                ShardKeyValueType.Boolean => _intValue != 0,
                _ => throw new InvalidOperationException($"Cannot convert {_type} to Boolean")
            };
        }

        public bool TryGetInt(out int value)
        {
            if (_type is ShardKeyValueType.Int or ShardKeyValueType.Int8 or ShardKeyValueType.Int16 or ShardKeyValueType.Boolean)
            {
                value = (int)_intValue;
                return true;
            }
            value = default;
            return false;
        }

        public bool TryGetLong(out long value)
        {
            if (_type is ShardKeyValueType.Long or ShardKeyValueType.Timestamp or
                ShardKeyValueType.Int or ShardKeyValueType.Int8 or ShardKeyValueType.Int16 or ShardKeyValueType.Boolean)
            {
                value = _intValue;
                return true;
            }
            value = default;
            return false;
        }

        public bool TryGetString(out string? value)
        {
            if (_type is ShardKeyValueType.String or ShardKeyValueType.Date or ShardKeyValueType.DateTime or
                ShardKeyValueType.Time or ShardKeyValueType.Ipv4 or ShardKeyValueType.Decimal or
                ShardKeyValueType.Uuid or ShardKeyValueType.Ulong or ShardKeyValueType.Null)
            {
                value = _stringValue;
                return true;
            }
            value = default;
            return false;
        }

        #endregion

        #region Equality and Hashing

        public bool Equals(ShardKeyValue other)
        {
            if (_type != other._type) return false;

            return _type switch
            {
                ShardKeyValueType.Null => true,
                ShardKeyValueType.Int or ShardKeyValueType.Long or ShardKeyValueType.Int8 or
                ShardKeyValueType.Int16 or ShardKeyValueType.Boolean or ShardKeyValueType.Timestamp
                    => _intValue == other._intValue,
                ShardKeyValueType.Float or ShardKeyValueType.Double
                    => _floatValue == other._floatValue,
                _ => string.Equals(_stringValue, other._stringValue, StringComparison.Ordinal)
            };
        }

        public override bool Equals(object? obj) => obj is ShardKeyValue other && Equals(other);

        public override int GetHashCode()
        {
            return _type switch
            {
                ShardKeyValueType.Null => 0,
                ShardKeyValueType.Int or ShardKeyValueType.Long or ShardKeyValueType.Int8 or
                ShardKeyValueType.Int16 or ShardKeyValueType.Boolean or ShardKeyValueType.Timestamp
                    => HashCode.Combine(_type, _intValue),
                ShardKeyValueType.Float or ShardKeyValueType.Double
                    => HashCode.Combine(_type, _floatValue),
                _ => HashCode.Combine(_type, _stringValue)
            };
        }

        public static bool operator ==(ShardKeyValue left, ShardKeyValue right) => left.Equals(right);
        public static bool operator !=(ShardKeyValue left, ShardKeyValue right) => !left.Equals(right);

        #endregion

        public override string ToString()
        {
            return _type switch
            {
                ShardKeyValueType.Null => "null",
                ShardKeyValueType.Int or ShardKeyValueType.Long or ShardKeyValueType.Int8 or
                ShardKeyValueType.Int16 or ShardKeyValueType.Timestamp
                    => _intValue.ToString(),
                ShardKeyValueType.Boolean => (_intValue != 0).ToString(),
                ShardKeyValueType.Float or ShardKeyValueType.Double
                    => _floatValue.ToString(),
                _ => _stringValue ?? "null"
            };
        }
    }

    public readonly struct ShardKeyValues : IReadOnlyList<(string Name, ShardKeyValue Value)>
    {
        private readonly (string Name, ShardKeyValue Value)[]? _values;

        public static ShardKeyValues Empty => new(Array.Empty<(string, ShardKeyValue)>());

        public ShardKeyValues(params (string Name, ShardKeyValue Value)[] values)
        {
            _values = values;
        }

        public static ShardKeyValues Single(string name, ShardKeyValue value)
            => new((name, value));

        public static ShardKeyValues Two(string name1, ShardKeyValue value1, string name2, ShardKeyValue value2)
            => new((name1, value1), (name2, value2));

        public static ShardKeyValues Three(
            string name1, ShardKeyValue value1,
            string name2, ShardKeyValue value2,
            string name3, ShardKeyValue value3)
            => new((name1, value1), (name2, value2), (name3, value3));

        public static ShardKeyValues Four(
            string name1, ShardKeyValue value1,
            string name2, ShardKeyValue value2,
            string name3, ShardKeyValue value3,
            string name4, ShardKeyValue value4)
            => new((name1, value1), (name2, value2), (name3, value3), (name4, value4));

        public int Count => _values?.Length ?? 0;

        public (string Name, ShardKeyValue Value) this[int index]
        {
            get
            {
                if (_values == null || index < 0 || index >= _values.Length)
                    throw new IndexOutOfRangeException();
                return _values[index];
            }
        }

        public IEnumerator<(string Name, ShardKeyValue Value)> GetEnumerator()
        {
            if (_values == null)
                yield break;

            foreach (var value in _values)
                yield return value;
        }

        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    }