wabbajack/Wabbajack.Hashing.xxHash64/Hash.cs

using System;
using System.Buffers.Text;

namespace Wabbajack.Hashing.xxHash64;

public struct Hash : IEquatable<Hash>, IComparable<Hash>
{
    private readonly ulong _code;

    public Hash(ulong code = 0)
    {
        _code = code;
    }

    public override string ToString()
    {
        return BitConverter.GetBytes(_code).ToBase64();
    }

    public bool Equals(Hash other)
    {
        return _code == other._code;
    }

    public int CompareTo(Hash other)
    {
        return _code.CompareTo(other._code);
    }

    public override bool Equals(object? obj)
    {
        if (obj is Hash h)
            return h._code == _code;
        return false;
    }

    public override int GetHashCode()
    {
        return (int) (_code >> 32) ^ (int) _code;
    }

    public static bool operator ==(Hash a, Hash b)
    {
        return a._code == b._code;
    }

    public static bool operator !=(Hash a, Hash b)
    {
        return !(a == b);
    }

    public static explicit operator ulong(Hash a)
    {
        return a._code;
    }

    public static explicit operator long(Hash a)
    {
        return BitConverter.ToInt64(BitConverter.GetBytes(a._code));
    }

    public string ToBase64()
    {
        Span<byte> bytes = stackalloc byte[8];

        BitConverter.TryWriteBytes(bytes, _code);
        return Convert.ToBase64String(bytes);
    }

    public static Hash FromBase64(string hash)
    {
        return new Hash(BitConverter.ToUInt64(hash.FromBase64()));
    }

    public static Hash FromBase64(ReadOnlySpan<byte> data)
    {
        unsafe
        {
            Span<byte> buffer = stackalloc byte[12];
            Base64.DecodeFromUtf8(data, buffer, out var consumed, out var written);
            return new Hash(BitConverter.ToUInt64(buffer));
        }
    }

    public void ToBase64(Span<byte> output)
    {
        unsafe
        {
            Span<byte> buffer = stackalloc byte[8];
            if (!BitConverter.TryWriteBytes(buffer, _code))
                throw new Exception("Base64 Encoding error");
            Base64.EncodeToUtf8(buffer, output, out var consumed, out var written);
        }
    }

    public static Hash FromLong(in long argHash)
    {
        return new Hash(BitConverter.ToUInt64(BitConverter.GetBytes(argHash)));
    }

    public static Hash FromULong(in ulong argHash)
    {
        return new Hash(argHash);
    }

    public static Hash FromHex(string xxHashAsHex)
    {
        return new Hash(BitConverter.ToUInt64(xxHashAsHex.FromHex()));
    }

    public string ToHex()
    {
        return BitConverter.GetBytes(_code).ToHex();
    }

    public byte[] ToArray()
    {
        return BitConverter.GetBytes(_code);
    }

    public static Hash Interpret(string input)
    {
        return input.Length switch
        {
            16 => FromHex(input),
            12 when input.EndsWith('=') => FromBase64(input),
            _ => FromLong(long.Parse(input))
        };
    }

    public static bool TryGetFromHex(string hex, out Hash hash)
    {
        hash = default;
        if (hex.Length != 16) return false;
        try
        {
            hash = FromHex(hex);
            return true;
        }
        catch (Exception)
        {
            return false;
        }
    }
}