private void ParseObject(HoconValue owner, bool root,string currentPath) { try { PushDiagnostics("{"); if (owner.IsObject()) { //the value of this KVP is already an object } else { //the value of this KVP is not an object, thus, we should add a new owner.NewValue(new HoconObject()); } HoconObject currentObject = owner.GetObject(); while (!_reader.EoF) { Token t = _reader.PullNext(); switch (t.Type) { case TokenType.Include: var included = _includeCallback(t.Value); var substitutions = included.Substitutions; foreach (var substitution in substitutions) { //fixup the substitution, add the current path as a prefix to the substitution path substitution.Path = currentPath + "." + substitution.Path; } _substitutions.AddRange(substitutions); var otherObj = included.Value.GetObject(); owner.GetObject().Merge(otherObj); break; case TokenType.EoF: if (!string.IsNullOrEmpty(currentPath)) { throw new HoconParserException(string.Format("Expected end of object but found EoF {0}",GetDiagnosticsStackTrace())); } break; case TokenType.Key: HoconValue value = currentObject.GetOrCreateKey(t.Value); var nextPath = currentPath == "" ? t.Value : currentPath + "." + t.Value; ParseKeyContent(value, nextPath); if (!root) return; break; case TokenType.ObjectEnd: return; } } } finally { PopDiagnostics(); } }
/// <summary> /// Parses the object. /// </summary> /// <param name="owner">The owner.</param> /// <param name="root">if set to <c>true</c> [root].</param> private void ParseObject(HoconValue owner, bool root) { if (owner.IsObject()) { //the value of this KVP is already an object } else { //the value of this KVP is not an object, thus, we should add a new owner.NewValue(new HoconObject()); } HoconObject currentObject = owner.GetObject(); while (!reader.EoF) { Token t = reader.PullNext(); switch (t.Type) { case TokenType.EoF: break; case TokenType.Key: HoconValue value = currentObject.GetOrCreateKey(t.Value); ParseKeyContent(value); if (!root) return; break; case TokenType.ObjectEnd: return; } } }
public Config(Config source, Config fallback) { if (source == null) throw new ArgumentNullException("source"); _node = source._node; this._fallback = fallback; }
public Config(HoconRoot root) { if (root.Value == null) throw new ArgumentNullException("root.Value"); this._node = root.Value; this._substitutions = root.Substitutions; }
/// <summary> /// Wraps this <see cref="HoconValue"/> into a new <see cref="Config"/> object at the specified key. /// </summary> /// <param name="key">The key designated to be the new root element.</param> /// <returns>A <see cref="Config"/> with the given key as the root element.</returns> public Config AtKey(string key) { var o = new HoconObject(); o.GetOrCreateKey(key); o.Items[key] = this; var r = new HoconValue(); r.Values.Add(o); return new Config(new HoconRoot(r)); }
public HoconValue GetOrCreateKey(string key) { if (_children.ContainsKey(key)) { return _children[key]; } var child = new HoconValue(); _children.Add(key, child); return child; }
public HoconValue GetOrCreateKey(string key) { if (Items.ContainsKey(key)) { return Items[key]; } var child = new HoconValue(); Items.Add(key, child); return child; }
private void ParseObject(HoconValue owner, bool root,string currentPath) { if (owner.IsObject()) { //the value of this KVP is already an object } else { //the value of this KVP is not an object, thus, we should add a new owner.NewValue(new HoconObject()); } HoconObject currentObject = owner.GetObject(); while (!_reader.EoF) { Token t = _reader.PullNext(); switch (t.Type) { case TokenType.Include: var included = _includeCallback(t.Value); var substitutions = included.Substitutions; foreach (var substitution in substitutions) { //fixup the substitution, add the current path as a prefix to the substitution path substitution.Path = currentPath + "." + substitution.Path; } _substitutions.AddRange(substitutions); var otherObj = included.Value.GetObject(); owner.GetObject().Merge(otherObj); break; case TokenType.EoF: break; case TokenType.Key: HoconValue value = currentObject.GetOrCreateKey(t.Value); var nextPath = currentPath == "" ? t.Value : currentPath + "." + t.Value; ParseKeyContent(value, nextPath); if (!root) return; break; case TokenType.ObjectEnd: return; } } }
/// <summary> /// Parses the text. /// </summary> /// <param name="text">The text.</param> /// <returns>HoconValue.</returns> /// <exception cref="System.Exception">Unresolved substitution: + sub.Path</exception> private HoconRoot ParseText(string text) { root = new HoconValue(); reader = new HoconTokenizer(text); reader.PullWhitespaceAndComments(); ParseObject(root, true); var c = new Config(new HoconRoot(root,Enumerable.Empty<HoconSubstitution>())); foreach (HoconSubstitution sub in substitutions) { HoconValue res = c.GetValue(sub.Path); if (res == null) throw new Exception("Unresolved substitution:" + sub.Path); sub.ResolvedValue = res; } return new HoconRoot(root, substitutions); }
private HoconRoot ParseText(string text,Func<string,HoconRoot> includeCallback) { _includeCallback = includeCallback; _root = new HoconValue(); _reader = new HoconTokenizer(text); _reader.PullWhitespaceAndComments(); ParseObject(_root, true,""); var c = new Config(new HoconRoot(_root, Enumerable.Empty<HoconSubstitution>())); foreach (HoconSubstitution sub in _substitutions) { HoconValue res = c.GetValue(sub.Path); if (res == null) throw new FormatException("Unresolved substitution:" + sub.Path); sub.ResolvedValue = res; } return new HoconRoot(_root, _substitutions); }
private void ParseKeyContent(HoconValue value) { while (!reader.EoF) { Token t = reader.PullNext(); switch (t.Type) { case TokenType.Dot: ParseObject(value, false); return; case TokenType.Assign: ParseValue(value); return; case TokenType.ObjectStart: ParseObject(value, true); return; } } }
/// <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> public void ParseValue(HoconValue owner,string currentPath) { if (_reader.EoF) throw new Exception("End of file reached while trying to read a value"); _reader.PullWhitespaceAndComments(); while (_reader.IsValue()) { Token t = _reader.PullValue(); switch (t.Type) { case TokenType.EoF: break; case TokenType.LiteralValue: if (owner.IsObject()) { //needed to allow for override objects owner.Clear(); } var lit = new HoconLiteral { Value = t.Value }; owner.AppendValue(lit); break; case TokenType.ObjectStart: ParseObject(owner, true,currentPath); break; case TokenType.ArrayStart: HoconArray arr = ParseArray(currentPath); owner.AppendValue(arr); break; case TokenType.Substitute: HoconSubstitution sub = ParseSubstitution(t.Value); _substitutions.Add(sub); owner.AppendValue(sub); break; } if (_reader.IsSpaceOrTab()) { ParseTrailingWhitespace(owner); } } IgnoreComma(); }
private void ParseKeyContent(HoconValue value,string currentPath) { while (!_reader.EoF) { Token t = _reader.PullNext(); switch (t.Type) { case TokenType.Dot: ParseObject(value, false,currentPath); return; case TokenType.Assign: if (!value.IsObject()) { //if not an object, then replace the value. //if object. value should be merged value.Clear(); } ParseValue(value,currentPath); return; case TokenType.ObjectStart: ParseObject(value, true,currentPath); return; } } }
/// <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>(); }
/// <summary> /// Initializes a new instance of the <see cref="HoconRoot"/> class. /// </summary> /// <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; }
public HoconRoot(HoconValue value) { Value = value; Substitutions = Enumerable.Empty <HoconSubstitution>(); }
public Config(Config source, Config fallback) { node = source.node; this.fallback = fallback; }
public Config(HoconValue node) { this._node = node; }
/// <summary> /// Parses the array. /// </summary> /// <returns>HoconArray.</returns> public HoconArray ParseArray() { var arr = new HoconArray(); while (!reader.EoF && !reader.IsArrayEnd()) { var v = new HoconValue(); ParseValue(v); arr.Add(v); reader.PullWhitespaceAndComments(); } reader.PullArrayEnd(); return arr; }
/// <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> public void ParseValue(HoconValue owner, string currentPath) { if (_reader.EoF) { throw new HoconParserException("End of file reached while trying to read a value"); } _reader.PullWhitespaceAndComments(); var start = _reader.Index; try { while (_reader.IsValue()) { Token t = _reader.PullValue(); switch (t.Type) { case TokenType.EoF: break; case TokenType.LiteralValue: if (owner.IsObject()) { //needed to allow for override objects owner.Clear(); } var lit = new HoconLiteral { Value = t.Value }; owner.AppendValue(lit); break; case TokenType.ObjectStart: ParseObject(owner, true, currentPath); break; case TokenType.ArrayStart: HoconArray arr = ParseArray(currentPath); owner.AppendValue(arr); break; case TokenType.Substitute: HoconSubstitution sub = ParseSubstitution(t.Value); _substitutions.Add(sub); owner.AppendValue(sub); break; } if (_reader.IsSpaceOrTab()) { ParseTrailingWhitespace(owner); } } IgnoreComma(); } catch (HoconTokenizerException tokenizerException) { throw new HoconParserException(string.Format("{0}\r{1}", tokenizerException.Message, GetDiagnosticsStackTrace()), tokenizerException); } finally { //no value was found, tokenizer is still at the same position if (_reader.Index == start) { throw new HoconParserException(string.Format("Hocon syntax error {0}\r{1}", _reader.GetHelpTextAtIndex(start), GetDiagnosticsStackTrace())); } } }
private void ParseTrailingWhitespace(HoconValue owner) { Token ws = _reader.PullSpaceOrTab(); //single line ws should be included if string concat if (ws.Value.Length > 0) { var wsLit = new HoconLiteral { Value = ws.Value, }; owner.AppendValue(wsLit); } }
/// <summary> /// Retrieves the next array token from the tokenizer. /// </summary> /// <returns>An array of elements retrieved from the token.</returns> public HoconArray ParseArray(string currentPath) { var arr = new HoconArray(); while (!_reader.EoF && !_reader.IsArrayEnd()) { var v = new HoconValue(); ParseValue(v,currentPath); arr.Add(v); _reader.PullWhitespaceAndComments(); } _reader.PullArrayEnd(); return arr; }
/// <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> public void ParseValue(HoconValue owner,string currentPath) { if (_reader.EoF) throw new HoconParserException("End of file reached while trying to read a value"); _reader.PullWhitespaceAndComments(); var start = _reader.Index; try { while (_reader.IsValue()) { Token t = _reader.PullValue(); switch (t.Type) { case TokenType.EoF: break; case TokenType.LiteralValue: if (owner.IsObject()) { //needed to allow for override objects owner.Clear(); } var lit = new HoconLiteral { Value = t.Value }; owner.AppendValue(lit); break; case TokenType.ObjectStart: ParseObject(owner, true, currentPath); break; case TokenType.ArrayStart: HoconArray arr = ParseArray(currentPath); owner.AppendValue(arr); break; case TokenType.Substitute: HoconSubstitution sub = ParseSubstitution(t.Value); _substitutions.Add(sub); owner.AppendValue(sub); break; } if (_reader.IsSpaceOrTab()) { ParseTrailingWhitespace(owner); } } IgnoreComma(); } catch(HoconTokenizerException tokenizerException) { throw new HoconParserException(string.Format("{0}\r{1}", tokenizerException.Message, GetDiagnosticsStackTrace()),tokenizerException); } finally { //no value was found, tokenizer is still at the same position if (_reader.Index == start) { throw new HoconParserException(string.Format("Hocon syntax error {0}\r{1}",_reader.GetHelpTextAtIndex(start),GetDiagnosticsStackTrace())); } } }
public HoconRoot(HoconValue value, IEnumerable <HoconSubstitution> substitutions) { Value = value; Substitutions = substitutions; }
private void ParseObject(HoconValue owner, bool root, string currentPath) { try { PushDiagnostics("{"); if (owner.IsObject()) { //the value of this KVP is already an object } else { //the value of this KVP is not an object, thus, we should add a new owner.NewValue(new HoconObject()); } HoconObject currentObject = owner.GetObject(); while (!_reader.EoF) { Token t = _reader.PullNext(); switch (t.Type) { case TokenType.Include: var included = _includeCallback(t.Value); var substitutions = included.Substitutions; foreach (var substitution in substitutions) { //fixup the substitution, add the current path as a prefix to the substitution path substitution.Path = currentPath + "." + substitution.Path; } _substitutions.AddRange(substitutions); var otherObj = included.Value.GetObject(); owner.GetObject().Merge(otherObj); break; case TokenType.EoF: if (!string.IsNullOrEmpty(currentPath)) { throw new HoconParserException(string.Format("Expected end of object but found EoF {0}", GetDiagnosticsStackTrace())); } break; case TokenType.Key: HoconValue value = currentObject.GetOrCreateKey(t.Value); var nextPath = currentPath == "" ? t.Value : currentPath + "." + t.Value; ParseKeyContent(value, nextPath); if (!root) { return; } break; case TokenType.ObjectEnd: return; } } } finally { PopDiagnostics(); } }
public Config(Config source, Config fallback) { _node = source._node; this._fallback = fallback; }
private void ParseKeyContent(HoconValue value,string currentPath) { try { var last = currentPath.Split('.').Last(); PushDiagnostics(string.Format("{0} = ", last)); while (!_reader.EoF) { Token t = _reader.PullNext(); switch (t.Type) { case TokenType.Dot: ParseObject(value, false, currentPath); return; case TokenType.Assign: if (!value.IsObject()) { //if not an object, then replace the value. //if object. value should be merged value.Clear(); } ParseValue(value, currentPath); return; case TokenType.ObjectStart: ParseObject(value, true, currentPath); return; } } } finally { PopDiagnostics(); } }