wabbajack/Wabbajack.Hashing.xxHash64/HashRelativePath.cs

using System;
using System.Linq;
using Wabbajack.Paths;

namespace Wabbajack.Hashing.xxHash64
{
    public readonly struct HashRelativePath : IPath, IEquatable<HashRelativePath>, IComparable<HashRelativePath>
    {
        public readonly Hash Hash;
        public readonly RelativePath[] Parts;


        public Extension Extension => Parts.Length > 0
            ? Parts[^1].Extension
            : throw new InvalidOperationException("No path in HashRelativePath");

        public RelativePath FileName => Parts.Length > 0
            ? Parts[^1].FileName
            : throw new InvalidOperationException("No path in HashRelativePath");

        public HashRelativePath(Hash basePath, params RelativePath[] parts)
        {
            Hash = basePath;
            Parts = parts;
        }

        public override string ToString()
        {
            return Hash + "|" + string.Join("|", Parts);
        }

        public override bool Equals(object? obj)
        {
            return obj is FullPath path && Equals(path);
        }

        public override int GetHashCode()
        {
            return Parts.Aggregate(Hash.GetHashCode(), (i, path) => i ^ path.GetHashCode());
        }

        public bool Equals(HashRelativePath other)
        {
            if (other.Parts.Length != Parts.Length) return false;
            if (other.Hash != Hash) return false;
            return ArrayExtensions.AreEqual(Parts, 0, other.Parts, 0, Parts.Length);
        }

        public int CompareTo(HashRelativePath other)
        {
            var init = Hash.CompareTo(other.Hash);
            if (init != 0) return init;
            return ArrayExtensions.Compare(Parts, other.Parts);
        }

        public static bool operator ==(HashRelativePath a, HashRelativePath b)
        {
            return a.Equals(b);
        }

        public static bool operator !=(HashRelativePath a, HashRelativePath b)
        {
            return !a.Equals(b);
        }
    }
}