ToonOutput.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text;
using Waher.Script.Abstraction.Elements;
 
namespace Waher.Content.Toon
{
    public class ToonOutput
    {
        private readonly StringBuilder output = new StringBuilder();
        private char delimiterCharacter = ',';
        private char indentCharacter = '\t';
        private int indentCharacterCount = 1;
        private int keyFoldingDepth = int.MaxValue;
        private bool standardIndentation = true;
        private bool standardDelimiter = true;
        private bool keyFolding = true;
        private bool empty = true;
        private bool lastIsListItem = false;
 
        public ToonOutput()
            : this(new StringBuilder())
        {
        }
 
        public ToonOutput(StringBuilder Output)
        {
            this.output = Output;
        }
 
        public char IndentCharacter
        {
            get => this.indentCharacter;
            set
            {
                this.indentCharacter = value;
                this.standardIndentation =
                    this.indentCharacter == '\t' &&
                    this.indentCharacterCount == 1;
            }
        }
 
        public int IndentCharacterCount
        {
            get => this.indentCharacterCount;
            set
            {
                if (value <= 0)
                {
                    throw new ArgumentException("Indent character count must be a positive integer.",
                        nameof(this.IndentCharacterCount));
                }
 
                this.indentCharacterCount = value;
                this.standardIndentation =
                    this.indentCharacter == '\t' &&
                    this.indentCharacterCount == 1;
            }
        }
 
        public bool StandardIndentation => this.standardIndentation;
 
        public bool StandardDelimiter => this.standardDelimiter;
 
        public StringBuilder Output => this.output;
 
        public bool Empty => this.empty;
 
        public char DelimiterCharacter
        {
            get => this.delimiterCharacter;
            set
            {
                this.delimiterCharacter = value;
                this.standardDelimiter = this.delimiterCharacter == ',';
            }
        }
 
        public bool KeyFolding
        {
            get => this.keyFolding;
            set
            {
                this.keyFolding = value;
 
                if (value && this.keyFoldingDepth <= 1)
                    this.keyFoldingDepth = 2;
            }
        }
 
        public int KeyFoldingDepth
        {
            get => this.keyFoldingDepth;
            set
            {
                if (value < 2)
                    this.keyFolding = false;
 
                this.keyFoldingDepth = value;
            }
        }
 
        public void Indent(int Level)
        {
            this.empty = false;
 
            if (this.standardIndentation)
                JSON.Indent(this.output, Level);
            else
            {
                Level *= this.indentCharacterCount;
 
                while (Level-- > 0)
                    this.output.Append(this.indentCharacter);
            }
 
            this.lastIsListItem = false;
        }
 
        public override string ToString()
        {
            return this.output.ToString();
        }
 
        public void Append(char Value)
        {
            this.empty = false;
            this.lastIsListItem = false;
            this.output.Append(Value);
        }
 
        public void Append(string Value)
        {
            this.empty = false;
            this.lastIsListItem = false;
            this.output.Append(Value);
        }
 
        public void AppendDelimiter()
        {
            this.empty = false;
            this.lastIsListItem = false;
            this.output.Append(this.delimiterCharacter);
        }
 
        public void AppendListItem()
        {
            this.output.Append('-');
            this.lastIsListItem = true;
        }
 
        public void AppendLine()
        {
            this.empty = false;
            this.lastIsListItem = false;
            this.output.Append('\n');
        }
 
        public void AppendEncoded(string s, bool InObject)
        {
            this.Append(this.Encode(s, InObject));
        }
 
        public string Encode(string s, bool InObject)
        {
            switch (s)
            {
                case null:
                case "":
                    return "\"\"";
 
                case "true":
                    return "\"true\"";
 
                case "false":
                    return "\"false\"";
 
                case "null":
                    return "\"null\"";
 
                case "-":
                    return "\"-\"";
 
                default:
                    if (double.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out _))
                        return "\"" + s + "\"";
 
                    if (JSON.ContainsEscapeCharacters(s))
                        return "\"" + JSON.Encode(s) + "\"";
 
                    if (s.StartsWith("[") ||
                        s.StartsWith("{") ||
                        s.IndexOf(this.delimiterCharacter) >= 0)
                    {
                        return "\"" + s + "\"";
                    }
 
                    if (InObject)
                    {
                        if (s.IndexOfAny(objectKeyCharacters) >= 0)
                            return "\"" + s + "\"";
                    }
                    else
                    {
                        if (s.IndexOfAny(keyCharacters) >= 0)
                            return "\"" + s + "\"";
                    }
 
                    return s;
            }
        }
 
        private static readonly char[] objectKeyCharacters = new char[] { ':', '-', ' ' };
        private static readonly char[] keyCharacters = new char[] { ':', '-' };
 
        public void AppendAsObject(IEnumerable<KeyValuePair<string, object>> Object,
            int? Indent, Func<string, bool> MemberExists)
        {
            bool MultiRow = Indent.HasValue;
            bool First = true;
 
            if (MultiRow)
                Indent++;
 
            if (!(Object is null))
            {
                foreach (KeyValuePair<string, object> Member in Object)
                {
                    if (!MultiRow)
                    {
                        if (!MultiRow)
                        {
                            if (First)
                                First = false;
                            else
                                this.AppendDelimiter();
                        }
                    }
 
                    this.AppendMember(Member.Key, Member.Value, Indent, MemberExists);
                }
            }
 
            if (MultiRow)
            {
                Indent--;
 
                if (!First && Indent.Value > 0)
                {
                    this.AppendLine();
                    this.Indent(Indent.Value);
                }
            }
        }
 
        public void AppendAsObject(IEnumerable<KeyValuePair<string, IElement>> Object,
            int? Indent, Func<string, bool> MemberExists)
        {
            bool MultiRow = Indent.HasValue;
            bool First = true;
 
            if (MultiRow)
                Indent++;
 
            if (!(Object is null))
            {
                foreach (KeyValuePair<string, IElement> Member in Object)
                {
                    if (!MultiRow)
                    {
                        if (First)
                            First = false;
                        else
                            this.AppendDelimiter();
                    }
 
                    this.AppendMember(Member.Key, Member.Value.AssociatedObjectValue, Indent,
                        MemberExists);
                }
            }
 
            if (MultiRow)
            {
                Indent--;
 
                if (!First && Indent.Value > 0)
                {
                    this.AppendLine();
                    this.Indent(Indent.Value);
                }
            }
        }
 
        public void AppendMember(string Name, object Value, int? Indent,
            Func<string, bool> MemberExists)
        {
            bool AppendSpaces = Indent.HasValue;
 
            if (AppendSpaces && (Indent.Value > 0 || (Indent.Value == 0 && !this.empty)))
            {
                if (this.lastIsListItem)
                {
                    this.output.Append(' ');
                    this.lastIsListItem = false;
                }
                else
                {
                    this.AppendLine();
                    this.Indent(Indent.Value);
                }
            }
 
            if (Value is null)
            {
                this.AppendEncoded(Name, true);
 
                if (AppendSpaces)
                    this.Append(": ");
                else
                    this.Append(':');
 
                this.Append("null");
                return;
            }
 
            IToonEncoder Encoder = TOON.GetEncoder(Value);
 
            if (this.keyFolding &&
                Encoder.EncodesAsObject(Value) &&
                this.Encode(Name, true) == Name)
            {
                string OriginalName = Name;
                object OriginalValue = Value;
                IToonEncoder OriginalEncoder = Encoder;
                int Depth = 1;
 
                while (Depth < this.keyFoldingDepth &&
                    Encoder.CanFold(Value, out string FoldedName, out object FoldedValue) &&
                    this.Encode(FoldedName, true) == FoldedName)
                {
                    Name += "." + FoldedName;
                    Value = FoldedValue;
                    Encoder = TOON.GetEncoder(Value);
                    Depth++;
 
                    if (!Encoder.EncodesAsObject(Value))
                        break;
                }
 
                if (Depth > 1 && MemberExists(Name))
                {
                    this.keyFolding = false;
 
                    this.AppendEncoded(OriginalName, true);
 
                    if (OriginalEncoder.EncodesAsVector(OriginalValue))
                        OriginalEncoder.Encode(OriginalValue, Indent, this, BracketsMode.Count);
                    else
                    {
                        if (OriginalEncoder.EncodesMultipleRows || !AppendSpaces)
                            this.Append(':');
                        else
                            this.Append(": ");
 
                        OriginalEncoder.Encode(OriginalValue, Indent, this);
                    }
 
                    this.keyFolding = true;
                    return;
                }
                else if (Depth == this.keyFoldingDepth)
                {
                    this.keyFolding = false;
 
                    this.AppendEncoded(Name, true);
 
                    if (Encoder.EncodesAsVector(Value))
                        Encoder.Encode(Value, Indent, this, BracketsMode.Count);
                    else
                    {
                        if (Encoder.EncodesMultipleRows || !AppendSpaces)
                            this.Append(':');
                        else
                            this.Append(": ");
 
                        Encoder.Encode(Value, Indent, this);
                    }
 
                    this.keyFolding = true;
                    return;
                }
            }
 
            this.AppendEncoded(Name, true);
 
            if (Encoder.EncodesAsVector(Value))
                Encoder.Encode(Value, Indent, this, BracketsMode.Count);
            else
            {
                if (Encoder.EncodesMultipleRows || !AppendSpaces)
                    this.Append(':');
                else
                    this.Append(": ");
 
                Encoder.Encode(Value, Indent, this);
            }
        }
 
    }
}