Import YamlDotNet.
This commit is contained in:
311
Assets/YamlDotNet/Core/MergingParser.cs
Normal file
311
Assets/YamlDotNet/Core/MergingParser.cs
Normal file
@@ -0,0 +1,311 @@
|
||||
// This file is part of YamlDotNet - A .NET library for YAML.
|
||||
// Copyright (c) Antoine Aubry and contributors
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
// this software and associated documentation files (the "Software"), to deal in
|
||||
// the Software without restriction, including without limitation the rights to
|
||||
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
// of the Software, and to permit persons to whom the Software is furnished to do
|
||||
// so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using YamlDotNet.Core.Events;
|
||||
|
||||
namespace YamlDotNet.Core
|
||||
{
|
||||
/// <summary>
|
||||
/// Simple implementation of <see cref="IParser"/> that implements merging: http://yaml.org/type/merge.html
|
||||
/// </summary>
|
||||
public sealed class MergingParser : IParser
|
||||
{
|
||||
private readonly ParsingEventCollection events;
|
||||
private readonly IParser innerParser;
|
||||
private IEnumerator<LinkedListNode<ParsingEvent>> iterator;
|
||||
private bool merged;
|
||||
|
||||
public MergingParser(IParser innerParser)
|
||||
{
|
||||
events = new ParsingEventCollection();
|
||||
merged = false;
|
||||
iterator = events.GetEnumerator();
|
||||
this.innerParser = innerParser;
|
||||
}
|
||||
|
||||
public ParsingEvent? Current => iterator.Current?.Value;
|
||||
|
||||
public bool MoveNext()
|
||||
{
|
||||
if (!merged)
|
||||
{
|
||||
Merge();
|
||||
events.CleanMarked();
|
||||
iterator = events.GetEnumerator();
|
||||
merged = true;
|
||||
}
|
||||
|
||||
return iterator.MoveNext();
|
||||
}
|
||||
|
||||
private void Merge()
|
||||
{
|
||||
while (innerParser.MoveNext())
|
||||
{
|
||||
events.Add(innerParser.Current!);
|
||||
}
|
||||
|
||||
foreach (var node in events)
|
||||
{
|
||||
if (IsMergeToken(node))
|
||||
{
|
||||
events.MarkDeleted(node);
|
||||
if (!HandleMerge(node.Next))
|
||||
{
|
||||
throw new SemanticErrorException(node.Value.Start, node.Value.End, "Unrecognized merge key pattern");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private bool HandleMerge(LinkedListNode<ParsingEvent>? node)
|
||||
{
|
||||
if (node == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (node.Value is AnchorAlias anchorAlias)
|
||||
{
|
||||
return HandleAnchorAlias(node, node, anchorAlias);
|
||||
}
|
||||
|
||||
if (node.Value is SequenceStart)
|
||||
{
|
||||
return HandleSequence(node);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
private bool HandleMergeSequence(LinkedListNode<ParsingEvent> sequenceStart, LinkedListNode<ParsingEvent>? node)
|
||||
{
|
||||
if (node is null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (node.Value is AnchorAlias anchorAlias)
|
||||
{
|
||||
return HandleAnchorAlias(sequenceStart, node, anchorAlias);
|
||||
}
|
||||
if (node.Value is SequenceStart)
|
||||
{
|
||||
return HandleSequence(node);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private bool IsMergeToken(LinkedListNode<ParsingEvent> node)
|
||||
{
|
||||
return node.Value is Scalar merge && merge.Value == "<<";
|
||||
}
|
||||
|
||||
private bool HandleAnchorAlias(LinkedListNode<ParsingEvent> node, LinkedListNode<ParsingEvent> anchorNode, AnchorAlias anchorAlias)
|
||||
{
|
||||
var mergedEvents = GetMappingEvents(anchorAlias.Value);
|
||||
|
||||
events.AddAfter(node, mergedEvents);
|
||||
events.MarkDeleted(anchorNode);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool HandleSequence(LinkedListNode<ParsingEvent> node)
|
||||
{
|
||||
var sequenceStart = node;
|
||||
events.MarkDeleted(node);
|
||||
|
||||
var current = node;
|
||||
while (current != null)
|
||||
{
|
||||
if (current.Value is SequenceEnd)
|
||||
{
|
||||
events.MarkDeleted(current);
|
||||
return true;
|
||||
}
|
||||
|
||||
var next = current.Next;
|
||||
HandleMergeSequence(sequenceStart, next);
|
||||
current = next;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private IEnumerable<ParsingEvent> GetMappingEvents(AnchorName anchor)
|
||||
{
|
||||
var cloner = new ParsingEventCloner();
|
||||
var nesting = 0;
|
||||
|
||||
return events.FromAnchor(anchor)
|
||||
.Select(e => e.Value)
|
||||
.TakeWhile(e => (nesting += e.NestingIncrease) >= 0)
|
||||
.Select(e => cloner.Clone(e));
|
||||
}
|
||||
|
||||
private sealed class ParsingEventCollection : IEnumerable<LinkedListNode<ParsingEvent>>
|
||||
{
|
||||
private readonly LinkedList<ParsingEvent> events;
|
||||
private readonly HashSet<LinkedListNode<ParsingEvent>> deleted;
|
||||
private readonly Dictionary<AnchorName, LinkedListNode<ParsingEvent>> references;
|
||||
|
||||
public ParsingEventCollection()
|
||||
{
|
||||
events = new LinkedList<ParsingEvent>();
|
||||
deleted = new HashSet<LinkedListNode<ParsingEvent>>();
|
||||
references = new Dictionary<AnchorName, LinkedListNode<ParsingEvent>>();
|
||||
}
|
||||
|
||||
public void AddAfter(LinkedListNode<ParsingEvent> node, IEnumerable<ParsingEvent> items)
|
||||
{
|
||||
foreach (var item in items)
|
||||
{
|
||||
node = events.AddAfter(node, item);
|
||||
}
|
||||
}
|
||||
|
||||
public void Add(ParsingEvent item)
|
||||
{
|
||||
var node = events.AddLast(item);
|
||||
AddReference(item, node);
|
||||
}
|
||||
|
||||
public void MarkDeleted(LinkedListNode<ParsingEvent> node)
|
||||
{
|
||||
deleted.Add(node);
|
||||
}
|
||||
|
||||
public void CleanMarked()
|
||||
{
|
||||
foreach (var node in deleted)
|
||||
{
|
||||
events.Remove(node);
|
||||
}
|
||||
}
|
||||
|
||||
public IEnumerable<LinkedListNode<ParsingEvent>> FromAnchor(AnchorName anchor)
|
||||
{
|
||||
var node = references[anchor].Next;
|
||||
return Enumerate(node);
|
||||
}
|
||||
|
||||
public IEnumerator<LinkedListNode<ParsingEvent>> GetEnumerator() => Enumerate(events.First).GetEnumerator();
|
||||
|
||||
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
|
||||
|
||||
private IEnumerable<LinkedListNode<ParsingEvent>> Enumerate(LinkedListNode<ParsingEvent>? node)
|
||||
{
|
||||
while (node != null)
|
||||
{
|
||||
yield return node;
|
||||
node = node.Next;
|
||||
}
|
||||
}
|
||||
|
||||
private void AddReference(ParsingEvent item, LinkedListNode<ParsingEvent> node)
|
||||
{
|
||||
if (item is MappingStart mappingStart)
|
||||
{
|
||||
var anchor = mappingStart.Anchor;
|
||||
if (!anchor.IsEmpty)
|
||||
{
|
||||
references[anchor] = node;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private sealed class ParsingEventCloner : IParsingEventVisitor
|
||||
{
|
||||
private ParsingEvent? clonedEvent;
|
||||
|
||||
public ParsingEvent Clone(ParsingEvent e)
|
||||
{
|
||||
e.Accept(this);
|
||||
if (clonedEvent == null)
|
||||
{
|
||||
throw new InvalidOperationException($"Could not clone event of type '{e.Type}'");
|
||||
}
|
||||
|
||||
return clonedEvent;
|
||||
}
|
||||
|
||||
void IParsingEventVisitor.Visit(AnchorAlias e)
|
||||
{
|
||||
clonedEvent = new AnchorAlias(e.Value, e.Start, e.End);
|
||||
}
|
||||
|
||||
void IParsingEventVisitor.Visit(StreamStart e)
|
||||
{
|
||||
throw new NotSupportedException();
|
||||
}
|
||||
|
||||
void IParsingEventVisitor.Visit(StreamEnd e)
|
||||
{
|
||||
throw new NotSupportedException();
|
||||
}
|
||||
|
||||
void IParsingEventVisitor.Visit(DocumentStart e)
|
||||
{
|
||||
throw new NotSupportedException();
|
||||
}
|
||||
|
||||
void IParsingEventVisitor.Visit(DocumentEnd e)
|
||||
{
|
||||
throw new NotSupportedException();
|
||||
}
|
||||
|
||||
void IParsingEventVisitor.Visit(Scalar e)
|
||||
{
|
||||
clonedEvent = new Scalar(AnchorName.Empty, e.Tag, e.Value, e.Style, e.IsPlainImplicit, e.IsQuotedImplicit, e.Start, e.End);
|
||||
}
|
||||
|
||||
void IParsingEventVisitor.Visit(SequenceStart e)
|
||||
{
|
||||
clonedEvent = new SequenceStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
|
||||
}
|
||||
|
||||
void IParsingEventVisitor.Visit(SequenceEnd e)
|
||||
{
|
||||
clonedEvent = new SequenceEnd(e.Start, e.End);
|
||||
}
|
||||
|
||||
void IParsingEventVisitor.Visit(MappingStart e)
|
||||
{
|
||||
clonedEvent = new MappingStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
|
||||
}
|
||||
|
||||
void IParsingEventVisitor.Visit(MappingEnd e)
|
||||
{
|
||||
clonedEvent = new MappingEnd(e.Start, e.End);
|
||||
}
|
||||
|
||||
void IParsingEventVisitor.Visit(Comment e)
|
||||
{
|
||||
throw new NotSupportedException();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user