public string ToJsonString()

in src/dotnet/utils/JacobianComparisonLib/JacobianComparison.cs [170:288]
113 lines of code
13 McCabe index (conditional complexity)

        public string ToJsonString()
        {
            return $@"{{
    ""{nameof(Tolerance)}"": {this.Tolerance},
    ""{nameof(File1)}"": ""{this.File1.Replace("\\", "/")}"",
    ""{nameof(File2)}"": ""{this.File2.Replace("\\", "/")}"",
    ""{nameof(DimensionMismatch)}"": {this.DimensionMismatch.ToString().ToLower()},
    ""{nameof(ParseError)}"": {this.ParseError.ToString().ToLower()},
    ""{nameof(MaxDifference)}"": {this.MaxDifference},
    ""{nameof(AvgDifference)}"": {this.AvgDifference},
    ""{nameof(DifferenceViolationCount)}"": {this.DifferenceViolationCount},
    ""{nameof(NumberComparisonCount)}"": {this.NumberComparisonCount},
    ""{nameof(Error)}"": ""{this.Error}"",
    ""ViolationsHappened"": {this.ViolationsHappened().ToString().ToLower()}
}}";
        }

        private enum TokenKind
        {
            Number,
            NewLine,
            Error
        }

        private struct Token
        {
            public TokenKind Kind;
            public double Value;

            public static Token CreateNewLine() => new Token { Kind = TokenKind.NewLine };
            public static Token CreateDouble(double value) => new Token { Kind = TokenKind.Number, Value = value };
            public static Token CreateError() => new Token { Kind = TokenKind.Error };
        }

        private IEnumerable<Token> ParseFile(string path)
        {
            int curLine = 0, curPos = 0, lastNumStartPos = 0;
            StringBuilder acc = new StringBuilder(32);
            char c;
            bool foundNewLine = false;
            using (var reader = File.OpenText(path))
            {
                // Skipping whitespace in the beginning
                while (reader.Peek() >= 0 && char.IsWhiteSpace((char)reader.Peek()))
                {
                    c = (char)reader.Read();
                    if (c == '\n')
                    {
                        ++curLine;
                        curPos = 0;
                    }
                    else
                    {
                        ++curPos;
                    }
                }

                while (reader.Peek() >= 0)
                {
                    c = (char)reader.Read();
                    if (char.IsWhiteSpace(c))
                    {
                        if (acc.Length > 0)
                        {
                            if (double.TryParse(acc.ToString(), out double d))
                            {
                                acc.Clear();
                                yield return Token.CreateDouble(d);
                            }
                            else
                            {
                                this.ParseError = true;
                                this.Error = $"Failed to parse file {path.Replace("\\", "/")} - line {curLine} position {lastNumStartPos}.";
                                yield return Token.CreateError();
                                yield break;
                            }
                        }
                        if (c == '\n')
                        {
                            foundNewLine = true;
                            ++curLine;
                            curPos = 0;
                        }
                        else
                        {
                            ++curPos;
                        }
                    }
                    else
                    {
                        if (acc.Length == 0)
                        {
                            if (foundNewLine)
                            {
                                yield return Token.CreateNewLine();
                                foundNewLine = false;
                            }
                            lastNumStartPos = curPos;
                        }
                        acc.Append(c);
                        ++curPos;
                    }
                }

                if (acc.Length > 0)
                {
                    if (double.TryParse(acc.ToString(), out double d))
                    {
                        yield return Token.CreateDouble(d);
                    }
                    else
                    {
                        this.ParseError = true;
                        this.Error = $"Failed to parse file {path.Replace("\\", "/")} - line {curLine} position {lastNumStartPos}.";
                        yield return Token.CreateError();
                    }
                }
            }
        }