コード例 #1
0
ファイル: HoconRoot.cs プロジェクト: nagytech/HOCON
 /// <inheritdoc cref="HoconRoot()"/>
 /// <param name="value">The value to associate with this element.</param>
 /// <param name="substitutions">An enumeration of substitutions to associate with this element.</param>
 public HoconRoot(HoconValue value, IEnumerable <HoconSubstitution> substitutions)
 {
     Value         = value;
     Substitutions = substitutions;
 }
コード例 #2
0
ファイル: HoconRoot.cs プロジェクト: nagytech/HOCON
 /// <inheritdoc cref="HoconRoot()"/>
 /// <param name="value">The value to associate with this element.</param>
 public HoconRoot(HoconValue value) : this(value, Enumerable.Empty <HoconSubstitution>())
 {
 }
コード例 #3
0
ファイル: HoconRoot.cs プロジェクト: nagytech/HOCON
        /// <inheritdoc cref="GetValue(string)"/>
        public HoconValue GetValue(HoconPath path)
        {
            HoconValue value = GetNode(path);

            return(value);
        }
コード例 #4
0
        static HoconObject()
        {
            var value = new HoconValue(null);

            _empty = new HoconObject(value);
        }
コード例 #5
0
ファイル: HoconRoot.cs プロジェクト: piksel/HOCON
 /// <summary>
 /// Initializes a new instance of the <see cref="HoconRoot"/> class.
 /// </summary>
 /// <param name="value">The value to associate with this element.</param>
 public HoconRoot(HoconValue value)
 {
     Value         = value;
     Substitutions = Enumerable.Empty <HoconSubstitution>();
 }
コード例 #6
0
ファイル: Config.cs プロジェクト: cptjazz/HOCON
 /// <inheritdoc cref="Config(HoconValue)" />
 protected Config(HoconValue value, Config fallback) : this(value)
 {
     MergeConfig(fallback);
 }
コード例 #7
0
ファイル: Config.cs プロジェクト: cptjazz/HOCON
 /// <inheritdoc />
 /// <summary>
 ///     Initializes a new instance of the <see cref="Config" /> class.
 /// </summary>
 protected Config(HoconValue value)
 {
     Value = (HoconValue)value.Clone(null);
 }
コード例 #8
0
ファイル: Config.cs プロジェクト: cptjazz/HOCON
 static Config()
 {
     EmptyValue = new HoconValue(null);
     EmptyValue.Add(new HoconObject(EmptyValue));
 }
コード例 #9
0
 protected bool Equals(HoconValue other)
 {
     return(Type == other.Type && GetString() == other.GetString());
 }
コード例 #10
0
ファイル: Parser.cs プロジェクト: nagytech/HOCON
        /// <summary>
        /// Retrieves the next value token from the tokenizer and appends it
        /// to the supplied element <paramref name="owner"/>.
        /// </summary>
        /// <param name="owner">The element to append the next token.</param>
        /// <exception cref="System.Exception">End of file reached while trying to read a value</exception>
        private HoconValue ParseValue(IHoconElement owner)
        {
            var value   = new HoconValue(owner);
            var parsing = true;

            while (parsing)
            {
                switch (_tokens.Current.Type)
                {
                case TokenType.Include:
                    value.Add(ParseInclude(value));
                    break;

                case TokenType.LiteralValue:
                    // Consume leading whitespaces.
                    if (_tokens.Current.IsNonSignificant())
                    {
                        ConsumeWhitespace();
                    }
                    if (_tokens.Current.Type != TokenType.LiteralValue)
                    {
                        break;
                    }

                    while (_tokens.Current.Type == TokenType.LiteralValue)
                    {
                        value.Add(HoconLiteral.Create(value, _tokens.Current));
                        _tokens.Next();
                    }
                    break;

                case TokenType.StartOfObject:
                    value.Add(ParseObject(value));
                    break;

                case TokenType.StartOfArray:
                    value.Add(ParseArray(value));
                    break;

                case TokenType.SubstituteOptional:
                case TokenType.SubstituteRequired:
                    var pointerPath       = HoconPath.Parse(_tokens.Current.Value);
                    HoconSubstitution sub = new HoconSubstitution(value, pointerPath, _tokens.Current,
                                                                  _tokens.Current.Type == TokenType.SubstituteRequired);
                    _substitutions.Add(sub);
                    value.Add(sub);
                    _tokens.Next();
                    break;

                case TokenType.EndOfObject:
                case TokenType.EndOfArray:
                    parsing = false;
                    break;

                // comments automatically stop value parsing.
                case TokenType.Comment:
                    ConsumeWhitelines();
                    parsing = false;
                    break;

                case TokenType.EndOfLine:
                    parsing = false;
                    break;

                case TokenType.EndOfFile:
                case TokenType.Comma:
                    parsing = false;
                    break;

                case TokenType.PlusEqualAssign:
                    HoconSubstitution subAssign = new HoconSubstitution(value, new HoconPath(Path), _tokens.Current, false);
                    _substitutions.Add(subAssign);
                    value.Add(subAssign);

                    value.Add(ParsePlusEqualAssignArray(value));
                    parsing = false;
                    break;

                case TokenType.Assign:
                    ConsumeWhitelines();
                    break;

                default:
                    throw HoconParserException.Create(_tokens.Current, Path,
                                                      $"Failed to parse Hocon value. Unexpected token: `{_tokens.Current.Type}`");
                }
            }

            // trim trailing whitespace if result is a literal
            if (value.Type == HoconType.Literal)
            {
                if (value[value.Count - 1] is HoconWhitespace)
                {
                    value.RemoveAt(value.Count - 1);
                }
            }
            return(value);
        }