RecordValue.cs

Go to the documentation of this file.

using System;
using System.Runtime.CompilerServices;

namespace kinetica.Records;

    public enum RecordValueType
    {
        Null,
        Int,
        Long,
        Float,
        Double,
        String,
        Bytes
    }

    public readonly struct RecordValue : IEquatable<RecordValue>
    {
        private readonly RecordValueType _type;
        private readonly long _intValue;
        private readonly double _floatValue;
        private readonly object? _objectValue; // string or byte[]

        private RecordValue(RecordValueType type, long intValue = 0, double floatValue = 0, object? objectValue = null)
        {
            _type = type;
            _intValue = intValue;
            _floatValue = floatValue;
            _objectValue = objectValue;
        }

        public RecordValueType Type => _type;

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

        #region Factory Methods

        public static RecordValue Null() => new(RecordValueType.Null);

        public static RecordValue Int(int value) => new(RecordValueType.Int, value);

        public static RecordValue Long(long value) => new(RecordValueType.Long, value);

        public static RecordValue Float(float value) => new(RecordValueType.Float, floatValue: value);

        public static RecordValue Double(double value) => new(RecordValueType.Double, floatValue: value);

        public static RecordValue String(string value) => new(RecordValueType.String, objectValue: value);

        public static RecordValue Bytes(byte[] value) => new(RecordValueType.Bytes, objectValue: value);

        public static RecordValue Boolean(bool value) => new(RecordValueType.Int, value ? 1 : 0);

        #endregion

        #region Implicit Conversions

        public static implicit operator RecordValue(int value) => Int(value);
        public static implicit operator RecordValue(long value) => Long(value);
        public static implicit operator RecordValue(float value) => Float(value);
        public static implicit operator RecordValue(double value) => Double(value);
        public static implicit operator RecordValue(string value) => value == null ? Null() : String(value);
        public static implicit operator RecordValue(byte[] value) => value == null ? Null() : Bytes(value);
        public static implicit operator RecordValue(bool value) => Boolean(value);

        // Nullable conversions
        public static implicit operator RecordValue(int? value) => value.HasValue ? Int(value.Value) : Null();
        public static implicit operator RecordValue(long? value) => value.HasValue ? Long(value.Value) : Null();
        public static implicit operator RecordValue(float? value) => value.HasValue ? Float(value.Value) : Null();
        public static implicit operator RecordValue(double? value) => value.HasValue ? Double(value.Value) : Null();
        public static implicit operator RecordValue(bool? value) => value.HasValue ? Boolean(value.Value) : Null();

        #endregion

        #region Value Accessors

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public int? AsInt()
        {
            return _type switch
            {
                RecordValueType.Int => (int)_intValue,
                RecordValueType.Null => null,
                _ => throw new InvalidOperationException($"Cannot convert {_type} to Int")
            };
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public long? AsLong()
        {
            return _type switch
            {
                RecordValueType.Long => _intValue,
                RecordValueType.Int => _intValue,
                RecordValueType.Null => null,
                _ => throw new InvalidOperationException($"Cannot convert {_type} to Long")
            };
        }

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

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

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public string? AsString()
        {
            return _type switch
            {
                RecordValueType.String => (string?)_objectValue,
                RecordValueType.Null => null,
                _ => throw new InvalidOperationException($"Cannot convert {_type} to String")
            };
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public byte[]? AsBytes()
        {
            return _type switch
            {
                RecordValueType.Bytes => (byte[]?)_objectValue,
                RecordValueType.Null => null,
                _ => throw new InvalidOperationException($"Cannot convert {_type} to Bytes")
            };
        }

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

        #endregion

        #region TryGet Methods

        public bool TryGetInt(out int value)
        {
            if (_type == RecordValueType.Int)
            {
                value = (int)_intValue;
                return true;
            }
            value = default;
            return false;
        }

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

        public bool TryGetFloat(out float value)
        {
            if (_type == RecordValueType.Float)
            {
                value = (float)_floatValue;
                return true;
            }
            value = default;
            return false;
        }

        public bool TryGetDouble(out double value)
        {
            if (_type is RecordValueType.Double or RecordValueType.Float)
            {
                value = _floatValue;
                return true;
            }
            value = default;
            return false;
        }

        public bool TryGetString(out string? value)
        {
            if (_type == RecordValueType.String)
            {
                value = (string?)_objectValue;
                return true;
            }
            if (_type == RecordValueType.Null)
            {
                value = null;
                return true;
            }
            value = default;
            return false;
        }

        public bool TryGetBytes(out byte[]? value)
        {
            if (_type == RecordValueType.Bytes)
            {
                value = (byte[]?)_objectValue;
                return true;
            }
            if (_type == RecordValueType.Null)
            {
                value = null;
                return true;
            }
            value = default;
            return false;
        }

        public bool TryGetBool(out bool value)
        {
            if (_type == RecordValueType.Int)
            {
                value = _intValue != 0;
                return true;
            }
            value = default;
            return false;
        }

        #endregion

        #region Equality and Hashing

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

            return _type switch
            {
                RecordValueType.Null => true,
                RecordValueType.Int or RecordValueType.Long => _intValue == other._intValue,
                RecordValueType.Float or RecordValueType.Double => _floatValue == other._floatValue,
                RecordValueType.String => string.Equals((string?)_objectValue, (string?)other._objectValue, StringComparison.Ordinal),
                RecordValueType.Bytes => ByteArrayEquals((byte[]?)_objectValue, (byte[]?)other._objectValue),
                _ => false
            };
        }

        private static bool ByteArrayEquals(byte[]? a, byte[]? b)
        {
            if (ReferenceEquals(a, b)) return true;
            if (a == null || b == null) return false;
            if (a.Length != b.Length) return false;
            for (int i = 0; i < a.Length; i++)
            {
                if (a[i] != b[i]) return false;
            }
            return true;
        }

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

        public override int GetHashCode()
        {
            return _type switch
            {
                RecordValueType.Null => 0,
                RecordValueType.Int or RecordValueType.Long => HashCode.Combine(_type, _intValue),
                RecordValueType.Float or RecordValueType.Double => HashCode.Combine(_type, _floatValue),
                RecordValueType.String => HashCode.Combine(_type, _objectValue),
                RecordValueType.Bytes => HashCode.Combine(_type, ((byte[]?)_objectValue)?.Length ?? 0),
                _ => 0
            };
        }

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

        #endregion

        public override string ToString()
        {
            return _type switch
            {
                RecordValueType.Null => "null",
                RecordValueType.Int or RecordValueType.Long => _intValue.ToString(),
                RecordValueType.Float or RecordValueType.Double => _floatValue.ToString(),
                RecordValueType.String => $"\"{_objectValue}\"",
                RecordValueType.Bytes => $"bytes[{((byte[]?)_objectValue)?.Length ?? 0}]",
                _ => "unknown"
            };
        }
    }