コード例 #1
0
ファイル: TableBuilder.cs プロジェクト: firleju/Nett
        private static TomlTable CreateTableArray(TomlTable.RootTable root, TableArrayNode tableArray, IHasComments comments)
        {
            System.Collections.Generic.IEnumerable <TerminalNode> keySegments = tableArray.Key.SyntaxNode().GetSegments();
            KeyChain chain = KeyChain.FromSegments(keySegments);

            if (chain.IsEmpty)
            {
                throw new InvalidOperationException("Empty TOML key is not allowed.");
            }

            TomlTable  owner    = FindOrCreateOwnerTableForTableArray(root, chain, out TomlKey last);
            TomlObject existing = owner.TryGetValue(last);

            if (existing != null && existing is TomlTableArray existingArray)
            {
                TomlTable newTable = new TomlTable(root);
                existingArray.Add(newTable);
                newTable.AddComments(comments);
                return(newTable);
            }
            else if (existing == null)
            {
                TomlTableArray newTableArray = new TomlTableArray(root);
                owner.AddRow(last, newTableArray);
                TomlTable newTable = new TomlTable(root);
                newTable.AddComments(comments);
                newTableArray.Add(newTable);
                return(newTable);
            }
            else
            {
                throw new InvalidOperationException($"Cannot define table array '{last}' as an object of type "
                                                    + $"'{existing.ReadableTypeName}' exists already.");
            }
        }
コード例 #2
0
ファイル: TableBuilder.cs プロジェクト: firleju/Nett
        private static TomlTable FindOrCreateOwnerTableForTableArray(TomlTable current, KeyChain keys, out TomlKey last)
        {
            if (keys.IsLastSegment)
            {
                last = keys.Key;
                return(current);
            }

            TomlObject row = current.TryGetValue(keys.Key);

            if (row != null)
            {
                if (row is TomlTable tbl)
                {
                    return(FindOrCreateOwnerTableForTable(tbl, keys.Next, out last));
                }
                else if (row is TomlTableArray ta)
                {
                    return(FindOrCreateOwnerTableForTableArray(ta.Items.Last(), keys.Next, out last));
                }
                else
                {
                    throw new InvalidOperationException(
                              $"Key '{keys}' corresponds to a TOML object hat is not of type TOML table or TOML table array.");
                }
            }
            else
            {
                TomlTableArray a = new TomlTableArray(current.Root);
                TomlTable      t = new TomlTable(current.Root);
                a.Add(t);
                current.AddRow(keys.Key, a);
                return(FindOrCreateOwnerTableForTableArray(t, keys.Next, out last));
            }
        }
コード例 #3
0
        private static TomlTableArray Apply(ITomlRoot root, TokenBuffer tokens)
        {
            tokens.ExpectAndConsume(TokenType.LBrac);
            tokens.ConsumeAllNewlines();

            var arr = new TomlTableArray(root);
            TomlTable tbl = null;
            while ((tbl = InlineTableProduction.TryApply(root, tokens)) != null)
            {
                arr.Add(tbl);

                if (tokens.TryExpect(TokenType.Comma))
                {
                    tokens.Consume();
                    tokens.ConsumeAllNewlines();
                }
                else
                {
                    tokens.ConsumeAllNewlines();
                    tokens.Expect(TokenType.RBrac);
                }
            }

            tokens.ConsumeAllNewlines();
            tokens.ExpectAndConsume(TokenType.RBrac);

            return arr;
        }
コード例 #4
0
            public void WriteTomlTableArray(TomlKey key, TomlTableArray tableArray)
            {
                this.WritePrependComments(tableArray);

                const string assignment = " = [ ";

                this.writer.Write(key.ToString());
                this.writer.Write(assignment);

                int    indentLen = key.ToString().Length + assignment.Length;
                string indent    = new string(' ', indentLen);

                for (int i = 0; i < tableArray.Items.Count; i++)
                {
                    this.WriteInlineTableBody(tableArray.Items[i]);

                    if (i < tableArray.Items.Count - 1)
                    {
                        this.writer.Write(",");
                        this.writer.WriteLine();
                        this.writer.Write(indent);
                    }
                }

                this.writer.WriteLine(" ]");
            }
コード例 #5
0
ファイル: TomlTableExtensions.cs プロジェクト: uheee/Nett
        public static TomlTable TransformToSourceTable(this TomlTable table, IConfigSource source, TomlObject rootSource = null)
        {
            table.CheckNotNull(nameof(table));

            var sourcesTable = rootSource == null
                ? Toml.Create(table.TableType)
                : TomlObjectFactory.CreateEmptyAttachedTable(rootSource, table.TableType);

            foreach (var r in table.Rows)
            {
                if (r.Value.TomlType == TomlObjectType.Table)
                {
                    sourcesTable[r.Key] = ((TomlTable)r.Value).TransformToSourceTable(source, sourcesTable);
                }
                else if (r.Value.TomlType == TomlObjectType.ArrayOfTables)
                {
                    var arr          = (TomlTableArray)r.Value;
                    var sourcesArray = new TomlTableArray(table.Root, arr.Items.Select(t => t.TransformToSourceTable(source, sourcesTable)));
                    sourcesTable[r.Key] = sourcesArray;
                }
                else
                {
                    sourcesTable[r.Key] = new TomlSource(sourcesTable.Root, source);
                }
            }

            return(sourcesTable);
        }
 private List <TimestampDefinition> ConvertTimeStampList(ITomlRoot root, TomlTableArray tomlTableArray)
 {
     return(tomlTableArray
            .Items
            .Select(t => CreateTimestampFromTable(root, t))
            .ToList());
 }
コード例 #7
0
        public static TomlTableArray Clone(this TomlTableArray source)
        {
            source.CheckNotNull(nameof(source));

            var cloned = new TomlTableArray(source.Root, source.Items.Select(i => i.Clone()));
            return cloned;
        }
コード例 #8
0
        private static TomlTableArray Apply(ITomlRoot root, TokenBuffer tokens)
        {
            tokens.ExpectAndConsume(TokenType.LBrac);
            tokens.ConsumeAllNewlines();

            var       arr = new TomlTableArray(root);
            TomlTable tbl = null;

            while ((tbl = InlineTableProduction.TryApply(root, tokens)) != null)
            {
                arr.Add(tbl);

                if (tokens.TryExpect(TokenType.Comma))
                {
                    tokens.Consume();
                    tokens.ConsumeAllNewlines();
                }
                else
                {
                    tokens.ConsumeAllNewlines();
                    tokens.Expect(TokenType.RBrac);
                }
            }

            tokens.ConsumeAllNewlines();
            tokens.ExpectAndConsume(TokenType.RBrac);

            return(arr);
        }
コード例 #9
0
 private static void ProcessTableArray(Dictionary <string, string> dict, TomlTableArray tableArray, string keyPrefix)
 {
     for (int i = 0; i < tableArray.Items.Count; i++)
     {
         TomlTable table = tableArray.Items[i];
         ProcessTable(dict, table, $"{keyPrefix}:{i}:");
     }
 }
コード例 #10
0
        public static TomlTableArray Clone(this TomlTableArray source)
        {
            source.CheckNotNull(nameof(source));

            var cloned = new TomlTableArray(source.Root, source.Items.Select(i => i.Clone()));

            return(cloned);
        }
 public void Visit(TomlTableArray tableArray)
 {
     for (int i = 0; i < tableArray.Count; i++)
     {
         PushContext(i.ToString());
         tableArray[i].Visit(this);
         PopContext();
     }
 }
コード例 #12
0
ファイル: TomlTableWriter.cs プロジェクト: zanedp/Nett
        internal static string WriteTomlFragment(TomlTableArray array)
        {
            return(WriteIntoStream(WriteTomlTableArray));

            void WriteTomlTableArray(FormattingStreamWriter stream)
            {
                var writer = new TomlTableWriter(stream, array.Root.Settings);

                writer.WriteTomlTableArray(string.Empty, KeyNotAvailable, array);
            }
        }
コード例 #13
0
        private static TomlTableArray Apply(ITomlRoot root, TokenBuffer tokens)
        {
            tokens.ExpectAndConsume(TokenType.LBrac);
            tokens.ConsumeAllNewlines();

            var prep = CommentProduction.TryParseComments(tokens, CommentLocation.Prepend);

            var arr = new TomlTableArray(root);

            while (true)
            {
                var tbl = InlineTableProduction.TryApply(root, tokens);
                if (tbl == null)
                {
                    break;
                }

                if (prep != null)
                {
                    tbl.AddComments(prep);
                    prep = null;
                }

                arr.Add(tbl);

                if (tokens.TryExpect(TokenType.Comma))
                {
                    tokens.Consume();
                    tokens.ConsumeAllNewlines();
                    tbl.AddComments(CommentProduction.TryParseComments(tokens, CommentLocation.Append));
                }
                else
                {
                    break;
                }
            }

            tokens.ConsumeAllNewlines();

            if (arr.Count > 0)
            {
                arr.Last().AddComments(CommentProduction.TryParseComments(tokens, CommentLocation.Append));
            }
            else
            {
                arr.AddComments(prep);
            }

            tokens.ExpectAndConsume(TokenType.RBrac);
            arr.AddComments(CommentProduction.TryParseComments(tokens, CommentLocation.Append));

            return(arr);
        }
コード例 #14
0
        private static TomlTable GetExistingOrCreateAndAddTableArray(TomlTable tbl, TomlKey key)
        {
            Func <TomlTable, TomlTable> createNew = (e) =>
            {
                var array    = new TomlTableArray(tbl.Root);
                var newTable = new TomlTable(tbl.Root);
                array.Add(newTable);
                tbl.AddRow(key, array);
                return(newTable);
            };

            return(GetExistinOrCreateAndAdd(tbl, key, createNew));
        }
コード例 #15
0
ファイル: ToJsonConverter.cs プロジェクト: paiden/Nett
        void ITomlObjectVisitor.Visit(TomlTableArray a)
        {
            sb.Append("[");

            for (int i = 0; i < a.Count - 1; i++)
            {
                a[i].Visit(this);
                this.sb.Append(",");
            }

            if (a.Count > 0) { a[a.Count - 1].Visit(this); }

            this.sb.Append("]");
        }
コード例 #16
0
        void ITomlObjectVisitor.Visit(TomlTableArray a)
        {
            sb.Append("[");

            for (int i = 0; i < a.Count - 1; i++)
            {
                a[i].Visit(this);
                this.sb.Append(",");
            }

            if (a.Count > 0)
            {
                a[a.Count - 1].Visit(this);
            }

            this.sb.Append("]");
        }
コード例 #17
0
ファイル: TomlTableWriter.cs プロジェクト: zanedp/Nett
        private void WriteTomlTableArray(string parentKey, TomlKey key, TomlTableArray tableArray)
        {
            if (IsInlineTomlTableArray(tableArray))
            {
                var inlineWriter = new TomlInlineTableWriter(this.writer, this.settings);
                inlineWriter.WriteTomlTableArray(key, tableArray);
            }
            else
            {
                this.WritePrependComments(tableArray);

                foreach (var t in tableArray.Items)
                {
                    this.writer.Write("[[");
                    this.writer.Write(parentKey + key.ToString());
                    this.writer.Write("]]");
                    this.writer.WriteLine();
                    this.WriteAppendComments(tableArray);
                    this.WriteTableRows(CombineKey(parentKey, key), t);
                }
            }
        }
コード例 #18
0
        private static TomlTableArray GetExistingOrCreateAndAdd(TomlTable target, TomlKey key, Token errorPosition)
        {
            TomlObject existing = target.TryGetValue(key);

            var typed = existing as TomlTableArray;

            if (existing != null && typed == null)
            {
                throw Parser.CreateParseError(
                          errorPosition,
                          $"Cannot create array of tables with key '{key}' because there already is an row with that key of type '{existing.ReadableTypeName}'.");
            }
            else if (typed != null)
            {
                return(typed);
            }

            var newTableArray = new TomlTableArray(target.Root);

            target.AddRow(key, newTableArray);

            return(newTableArray);
        }
コード例 #19
0
ファイル: ExpressionProduction.cs プロジェクト: paiden/Nett
        private static TomlTableArray GetExistingOrCreateAndAdd(TomlTable target, string name, Token errorPosition)
        {
            TomlObject existing = target.TryGetValue(name);

            var typed = existing as TomlTableArray;

            if (existing != null && typed == null)
            {
                throw Parser.CreateParseError(
                    errorPosition,
                    $"Cannot create array of tables with name '{name}' because there already is an row with that key of type '{existing.ReadableTypeName}'.");
            }
            else if (typed != null)
            {
                return typed;
            }

            var newTableArray = new TomlTableArray(target.Root);
            target.Add(name, newTableArray);

            return newTableArray;
        }
コード例 #20
0
ファイル: ExpressionProduction.cs プロジェクト: paiden/Nett
        private static TomlTable GetExistingOrCreateAndAddTableArray(TomlTable tbl, string key)
        {
            Func<TomlTable, TomlTable> createNew = (e) =>
            {
                var array = new TomlTableArray(tbl.Root);
                var newTable = new TomlTable(tbl.Root);
                array.Add(newTable);
                tbl.Add(key, array);
                return newTable;
            };

            return GetExistinOrCreateAndAdd(tbl, key, createNew);
        }
コード例 #21
0
ファイル: TomlTableWriter.cs プロジェクト: paiden/Nett
        private void WriteTomlTableArray(string parentKey, string key, TomlTableArray tableArray)
        {
            this.WritePrependComments(tableArray);

            foreach (var t in tableArray.Items)
            {
                this.writer.Write("[[");
                this.writer.Write(parentKey + key);
                this.writer.Write("]]");
                this.writer.WriteLine();
                this.WriteAppendComments(tableArray);
                this.WriteTableRows(CombineKey(parentKey, key), t);
            }
        }
コード例 #22
0
ファイル: TomlTableWriter.cs プロジェクト: zanedp/Nett
 private static bool IsInlineTomlTableArray(TomlTableArray a)
 => a.Items.Any(t => t.TableType == TomlTable.TableTypes.Inline);
コード例 #23
0
ファイル: TableBuilder.cs プロジェクト: firleju/Nett
        private static TomlObject ToTomlValue(ITomlRoot root, ValueNode node)
        {
            switch (node.Value.SyntaxNode())
            {
            case TerminalNode tn: return(CreateValueFromTerminal(tn.Terminal));

            case ArrayNode an: return(CreateArrayOrTableArray(an));

            case InlineTableNode it: return(CreateInlineTable(it));

            default: throw new Exception($"Cannot create TomlValue from node with type '{node.GetType()}'.");
            }

            TomlValue CreateValueFromTerminal(Token terminal)
            {
                switch (terminal.Type)
                {
                case TokenType.Integer: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 0)), TomlInt.IntTypes.Decimal));

                case TokenType.HexInteger: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 2), 16), TomlInt.IntTypes.Hex));

                case TokenType.BinaryInteger: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 2), 2), TomlInt.IntTypes.Binary));

                case TokenType.OctalInteger: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 2), 8), TomlInt.IntTypes.Octal));

                case TokenType.Bool: return(new TomlBool(root, Convert.ToBoolean(terminal.Value)));

                case TokenType.String: return(new TomlString(root, terminal.Value.Unescape(terminal)));

                case TokenType.LiteralString: return(new TomlString(root, terminal.Value, TomlString.TypeOfString.Literal));

                case TokenType.MultilineLiteralString: return(new TomlString(root, terminal.Value, TomlString.TypeOfString.MultilineLiteral));

                case TokenType.MultilineString: return(new TomlString(root, terminal.Value, TomlString.TypeOfString.Multiline));

                case TokenType.Float: return(TomlFloat.FromTerminal(root, terminal));

                case TokenType.OffsetDateTime: return(TomlOffsetDateTime.Parse(root, terminal.Value));

                case TokenType.LocalTime: return(TomlLocalTime.Parse(root, terminal.Value));

                case TokenType.Duration: return(TomlDuration.Parse(root, terminal.Value));

                case TokenType.LocalDate: return(TomlLocalDate.Parse(root, terminal.Value));

                case TokenType.LocalDateTime: return(TomlLocalDateTime.Parse(root, terminal.Value));

                default: throw new NotSupportedException();
                }

                string Cleanup(string s, int sub)
                => s.Substring(sub).Replace("_", string.Empty);
            }

            TomlObject CreateArrayOrTableArray(ArrayNode array)
            {
                var values = CreateValues(array.GetValues()).ToList();
                var tables = values.OfType <TomlTable>().ToList();

                if (tables.Count > 0 && tables.Count == values.Count)
                {
                    var ta = new TomlTableArray(root, tables);
                    ta.AddComments(array);
                    return(ta);
                }
                else if (tables.Count == 0)
                {
                    var arr = new TomlArray(root, values.Cast <TomlValue>().ToArray());
                    arr.AddComments(array);
                    return(arr);
                }
                else
                {
                    throw new InvalidOperationException("Array is a mixture of a value array and a TOML table array.");
                }

                IEnumerable <TomlObject> CreateValues(IEnumerable <ValueNode> nodes)
                {
                    var linked       = nodes.Select(n => Tuple.Create(n, ToTomlValue(root, n))).ToList();
                    var expectedType = linked.DistinctBy(n => n.Item2.GetType()).FirstOrDefault();
                    var wrongType    = linked.DistinctBy(n => n.Item2.GetType()).Skip(1).FirstOrDefault();

                    if (wrongType != null)
                    {
                        string msg = $"Expected array value of type '{expectedType.Item2.ReadableTypeName}' " +
                                     $"but value of type '{wrongType.Item2.ReadableTypeName}' was found.'";

                        throw ParseException.MessageForNode(wrongType.Item1, msg);
                    }

                    return(linked.Select(l => l.Item2));
                }
            }

            TomlTable CreateInlineTable(InlineTableNode it)
            {
                TomlTable table = new TomlTable(root, TomlTable.TableTypes.Inline);

                table.AddComments(it);

                System.Collections.Generic.IEnumerable <KeyValueExpressionNode> expressions = it.GetExpressions();

                foreach (KeyValueExpressionNode e in expressions)
                {
                    table.AddRow(e.Key.SyntaxNode().ExpressionKey(), ToTomlValue(root, e.Value.SyntaxNode()));
                }

                return(table);
            }
        }