/// <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; }
/// <inheritdoc cref="HoconRoot()"/> /// <param name="value">The value to associate with this element.</param> public HoconRoot(HoconValue value) : this(value, Enumerable.Empty <HoconSubstitution>()) { }
/// <inheritdoc cref="GetValue(string)"/> public HoconValue GetValue(HoconPath path) { HoconValue value = GetNode(path); return(value); }
static HoconObject() { var value = new HoconValue(null); _empty = new HoconObject(value); }
/// <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>(); }
/// <inheritdoc cref="Config(HoconValue)" /> protected Config(HoconValue value, Config fallback) : this(value) { MergeConfig(fallback); }
/// <inheritdoc /> /// <summary> /// Initializes a new instance of the <see cref="Config" /> class. /// </summary> protected Config(HoconValue value) { Value = (HoconValue)value.Clone(null); }
static Config() { EmptyValue = new HoconValue(null); EmptyValue.Add(new HoconObject(EmptyValue)); }
protected bool Equals(HoconValue other) { return(Type == other.Type && GetString() == other.GetString()); }
/// <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); }