private void TryParseContentItems(YNode node, ref Dictionary <string, string> dict, string prefix = null) { switch (node) { case YKeyValuePair keyValuePair: string key = null; try { key = (string)keyValuePair.Key; } catch (System.Exception ex) { Debug.WriteLine(ex.Message); } key = string.IsNullOrEmpty(prefix) ? key : string.Concat(prefix, this.Separator, key); if (keyValuePair.Value is YScalar valueScalar) { dict[key] = valueScalar.Value; } else { this.TryParseContentItems(keyValuePair.Value, ref dict, key); } break; case YSequence sequence: // TODO: need suppoer Enum fields foreach (var sequenceChild in sequence.Children) { if (sequenceChild is YScalar yScalar) { dict[string.Concat(prefix, this.Separator, yScalar.Value)] = yScalar.Value; } } break; case YMapping mapping: foreach (var mapItem in mapping) { this.TryParseContentItems(mapItem, ref dict, prefix); } break; case IEnumerable <YNode> collection: foreach (var colItem in collection) { this.TryParseContentItems(colItem, ref dict, prefix); } break; } }
private static void TryGetContentItemsAsDynamic(YNode node, ref IDictionary <string, object> expandoObject) { switch (node) { case YKeyValuePair keyValuePair: string key = null; try { key = (string)keyValuePair.Key; } catch (Exception ex) { Debug.WriteLine(ex.Message); } if (keyValuePair.Value is YScalar valueScalar) { expandoObject[key] = valueScalar.Value; } else { var mapExpandoObject = new ExpandoObject() as IDictionary <string, object>; expandoObject[key] = mapExpandoObject; TryGetContentItemsAsDynamic(keyValuePair.Value, ref mapExpandoObject); } break; case YSequence sequence: // TODO: need support Enum fields throw new NotSupportedException(); case YMapping mapping: foreach (var mapItem in mapping) { TryGetContentItemsAsDynamic(mapItem, ref expandoObject); } break; case IEnumerable <YNode> collection: foreach (var colItem in collection) { TryGetContentItemsAsDynamic(colItem, ref expandoObject); } break; } }
private static void FindDuplicateNodes(YNode node, HashSet<YNode> visited, HashSet<YNode> duplicates) { if (visited.Contains(node)) { duplicates.Add(node); } else { visited.Add(node); foreach (var subNode in node.SubNodes) { FindDuplicateNodes(subNode, visited, duplicates); } } }
private static void FindDuplicateNodes(YNode node, HashSet <YNode> visited, HashSet <YNode> duplicates) { if (visited.Contains(node)) { duplicates.Add(node); } else { visited.Add(node); foreach (var subNode in node.SubNodes) { FindDuplicateNodes(subNode, visited, duplicates); } } }
internal new static YKeyValuePair Parse(Tokenizer tokenizer) { switch (tokenizer.Current.Kind) { case TokenKind.MappingKey: { tokenizer.MoveNext(); var key = YNode.Parse(tokenizer); if (tokenizer.Current.Kind != TokenKind.MappingValue) { return(new YKeyValuePair(key, new YScalar(null))); } tokenizer.MoveNext(); var value = YNode.Parse(tokenizer); return(new YKeyValuePair(key, value)); } case TokenKind.Alias: var keyAlias = YNode.Parse(tokenizer); tokenizer.MoveNext(); var valueAlias = YNode.Parse(tokenizer); return(new YKeyValuePair(keyAlias, valueAlias)); default: { var key = YNode.Parse(tokenizer); if (tokenizer.Current.Kind != TokenKind.MappingValue) { throw ParseException.UnexpectedToken(tokenizer, TokenKind.MappingValue); } tokenizer.MoveNext(); if (tokenizer.Current.Kind == TokenKind.Anchor) { return(null); } var value = YNode.Parse(tokenizer); return(new YKeyValuePair(key, value)); } } }
private static void GenerateNodeEvents(IntPtr pNativeEmitter, YNode node, IDictionary <YNode, string> aliases, HashSet <YNode> visited) { string alias; bool hasAlias = aliases.TryGetValue(node, out alias); bool isAnchor = hasAlias && !visited.Contains(node); bool isAlias = hasAlias && !isAnchor; if (isAnchor) { visited.Add(node); } if (isAlias) { GenerateEvent(pNativeEmitter, x => CreateEventAlias((YamlEvent *)x, alias)); } else { string anchor = isAnchor ? alias : null; var scalarNode = node as YScalar; var sequenceNode = node as YSequence; var mappingNode = node as YMapping; if (scalarNode != null) { GenerateSubTypeEvents(pNativeEmitter, scalarNode, aliases, anchor); } else if (sequenceNode != null) { GenerateSubTypeEvents(pNativeEmitter, sequenceNode, aliases, anchor, visited); } else if (mappingNode != null) { GenerateSubTypeEvents(pNativeEmitter, mappingNode, aliases, anchor, visited); } } }
/// <summary> /// 型'<see cref="CAP.Yencon.YBoolean"/>'の新しいインスタンスを生成します。 /// </summary> /// <param name="parent"> /// 新しい論理値の親セクションまたは親配列です。 /// </param> /// <param name="name">新しい論理値の名前です。</param> /// <exception cref="System.ArgumentNullException"/> /// <exception cref="System.ArgumentException"/> /// <exception cref="CAP.Yencon.Exceptions.InvalidNodeNameException"/> protected YBoolean(YNode parent, string name) : base(parent, name) { }
public void MergeY(YNode source, int offset, int length) { Array.Copy(source._keys, 0, _keys, offset, length); Array.Copy(source._values, 0, _values, offset, length); }
public void Split(YNode target, int offset, int length) { Array.Copy(_keys, offset, target._keys, 0, length); Array.Copy(_values, offset, target._values, 0, length); }
/// <summary> /// 上書きされた場合、ノードを書き込みます。 /// </summary> /// <param name="node">書き込むノードを表すオブジェクトです。</param> public abstract void Write(YNode node);
private void SetAnchor(string anchor, YNode node) { if (!string.IsNullOrEmpty(anchor)) anchors[anchor] = node; }
// .ToString() /// <summary> /// 型'<see cref="CAP.Yencon.YNumber"/>'の新しいインスタンスを生成します。 /// </summary> /// <param name="parent"> /// 新しい数値の親セクションまたは親配列です。 /// </param> /// <param name="name">新しい数値の名前です。</param> /// <exception cref="System.ArgumentNullException"/> /// <exception cref="System.ArgumentException"/> /// <exception cref="CAP.Yencon.Exceptions.InvalidNodeNameException"/> protected YNumber(YNode parent, string name) : base(parent, name) { }
string Annotator(int i, YNode n) { return(string.Format("node {0} depth {1}", i, n.Depth)); }
/// <summary> /// 型'<see cref="CAP.Yencon.YString"/>'の新しいインスタンスを生成します。 /// </summary> /// <param name="parent"> /// 新しいリンク文字列の親セクションまたは親配列です。 /// </param> /// <param name="name">新しいリンク文字列の名前です。</param> /// <exception cref="System.ArgumentNullException"/> /// <exception cref="System.ArgumentException"/> /// <exception cref="CAP.Yencon.Exceptions.InvalidNodeNameException"/> protected YLink(YNode parent, string name) : base(parent, name) { }
protected override bool RemoveNodeCore(YNode node) { return(_section?.RemoveNode(node) ?? false); }
public YKeyValuePair(YNode key, YNode value = null) : base(YNodeStyle.Block) { this.Key = key; this.Value = value; }
public YStringInternal(YNode parent, string name) : base(parent, name) { }
public YCommentInternal(YNode parent) : base(parent) { }
public YEmptyInternal(YNode parent, string name) : base(parent, name) { }
/// <summary> /// 型'<see cref="CAP.Yencon.YString"/>'の新しいインスタンスを生成します。 /// </summary> /// <param name="parent"> /// 新しい空値の親セクションまたは親配列です。 /// </param> /// <param name="name">新しい空値の名前です。</param> /// <exception cref="System.ArgumentNullException"/> /// <exception cref="System.ArgumentException"/> /// <exception cref="CAP.Yencon.Exceptions.InvalidNodeNameException"/> protected YEmpty(YNode parent, string name) : base(parent, name) { }
private static void GenerateNodeEvents(IntPtr pNativeEmitter, YNode node, IDictionary<YNode, string> aliases, HashSet<YNode> visited) { string alias; bool hasAlias = aliases.TryGetValue(node, out alias); bool isAnchor = hasAlias && !visited.Contains(node); bool isAlias = hasAlias && !isAnchor; if (isAnchor) { visited.Add(node); } if (isAlias) { GenerateEvent(pNativeEmitter, x => CreateEventAlias((YamlEvent*)x, alias)); } else { string anchor = isAnchor ? alias : null; var scalarNode = node as YScalar; var sequenceNode = node as YSequence; var mappingNode = node as YMapping; if (scalarNode != null) { GenerateSubTypeEvents(pNativeEmitter, scalarNode, aliases, anchor); } else if (sequenceNode != null) { GenerateSubTypeEvents(pNativeEmitter, sequenceNode, aliases, anchor, visited); } else if (mappingNode != null) { GenerateSubTypeEvents(pNativeEmitter, mappingNode, aliases, anchor, visited); } } }
string Annotator(int i,YNode n) { return string.Format("node {0} depth {1}",i,n.Depth); }
public YArrayInternal(YNode parent, string name) : base(parent, name) { _children = new List <YNode>(); this.Children = _children.AsReadOnly(); }
/// <summary> /// 型'<see cref="CAP.Yencon.YString"/>'の新しいインスタンスを生成します。 /// </summary> /// <param name="parent"> /// 新しいコメントの親セクションまたは親配列です。 /// </param> /// <exception cref="System.ArgumentNullException"/> /// <exception cref="System.ArgumentException"/> protected YComment(YNode parent) : base(parent, string.Empty) { }
protected override bool RemoveNodeCore(YNode node) { return(_children.Remove(node)); }
/// <summary> /// 型'<see cref="CAP.Yencon.YString"/>'の新しいインスタンスを生成します。 /// </summary> /// <param name="parent"> /// 新しい文字列値の親セクションまたは親配列です。 /// </param> /// <param name="name">新しい文字列値の名前です。</param> /// <exception cref="System.ArgumentNullException"/> /// <exception cref="System.ArgumentException"/> /// <exception cref="CAP.Yencon.Exceptions.InvalidNodeNameException"/> protected YString(YNode parent, string name) : base(parent, name) { }
static DocumentGrammar() { Boolean.Rule = Choice( YamlLexer.True.Constant(YBoolean.True), YamlLexer.False.Constant(YBoolean.False)); Null.Rule = YamlLexer.Null.Constant(YNull.Null); Number.Rule = YamlLexer.Number.BindLexeme(YNumber.FromString); QuotedString.Rule = Choice( YamlLexer.SingleQuotedString.BindLexeme(YString.FromQuotedString), YamlLexer.DoubleQuotedString.BindLexeme(YString.FromQuotedString)); UnquotedString.Rule = YamlLexer.UnquotedString.BindLexeme(YString.FromString); AnyString.Rule = Choice(QuotedString, UnquotedString); Alias.Rule = YamlLexer.Alias.BindLexeme(YAlias.FromString); BlockScalarText.Rule = from header in YamlLexer.BlockScalarHeader.Lexeme() from lines in Between( ScopeTokenKind.ScopeBegin.Kind(), OneOrMore(Choice(YamlLexer.BlockScalarLine.Lexeme(), YamlLexer.NewLine.Lexeme())), ScopeTokenKind.ScopeEnd.Kind()) select YString.FromBlockScalar(header, lines); BlockSequence.Rule = OneOrMore(YamlLexer.BlockSequenceItemMarker.Kind().Take(Node)) .Bind(YSequence.FromList); FlowSequence.Rule = Between(YamlLexer.FlowSequenceBegin.Kind(), ZeroOrMore(FlowNode, YamlLexer.FlowItemSeparator.Kind()), YamlLexer.FlowSequenceEnd.Kind()) .Bind(YSequence.FromList); BlockMapping.Rule = OneOrMore(NameValuePair(AnyString, YamlLexer.MappingSeparator.Kind(), Choice(Node, Alias))) .Bind(YMapping.FromDictionary); FlowMapping.Rule = Between( YamlLexer.FlowMappingBegin.Kind(), ZeroOrMore( NameValuePair( AnyString, YamlLexer.MappingSeparator.Kind(), Choice(FlowNode, Alias)), YamlLexer.FlowItemSeparator.Kind()), YamlLexer.FlowMappingEnd.Kind()) .Bind(YMapping.FromDictionary); FlowNode.Rule = from anchor in Optional(YamlLexer.Anchor.Lexeme()) from node in Choice <YNode>( FlowSequence, Attempt(FlowMapping), // enclosed into attempt lest it consumes QuotedString, UnquotedString QuotedString, Number, Boolean, Null, UnquotedString) select YNode.AttachAnchor(node, anchor); BlockNode.Rule = Between( ScopeTokenKind.ScopeBegin.Kind(), from anchor in Optional(YamlLexer.Anchor.Lexeme()) from node in Choice <YNode>( BlockSequence, Attempt(BlockMapping), // enclosed into attempt lest it consumes QuotedString, UnquotedString QuotedString, Number, Boolean, Null, BlockScalarText, UnquotedString) select YNode.AttachAnchor(node, anchor), ScopeTokenKind.ScopeEnd.Kind()); Node.Rule = Choice(FlowNode, BlockNode); TagDirective.Rule = YamlLexer.TagDirective.BindLexeme(YTagDirective.FromLexeme); YamlVersionDirective.Rule = YamlLexer.VersionDirective.BindLexeme(YVersionDirective.FromLexeme); Directive.Rule = Choice <YDirective>(TagDirective, YamlVersionDirective); BareDocument.Rule = Node.Bind(YDocument.FromBareNode); ExplicitDocument.Rule = YamlLexer.DirectivesEndMarker.Kind().Take(Optional(Node)).Bind(YDocument.FromBareNode); DirectivesDocument.Rule = from directives in OneOrMore(Directive) from body in YamlLexer.DirectivesEndMarker.Kind().Take(Node) select YDocument.Create(directives, body); Document.Rule = OccupiesEntireInput(Choice(DirectivesDocument, ExplicitDocument, BareDocument).ThenSkip(Optional(YamlLexer.DocumentEndMarker.Lexeme()))); }