PKHeX/PKHeX.Core/Util/BigEndian.cs

using System;

namespace PKHeX.Core
{
    public static class BigEndian
    {
        public static uint ToUInt32(ReadOnlySpan<byte> data)
        {
            int val = 0;
            val |= data[0] << 24;
            val |= data[1] << 16;
            val |= data[2] << 8;
            val |= data[3];
            return (uint)val;
        }

        public static ushort ToUInt16(ReadOnlySpan<byte> data)
        {
            int val = 0;
            val |= data[0] << 8;
            val |= data[1];
            return (ushort)val;
        }

        public static int ToInt32(ReadOnlySpan<byte> data)
        {
            int val = 0;
            val |= data[0] << 24;
            val |= data[1] << 16;
            val |= data[2] << 8;
            val |= data[3];
            return val;
        }

        public static short ToInt16(ReadOnlySpan<byte> data)
        {
            int val = 0;
            val |= data[0] << 8;
            val |= data[1];
            return (short)val;
        }

        public static uint ToUInt32(byte[] data, int offset)
        {
            int val = 0;
            val |= data[offset + 0] << 24;
            val |= data[offset + 1] << 16;
            val |= data[offset + 2] << 8;
            val |= data[offset + 3];
            return (uint)val;
        }

        public static ushort ToUInt16(byte[] data, int offset)
        {
            int val = 0;
            val |= data[offset + 0] << 8;
            val |= data[offset + 1];
            return (ushort)val;
        }

        public static int ToInt32(byte[] data, int offset)
        {
            int val = 0;
            val |= data[offset + 0] << 24;
            val |= data[offset + 1] << 16;
            val |= data[offset + 2] << 8;
            val |= data[offset + 3];
            return val;
        }

        public static short ToInt16(byte[] data, int offset)
        {
            int val = 0;
            val |= data[offset + 0] << 8;
            val |= data[offset + 1];
            return (short)val;
        }

        public static byte[] GetBytes(int value)
        {
            return Invert(BitConverter.GetBytes(value));
        }

        public static byte[] GetBytes(short value)
        {
            return Invert(BitConverter.GetBytes(value));
        }

        public static byte[] GetBytes(uint value)
        {
            return Invert(BitConverter.GetBytes(value));
        }

        public static byte[] GetBytes(ushort value)
        {
            return Invert(BitConverter.GetBytes(value));
        }

        private static byte[] Invert(byte[] data)
        {
            int i = 0;
            int j = 0 + data.Length - 1;
            while (i < j)
            {
                (data[i], data[j]) = (data[j], data[i]);
                i++;
                j--;
            }
            return data;
        }

        /// <summary>
        /// Swaps byte ordering in a byte array based on 32bit value writes.
        /// </summary>
        /// <remarks>The <see cref="data"/> is reversed in-place.</remarks>
        public static void SwapBytes32(byte[] data)
        {
            for (int i = 0; i < data.Length; i += 4)
            {
                (data[0 + i], data[3 + i]) = (data[3 + i], data[0 + i]);
                (data[1 + i], data[2 + i]) = (data[2 + i], data[1 + i]);
            }
        }
    }
}