Custom jSON - escaco95/Charcoal GitHub Wiki

// Copyright (c) 2019 최선웅
// Distributed under the BSD License, Version 1.0.
using System.Collections.Generic;
using System.Text;
//==========================================================================================
// 코드 본문
//==========================================================================================
#region [    Base CSON Element    ]
/// <summary>
/// <see cref="CSONElement"/>가 취할 수 있는 형태의 종류를 나타냅니다.
/// </summary>
public enum CSONElementType {
    Unknown,
    /// <summary>
    /// Key(string), Value(<see cref="CSONElement"/>)의 쌍으로 이루어진 <see cref="CSONElement"/>의 파생 형태 중 하나입니다.
    /// </summary>
    Object,
    /// <summary>
    /// Index(int), Value(<see cref="CSONElement"/>)의 쌍으로 이루어진 <see cref="CSONElement"/>의 파생 형태 중 하나입니다.
    /// <para>배열의 각 요소는 리스트의 형태로 다루어집니다.</para>
    /// </summary>
    Array,
    /// <summary>
    /// 배열에 속한 요소의 위치가 연속적이지 않은 자료구조를 다루기에 적합한 파생 형태입니다.
    /// <para>배열의 의미에 맞게 각 요소가 다루어집니다.</para>
    /// </summary>
    SparseArray,
    /// <summary>
    /// 원시적인 데이터 타입 <see cref="string"/>의 형태를 취하고 있는 <see cref="CSONElement"/>입니다.
    /// </summary>
    String,
    /// <summary>
    /// 원시적인 데이터 타입 <see cref="int"/>의 형태를 취하고 있는 <see cref="CSONElement"/>입니다.
    /// </summary>
    Integer,
    // TODO: CSON FIxedReal 구현
    FixedReal,
    // TODO: CSON FloatReal 구현
    FloatReal
}
/// <summary>
/// Custom JSON 자료구조를 구성하는 단위, Element입니다.
/// </summary>
public abstract class CSONElement
{
    /// <summary>
    /// 해당 <see cref="CSONElement"/>가 취하고 있는 자료형입니다.
    /// </summary>
    public CSONElementType Type { get; protected set; }
}
#endregion
#region[    CSON Object{}    ]
/// <summary>
/// Key(string), Value(<see cref="CSONElement"/>) 쌍으로 이루어진 <see cref="CSONElement"/>들을 갖는 자료형입니다.
/// </summary>
public class CSONObject : CSONElement
{
    public Dictionary<string, CSONElement> Elements { get; protected set; } = new Dictionary<string, CSONElement>();
    public CSONObject(){ Type = CSONElementType.Object;}
    public bool Contains(string key) { return Elements.ContainsKey(key); }
    public void Remove(string key) { Elements.Remove(key); }
    public void Clear() { Elements.Clear(); }
    public CSONElement this[string key] { get { return Elements[key]; } set { Elements[key] = value; } }
    public void Add(string key, CSONElement Element){Elements.Add(key, Element); }
    public void Add(string key, string value) { Elements.Add(key, new CSONString() { Value = value }); }
    public void Add(string key, int value) { Elements.Add(key, new CSONInteger() { Value = value }); }
    public override string ToString()
    {
        string result = "{";
        bool first = true;
        foreach (var Element in Elements)
        {
            if (!first)
                result += ", ";
            result += $"\"{Element.Key}\": {Element.Value.ToString()}";
            first = false;
        }
        result += "}";
        return result;
    }
}
#endregion
#region [    CSON Sparse Array<>    ]
public class CSONSparseArray : CSONElement
{
    public Dictionary<int, CSONElement> Items { get; protected set; } = new Dictionary<int, CSONElement>();
    public CSONSparseArray() { Type = CSONElementType.SparseArray; }
    public bool Contains(int index) { return Items.ContainsKey(index); }
    public void Remove(int index) { Items.Remove(index); }
    public void Clear() { Items.Clear(); }
    public CSONElement this[int index] { get { return Items[index]; } set { Items[index] = value; } }
    public void Add(int index, CSONElement Element) { Items.Add(index, Element); }
    public void Add(int index, string value) { Items.Add(index, new CSONString() { Value = value }); }
    public void Add(int index, int value) { Items.Add(index, new CSONInteger() { Value = value }); }
    public override string ToString()
    {
        string result = "<";
        bool first = true;
        foreach (var item in Items)
        {
            if (!first)
                result += ", ";
            result += $"{item.Key}: {item.Value.ToString()}";
            first = false;
        }
        result += ">";
        return result;
    }
}
#endregion
#region [    CSON Array[]    ]
public class CSONArray : CSONElement
{
    public List<CSONElement> Items { get; protected set; } = new List<CSONElement>();
    public CSONArray(){Type = CSONElementType.Array;}
    public bool Contains(CSONElement Element) { return Items.Contains(Element); }
    public void RemoveAt(int index) { Items.RemoveAt(index); }
    public void Clear() { Items.Clear(); }
    public CSONElement this[int index] { get { return Items[index]; } set { Items[index] = value; } }
    public void Add(CSONElement Element) { Items.Add(Element); }
    public void Add(string value) { Items.Add( new CSONString() { Value = value }); }
    public void Add(int value) { Items.Add( new CSONInteger() { Value = value }); }
    public override string ToString()
    {
        string result = "[";
        bool first = true;
        foreach (var element in Items)
        {
            if (!first)
                result += ", ";
            result += element.ToString();
            first = false;
        }
        result += "]";
        return result;
    }
}
#endregion
#region [    Primitive CSON Elements    ]
public class CSONString : CSONElement
{
    public string Value;
    public CSONString() { Type = CSONElementType.String; }
    public override string ToString(){ return $"\"{Value}\""; }
}
public class CSONInteger : CSONElement
{
    public int Value;
    public CSONInteger() { Type = CSONElementType.Integer; }
    public override string ToString() { return $"{Value}"; }
}
public class CSONReal : CSONElement
{
    public double Value;
    public CSONReal() { Type = CSONElementType.FixedReal; }
    public override string ToString() { return $"{Value}"; }
}
#endregion
//==========================================================================================
// Parser
//==========================================================================================
#region [    CSON Parser    ]
public class CSONParser
{
    private enum TokenType
    {
        Default, String, Integer, Real, CommentReady, Comment, CommentEndReady,
        Seperator, Parameter, ObjectOpen, ArrayOpen, SparseOpen, ObjectClose, ArrayClose, SparseClose
    }
    private class ParseToken
    {
        public TokenType Type;
        public string Value;
    }
    private List<ParseToken> Tokenize(char[] CSONCharArray)
    {
        var tokens = new List<ParseToken>();
        TokenType currentToken = TokenType.Default;
        StringBuilder tokenBuilder = new StringBuilder();
        string tokenString;
        for(int ci=0;ci<CSONCharArray.Length;ci++)
        {
            var c = CSONCharArray[ci];
            switch (currentToken)
            {
                case TokenType.Integer:
                case TokenType.Real:
                    switch (c)
                    {
                        case '.':
                            if (currentToken == TokenType.Real)
                                throw new System.Exception($"올바르지 않은 숫자 서식.");
                            currentToken = TokenType.Real;
                            tokenBuilder.Append(c);
                            break;
                        case '0':
                        case '1':
                        case '2':
                        case '3':
                        case '4':
                        case '5':
                        case '6':
                        case '7':
                        case '8':
                        case '9':
                            tokenBuilder.Append(c);
                            break;
                        default:
                            tokenString = tokenBuilder.ToString();
                            tokens.Add(new ParseToken() { Type = currentToken, Value = tokenString });
                            tokenBuilder.Clear();
                            //
                            currentToken = TokenType.Default; //....?
                            ci--;
                            break;
                    }
                    break;
                case TokenType.String:
                    switch (c)
                    {
                        case '"':
                            tokenString = tokenBuilder.ToString();
                            tokens.Add(new ParseToken() { Type = TokenType.String, Value = tokenString });
                            tokenBuilder.Clear();
                            //
                            currentToken = TokenType.Default; //....?
                            break;
                        default:
                            tokenBuilder.Append(c);
                            break;
                    }
                    break;
                case TokenType.CommentEndReady:
                case TokenType.Comment:
                    switch (c)
                    {
                        case '*':
                            currentToken = TokenType.CommentEndReady;
                            break;
                        case '/':
                            if (currentToken == TokenType.CommentEndReady)
                            {
                                currentToken = TokenType.Default; //....?
                            }
                            break;
                    }
                    break;
                case TokenType.CommentReady:
                case TokenType.Default:
                    switch (c)
                    {
                        case '0':
                        case '1':
                        case '2':
                        case '3':
                        case '4':
                        case '5':
                        case '6':
                        case '7':
                        case '8':
                        case '9':
                            // 디폴트가 아닌 상황 = 앞서 accept한 문자가 있었음.
                            if (currentToken != TokenType.Default)
                                throw new System.Exception($"예상하지 못한 문자가 선행됨.");
                            currentToken = TokenType.Integer;
                            tokenBuilder.Append(c);
                            break;
                        case '"':
                            // 디폴트가 아닌 상황 = 앞서 accept한 문자가 있었음.
                            if (currentToken != TokenType.Default)
                                throw new System.Exception($"예상하지 못한 문자가 선행됨.");
                            currentToken = TokenType.String;
                            break;
                        case '/':
                            // 디폴트가 아닌 상황 = 앞서 accept한 문자가 있었음.
                            if (currentToken != TokenType.Default)
                                throw new System.Exception($"예상하지 못한 문자가 선행됨.");
                            // 코멘트 준비 시작
                            currentToken = TokenType.CommentReady;
                            break;
                        case ' ':
                        case '\t':
                            // 디폴트가 아닌 상황 = 앞서 accept한 문자가 있었음.
                            if (currentToken != TokenType.Default)
                                throw new System.Exception($"예상하지 못한 문자가 선행됨.");
                            // 기본적으로 공백은 무시함
                            break;
                        case '*':
                            // 코멘트 준비
                            if (currentToken == TokenType.CommentReady)
                            {
                                currentToken = TokenType.Comment;
                                break;
                            }
                            throw new System.Exception($"예상하지 못한 문자 {c}.");
                        case '{':
                            tokens.Add(new ParseToken() { Type = TokenType.ObjectOpen });
                            break;
                        case '[':
                            tokens.Add(new ParseToken() { Type = TokenType.ArrayOpen });
                            break;
                        case '<':
                            tokens.Add(new ParseToken() { Type = TokenType.SparseOpen });
                            break;
                        case '>':
                            tokens.Add(new ParseToken() { Type = TokenType.SparseClose });
                            break;
                        case ']':
                            tokens.Add(new ParseToken() { Type = TokenType.ArrayClose });
                            break;
                        case '}':
                            tokens.Add(new ParseToken() { Type = TokenType.ObjectClose });
                            break;
                        case ':':
                            tokens.Add(new ParseToken() { Type = TokenType.Parameter });
                            break;
                        case ',':
                            tokens.Add(new ParseToken() { Type = TokenType.Seperator });
                            break;
                        default:
                            throw new System.Exception($"예상하지 못한 문자 {c}.");
                    }
                    break;
            }
        }
        if (currentToken != TokenType.Default)
            throw new System.Exception($"CSON이 올바르게 종결되지 못함.");
        return tokens;
    }
    private CSONElement ParseRecur(List<ParseToken> tokens, ref int readPtr)
    {
        CSONElement baseElement = null;
        var token = tokens[readPtr];
        readPtr++;
        switch (token.Type)
        {
            case TokenType.String:
                baseElement = new CSONString() { Value = token.Value };
                break;
            case TokenType.Integer:
                baseElement = new CSONInteger() { Value = int.Parse(token.Value) };
                break;
            case TokenType.Real:
                baseElement = new CSONReal() { Value = double.Parse(token.Value) };
                break;
            case TokenType.ObjectOpen:
                baseElement = new CSONObject();
                while (readPtr < tokens.Count)
                {
                    var finish = false;
                    var subtoken = tokens[readPtr];
                    readPtr++;
                    switch (subtoken.Type)
                    {
                        case TokenType.Seperator:/*Do Nothing*/break;
                        case TokenType.String:
                            {
                                if(tokens[readPtr].Type != TokenType.Parameter)
                                    throw new System.Exception($"예기치 못한 {subtoken.Type}.");
                                var paraToken = tokens[readPtr + 1];
                                readPtr += 2;
                                switch (paraToken.Type)
                                {
                                    case TokenType.String:
                                        ((CSONObject)baseElement).Add(subtoken.Value, new CSONString() { Value = paraToken.Value });
                                        break;
                                    case TokenType.Integer:
                                        ((CSONObject)baseElement).Add(subtoken.Value, new CSONInteger() { Value = int.Parse(paraToken.Value) });
                                        break;
                                    case TokenType.Real:
                                        ((CSONObject)baseElement).Add(subtoken.Value, new CSONReal() { Value = double.Parse(paraToken.Value) });
                                        break;
                                    case TokenType.ObjectOpen:
                                    case TokenType.SparseOpen:
                                    case TokenType.ArrayOpen:
                                        readPtr--;
                                        ((CSONObject)baseElement).Add(subtoken.Value, ParseRecur(tokens, ref readPtr));
                                        break;
                                }
                            }
                            break;
                        case TokenType.ObjectClose:
                            finish = true;
                            break;
                        default:
                            throw new System.Exception($"예기치 못한 {subtoken.Type}.");
                    }
                    if (finish)
                        break;
                }
                break;
            case TokenType.SparseOpen:
                baseElement = new CSONSparseArray();
                while (readPtr < tokens.Count)
                {
                    var finish = false;
                    var subtoken = tokens[readPtr];
                    readPtr++;
                    switch (subtoken.Type)
                    {
                        case TokenType.Seperator:/*Do Nothing*/break;
                        case TokenType.Integer:
                            {
                                if (tokens[readPtr].Type != TokenType.Parameter)
                                    throw new System.Exception($"예기치 못한 {subtoken.Type}.");
                                var paraToken = tokens[readPtr + 1];
                                readPtr += 2;
                                switch (paraToken.Type)
                                {
                                    case TokenType.String:
                                        ((CSONSparseArray)baseElement).Add(int.Parse(subtoken.Value), new CSONString() { Value = paraToken.Value });
                                        break;
                                    case TokenType.Integer:
                                        ((CSONSparseArray)baseElement).Add(int.Parse(subtoken.Value), new CSONInteger() { Value = int.Parse(paraToken.Value) });
                                        break;
                                    case TokenType.Real:
                                        ((CSONSparseArray)baseElement).Add(int.Parse(subtoken.Value), new CSONReal() { Value = double.Parse(paraToken.Value) });
                                        break;
                                    case TokenType.ObjectOpen:
                                    case TokenType.SparseOpen:
                                    case TokenType.ArrayOpen:
                                        readPtr--;
                                        ((CSONSparseArray)baseElement).Add(int.Parse(subtoken.Value), ParseRecur(tokens, ref readPtr));
                                        break;
                                }
                            }
                            break;
                        case TokenType.ArrayClose:
                            finish = true;
                            break;
                        default:
                            throw new System.Exception($"예기치 못한 {subtoken.Type}.");
                    }
                    if (finish)
                        break;
                }
                break;
            case TokenType.ArrayOpen:
                baseElement = new CSONArray();
                while (readPtr < tokens.Count)
                {
                    var finish = false;
                    var subtoken = tokens[readPtr];
                    readPtr++;
                    switch (subtoken.Type)
                    {
                        case TokenType.Seperator:/*Do Nothing*/break;
                        case TokenType.String:
                            ((CSONArray)baseElement).Add(new CSONString() { Value = subtoken.Value });
                            break;
                        case TokenType.Integer:
                            ((CSONArray)baseElement).Add(new CSONInteger() { Value = int.Parse(subtoken.Value) });
                            break;
                        case TokenType.Real:
                            ((CSONArray)baseElement).Add(new CSONReal() { Value = double.Parse(subtoken.Value) });
                            break;
                        case TokenType.ObjectOpen:
                        case TokenType.SparseOpen:
                        case TokenType.ArrayOpen:
                            readPtr--;
                            ((CSONArray)baseElement).Add(ParseRecur(tokens, ref readPtr));
                            break;
                        case TokenType.ArrayClose:
                            finish = true;
                            break;
                        default:
                            throw new System.Exception($"예기치 못한 {subtoken.Type}.");
                    }
                    if (finish)
                        break;
                }
                break;
        }
        return baseElement;
    }
    public CSONElement Parse(string CSONString)
    {
        CSONString += " "; //공백을 추가해서 비-블록 구조의 데이터가 알고리즘 중간에 끊기는 일이 없도록 함
        // 주석은 배제되고 문자열이 토큰 형태로 묶인 리스트를 반환받습니다.
        List<ParseToken> tokens = Tokenize(CSONString.ToCharArray());
        int readPtr = 0;
        return ParseRecur(tokens, ref readPtr);
    }
}
#endregion