Comparators.cs

using System;
using System.Runtime.InteropServices;
using System.Security;
 
namespace NanoXLSX.Utils
{
    public static class Comparators
    {

        private const float FLOAT_THRESHOLD = 0.00001f;
        private const double DOUBLE_THRESHOLD = 1e-12;

        public static bool CompareSecureStrings(SecureString value1, SecureString value2)
        {
            bool v1Empty = false;
            bool v2Empty = false;
            if (value1 == null || value1.Length == 0)
            {
                v1Empty = true;
            }
            if (value2 == null || value2.Length == 0)
            {
                v2Empty = true;
            }
            if (v1Empty && !v2Empty || !v1Empty && v2Empty)
            {
                return false;
            }
            if (v1Empty && v2Empty)
            {
                return true;
            }
            IntPtr unmanagedString1 = IntPtr.Zero;
            IntPtr unmanagedString2 = IntPtr.Zero;
            try
            {
                unmanagedString1 = Marshal.SecureStringToBSTR(value1);
                unmanagedString2 = Marshal.SecureStringToBSTR(value2);
                int length1 = Marshal.ReadInt32(unmanagedString1, -4);
                int length2 = Marshal.ReadInt32(unmanagedString2, -4);
                if (length1 == length2)
                {
                    for (int i = 0; i < length1; ++i)
                    {
                        byte byte1 = Marshal.ReadByte(unmanagedString1, i);
                        byte byte2 = Marshal.ReadByte(unmanagedString2, i);
                        if (byte1 != byte2) return false;
                    }
                }
                else
                {
                    return false;
                }
                return true;
            }
            finally
            {
                // Cleanup
                if (unmanagedString2 != IntPtr.Zero) Marshal.ZeroFreeBSTR(unmanagedString2);
                if (unmanagedString1 != IntPtr.Zero) Marshal.ZeroFreeBSTR(unmanagedString1);
            }
        }

        public static int CompareDimensions(float? dimension1, float? dimension2)
        {
            if (dimension1 == null)
            {
                dimension1 = float.MinValue;
            }
            if (dimension2 == null)
            {
                dimension2 = float.MinValue;
            }
            if (Math.Abs(dimension1.Value - dimension2.Value) < FLOAT_THRESHOLD)
            {
                return 0;
            }
            else if (dimension1 > dimension2)
            {
                return 1;
            }
            else
            {
                return -1;
            }
        }

        public static bool IsZero(double value)
        {
            return Math.Abs(value) < DOUBLE_THRESHOLD;
        }

        public static bool IsZero(float value)
        {
            return Math.Abs(value) < FLOAT_THRESHOLD;
        }
    }
}