ParserUtils.cs

/*
 * NanoXLSX is a small .NET library to generate and read XLSX (Microsoft Excel 2007 or newer) files in an easy and native way
 * Copyright Raphael Stoeckli © 2025
 * This library is licensed under the MIT License.
 * You find a copy of the license in project folder or on: http://opensource.org/licenses/MIT
 */
 
using System;
using System.Globalization;
using System.Linq;
 
namespace NanoXLSX.Utils
{
    public static class ParserUtils
    {
        #region constants

        public const string NumericFormat = "G";

        public static readonly CultureInfo InvariantCulture = CultureInfo.InvariantCulture;
 
        #endregion

        public static bool StartsWith(string input, string value)
        {
            if (input == null && value == null)
            {
                return true;
            }
            else if (input == null && value != null)
            {
                return false;
            }
            else if (value == null)
            {
                return false;
            }
            return input.StartsWith(value, StringComparison.InvariantCulture);
        }

        public static bool NotStartsWith(string input, string value)
        {
            return !StartsWith(input, value);
        }

        public static string ToUpper(string input)
        {
            return !string.IsNullOrEmpty(input) ? input.ToUpper(InvariantCulture) : input;
        }

        public static string ToLower(string input)
        {
            return !string.IsNullOrEmpty(input) ? input.ToLower(InvariantCulture) : input;
        }

        public static string ToString(int input)
        {
            return input.ToString(NumericFormat, InvariantCulture);
        }

        public static string ToString(float input)
        {
            return input.ToString(NumericFormat, InvariantCulture);
        }

        public static string ToString(byte input)
        {
            return input.ToString(NumericFormat, InvariantCulture);
        }

        public static string ToString(sbyte input)
        {
            return input.ToString(NumericFormat, InvariantCulture);
        }

        public static string ToString(double input)
        {
            return input.ToString(NumericFormat, InvariantCulture);
        }

        public static string ToString(decimal input)
        {
            return input.ToString(NumericFormat, InvariantCulture);
        }

        public static string ToString(uint input)
        {
            return input.ToString(NumericFormat, InvariantCulture);
        }

        public static string ToString(long input)
        {
            return input.ToString(NumericFormat, InvariantCulture);
        }

        public static string ToString(ulong input)
        {
            return input.ToString(NumericFormat, InvariantCulture);
        }

        public static string ToString(short input)
        {
            return input.ToString(NumericFormat, InvariantCulture);
        }

        public static string ToString(ushort input)
        {
            return input.ToString(NumericFormat, InvariantCulture);
        }

        public static string NormalizeNewLines(string value)
        {
            if (value == null || (!value.Contains('\n') && !value.Contains('\r')))
            {
                return value;
            }
            return value.Replace("\n\r", "\n").Replace("\r\n", "\n").Replace("\r", "\n").Replace("\n", "\r\n");
        }

        public static float ParseFloat(string rawValue)
        {
            return float.Parse(rawValue, InvariantCulture);
        }

        public static int ParseInt(string rawValue)
        {
            return int.Parse(rawValue, NumberStyles.Any, InvariantCulture);
        }

        public static double ParseDouble(string rawValue)
        {
            return double.Parse(rawValue, InvariantCulture);
        }

        public static int ParseBinaryBool(String rawValue)
        {
            if (string.IsNullOrEmpty(rawValue))
            {
                return 0;
            }
            int value;
            if (TryParseInt(rawValue, out value))
            {
                if (value >= 1)
                {
                    return 1;
                }
                else
                {
                    return 0;
                }
            }
            rawValue = rawValue.ToLower(InvariantCulture);
            if (rawValue == "true")
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }

        public static bool TryParseInt(string rawValue, out int parsedValue)
        {
            return int.TryParse(rawValue, NumberStyles.Integer, InvariantCulture, out parsedValue);
        }

        public static bool TryParseUint(string rawValue, out uint parsedValue)
        {
            return uint.TryParse(rawValue, NumberStyles.Integer, InvariantCulture, out parsedValue);
        }

        public static bool TryParseLong(string rawValue, out long parsedValue)
        {
            return long.TryParse(rawValue, NumberStyles.Integer, InvariantCulture, out parsedValue);
        }

        public static bool TryParseUlong(string rawValue, out ulong parsedValue)
        {
            return ulong.TryParse(rawValue, NumberStyles.Integer, InvariantCulture, out parsedValue);
        }

        public static bool TryParseFloat(string rawValue, out float parsedValue)
        {
            return float.TryParse(rawValue, NumberStyles.Any, CultureInfo.InvariantCulture, out parsedValue);
        }

        public static bool TryParseDecimal(string rawValue, out decimal parsedValue)
        {
            return decimal.TryParse(rawValue, NumberStyles.Float, InvariantCulture, out parsedValue);
        }

        public static bool TryParseDouble(string rawValue, out double parsedValue)
        {
            return double.TryParse(rawValue, NumberStyles.Any, InvariantCulture, out parsedValue);
        }
    }
}