Pop_Slime/crtr
1
0
Fork 0
Code Issues 6 Pull Requests Projects 1 Releases Activity

Import YamlDotNet.

Browse Source
This commit is contained in:
PopSlime
2022-12-12 22:23:49 +08:00
parent f559cea826
commit 1477e907e6
462 changed files with 27142 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

111
Assets/YamlDotNet/RepresentationModel/DocumentLoadingState.cs Normal file
View File

@@ -0,0 +1,111 @@
// 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.Generic;
using System.Diagnostics.CodeAnalysis;
using YamlDotNet.Core;
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Manages the state of a <see cref="YamlDocument" /> while it is loading.
/// </summary>
internal class DocumentLoadingState
{
private readonly IDictionary<AnchorName, YamlNode> anchors = new Dictionary<AnchorName, YamlNode>();
private readonly IList<YamlNode> nodesWithUnresolvedAliases = new List<YamlNode>();
/// <summary>
/// Adds the specified node to the anchor list.
/// </summary>
/// <param name="node">The node.</param>
public void AddAnchor(YamlNode node)
{
if (node.Anchor.IsEmpty)
{
throw new ArgumentException("The specified node does not have an anchor");
}
if (anchors.ContainsKey(node.Anchor))
{
anchors[node.Anchor] = node;
}
else
{
anchors.Add(node.Anchor, node);
}
}
/// <summary>
/// Gets the node with the specified anchor.
/// </summary>
/// <param name="anchor">The anchor.</param>
/// <param name="start">The start position.</param>
/// <param name="end">The end position.</param>
/// <returns></returns>
/// <exception cref="AnchorNotFoundException">if there is no node with that anchor.</exception>
public YamlNode GetNode(AnchorName anchor, Mark start, Mark end)
{
if (anchors.TryGetValue(anchor, out var target))
{
return target;
}
else
{
throw new AnchorNotFoundException(start, end, $"The anchor '{anchor}' does not exists");
}
}
/// <summary>
/// Gets the node with the specified anchor.
/// </summary>
/// <param name="anchor">The anchor.</param>
/// <param name="node">The node that was retrieved.</param>
/// <returns>true if the anchor was found; otherwise false.</returns>
public bool TryGetNode(AnchorName anchor, [NotNullWhen(true)] out YamlNode? node)
{
return anchors.TryGetValue(anchor, out node);
}
/// <summary>
/// Adds the specified node to the collection of nodes with unresolved aliases.
/// </summary>
/// <param name="node">
/// The <see cref="YamlNode"/> that has unresolved aliases.
/// </param>
public void AddNodeWithUnresolvedAliases(YamlNode node)
{
nodesWithUnresolvedAliases.Add(node);
}
/// <summary>
/// Resolves the aliases that could not be resolved while loading the document.
/// </summary>
public void ResolveAliases()
{
foreach (var node in nodesWithUnresolvedAliases)
{
node.ResolveAliases(this);
}
}
}
}

11
Assets/YamlDotNet/RepresentationModel/DocumentLoadingState.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 76a242df6680b9742a2670bde85baa6e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

38
Assets/YamlDotNet/RepresentationModel/EmitterState.cs Normal file
View File

@@ -0,0 +1,38 @@
// 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.Collections.Generic;
using YamlDotNet.Core;
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Holds state that is used when emitting a stream.
/// </summary>
internal class EmitterState
{
/// <summary>
/// Gets the already emitted anchors.
/// </summary>
/// <value>The emitted anchors.</value>
public HashSet<AnchorName> EmittedAnchors { get; } = new HashSet<AnchorName>();
}
}

11
Assets/YamlDotNet/RepresentationModel/EmitterState.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: c3761b6b22a04a24fade56273bbb3c5b
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

69
Assets/YamlDotNet/RepresentationModel/IYamlVisitor.cs Normal file
View File

@@ -0,0 +1,69 @@
// 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.
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Defines the method needed to be able to visit Yaml elements.
/// </summary>
public interface IYamlVisitor
{
/// <summary>
/// Visits a <see cref="YamlStream"/>.
/// </summary>
/// <param name="stream">
/// The <see cref="YamlStream"/> that is being visited.
/// </param>
void Visit(YamlStream stream);
/// <summary>
/// Visits a <see cref="YamlDocument"/>.
/// </summary>
/// <param name="document">
/// The <see cref="YamlDocument"/> that is being visited.
/// </param>
void Visit(YamlDocument document);
/// <summary>
/// Visits a <see cref="YamlScalarNode"/>.
/// </summary>
/// <param name="scalar">
/// The <see cref="YamlScalarNode"/> that is being visited.
/// </param>
void Visit(YamlScalarNode scalar);
/// <summary>
/// Visits a <see cref="YamlSequenceNode"/>.
/// </summary>
/// <param name="sequence">
/// The <see cref="YamlSequenceNode"/> that is being visited.
/// </param>
void Visit(YamlSequenceNode sequence);
/// <summary>
/// Visits a <see cref="YamlMappingNode"/>.
/// </summary>
/// <param name="mapping">
/// The <see cref="YamlMappingNode"/> that is being visited.
/// </param>
void Visit(YamlMappingNode mapping);
}
}

11
Assets/YamlDotNet/RepresentationModel/IYamlVisitor.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: e12b6dd8690a6674696c7a997fdbd895
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

136
Assets/YamlDotNet/RepresentationModel/LibYamlEventStream.cs Normal file
View File

@@ -0,0 +1,136 @@
// 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.IO;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Represents a LibYAML event stream.
/// </summary>
public class LibYamlEventStream
{
private readonly IParser parser;
/// <summary>
/// Initializes a new instance of the <see cref="LibYamlEventStream"/> class
/// from the specified <see cref="IParser"/>.
/// </summary>
public LibYamlEventStream(IParser iParser)
{
parser = iParser ?? throw new ArgumentNullException(nameof(iParser));
}
public void WriteTo(TextWriter textWriter)
{
while (parser.MoveNext())
{
switch (parser.Current)
{
case AnchorAlias anchorAlias:
textWriter.Write("=ALI *");
textWriter.Write(anchorAlias.Value);
break;
case DocumentEnd documentEnd:
textWriter.Write("-DOC");
if (!documentEnd.IsImplicit)
{
textWriter.Write(" ...");
}
break;
case DocumentStart documentStart:
textWriter.Write("+DOC");
if (!documentStart.IsImplicit)
{
textWriter.Write(" ---");
}
break;
case MappingEnd _:
textWriter.Write("-MAP");
break;
case MappingStart mappingStart:
textWriter.Write("+MAP");
WriteAnchorAndTag(textWriter, mappingStart);
break;
case Scalar scalar:
textWriter.Write("=VAL");
WriteAnchorAndTag(textWriter, scalar);
switch (scalar.Style)
{
case ScalarStyle.DoubleQuoted: textWriter.Write(" \""); break;
case ScalarStyle.SingleQuoted: textWriter.Write(" '"); break;
case ScalarStyle.Folded: textWriter.Write(" >"); break;
case ScalarStyle.Literal: textWriter.Write(" |"); break;
default: textWriter.Write(" :"); break;
}
foreach (var character in scalar.Value)
{
switch (character)
{
case '\b': textWriter.Write("\\b"); break;
case '\t': textWriter.Write("\\t"); break;
case '\n': textWriter.Write("\\n"); break;
case '\r': textWriter.Write("\\r"); break;
case '\\': textWriter.Write("\\\\"); break;
default: textWriter.Write(character); break;
}
}
break;
case SequenceEnd _:
textWriter.Write("-SEQ");
break;
case SequenceStart sequenceStart:
textWriter.Write("+SEQ");
WriteAnchorAndTag(textWriter, sequenceStart);
break;
case StreamEnd _:
textWriter.Write("-STR");
break;
case StreamStart _:
textWriter.Write("+STR");
break;
}
textWriter.WriteLine();
}
}
private void WriteAnchorAndTag(TextWriter textWriter, NodeEvent nodeEvent)
{
if (!nodeEvent.Anchor.IsEmpty)
{
textWriter.Write(" &");
textWriter.Write(nodeEvent.Anchor);
}
if (!nodeEvent.Tag.IsEmpty)
{
textWriter.Write(" <");
textWriter.Write(nodeEvent.Tag.Value);
textWriter.Write(">");
}
}
}
}

11
Assets/YamlDotNet/RepresentationModel/LibYamlEventStream.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: a2468528a04d1c74f8301b7e6326e3ae
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

120
Assets/YamlDotNet/RepresentationModel/YamlAliasNode.cs Normal file
View File

@@ -0,0 +1,120 @@
// 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.Generic;
using YamlDotNet.Core;
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Represents an alias node in the YAML document.
/// </summary>
internal class YamlAliasNode : YamlNode
{
/// <summary>
/// Initializes a new instance of the <see cref="YamlAliasNode"/> class.
/// </summary>
/// <param name="anchor">The anchor.</param>
internal YamlAliasNode(AnchorName anchor)
{
Anchor = anchor;
}
/// <summary>
/// Resolves the aliases that could not be resolved when the node was created.
/// </summary>
/// <param name="state">The state of the document.</param>
internal override void ResolveAliases(DocumentLoadingState state)
{
throw new NotSupportedException("Resolving an alias on an alias node does not make sense");
}
/// <summary>
/// Saves the current node to the specified emitter.
/// </summary>
/// <param name="emitter">The emitter where the node is to be saved.</param>
/// <param name="state">The state.</param>
internal override void Emit(IEmitter emitter, EmitterState state)
{
throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be saved.");
}
/// <summary>
/// Accepts the specified visitor by calling the appropriate Visit method on it.
/// </summary>
/// <param name="visitor">
/// A <see cref="IYamlVisitor"/>.
/// </param>
public override void Accept(IYamlVisitor visitor)
{
throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be visited.");
}
/// <summary />
public override bool Equals(object? obj)
{
return obj is YamlAliasNode other
&& Equals(other)
&& Equals(Anchor, other.Anchor);
}
/// <summary>
/// Serves as a hash function for a particular type.
/// </summary>
/// <returns>
/// A hash code for the current <see cref="T:System.Object"/>.
/// </returns>
public override int GetHashCode()
{
return base.GetHashCode();
}
/// <summary>
/// Returns a <see cref="string"/> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="string"/> that represents this instance.
/// </returns>
internal override string ToString(RecursionLevel level)
{
return "*" + Anchor;
}
/// <summary>
/// Recursively enumerates all the nodes from the document, starting on the current node,
/// and throwing <see cref="MaximumRecursionLevelReachedException"/>
/// if <see cref="RecursionLevel.Maximum"/> is reached.
/// </summary>
internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
{
yield return this;
}
/// <summary>
/// Gets the type of node.
/// </summary>
public override YamlNodeType NodeType
{
get { return YamlNodeType.Alias; }
}
}
}

12
Assets/YamlDotNet/RepresentationModel/YamlAliasNode.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 72c7427f0fab35849b7545d301debcd5
timeCreated: 1427145264
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

211
Assets/YamlDotNet/RepresentationModel/YamlDocument.cs Normal file
View File

@@ -0,0 +1,211 @@
// 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.Generic;
using System.Diagnostics;
using System.Globalization;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Represents an YAML document.
/// </summary>
public class YamlDocument
{
/// <summary>
/// Gets or sets the root node.
/// </summary>
/// <value>The root node.</value>
public YamlNode RootNode { get; private set; }
/// <summary>
/// Initializes a new instance of the <see cref="YamlDocument"/> class.
/// </summary>
public YamlDocument(YamlNode rootNode)
{
RootNode = rootNode;
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlDocument"/> class with a single scalar node.
/// </summary>
public YamlDocument(string rootNode)
{
RootNode = new YamlScalarNode(rootNode);
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlDocument"/> class.
/// </summary>
internal YamlDocument(IParser parser)
{
var state = new DocumentLoadingState();
parser.Consume<DocumentStart>();
while (!parser.TryConsume<DocumentEnd>(out var _))
{
Debug.Assert(RootNode == null);
RootNode = YamlNode.ParseNode(parser, state);
if (RootNode is YamlAliasNode)
{
throw new YamlException("A document cannot contain only an alias");
}
}
state.ResolveAliases();
// Throw should not happen unless the parser has a bug
RootNode = RootNode ?? throw new ArgumentException("Atempted to parse an empty document");
}
/// <summary>
/// Visitor that assigns anchors to nodes that are referenced more than once.
/// Existing anchors are preserved as much as possible.
/// </summary>
private class AnchorAssigningVisitor : YamlVisitorBase
{
private readonly HashSet<AnchorName> existingAnchors = new HashSet<AnchorName>();
/// <summary>
/// Key: Node, Value: IsDuplicate
/// </summary>
private readonly Dictionary<YamlNode, bool> visitedNodes = new Dictionary<YamlNode, bool>();
public void AssignAnchors(YamlDocument document)
{
existingAnchors.Clear();
visitedNodes.Clear();
document.Accept(this);
var random = new Random();
foreach (var visitedNode in visitedNodes)
{
if (visitedNode.Value)
{
AnchorName anchor;
// If the existing anchor is not already used, we can have it
if (!visitedNode.Key.Anchor.IsEmpty && !existingAnchors.Contains(visitedNode.Key.Anchor))
{
anchor = visitedNode.Key.Anchor;
}
else
{
do
{
anchor = new AnchorName(random.Next().ToString(CultureInfo.InvariantCulture));
} while (existingAnchors.Contains(anchor));
}
existingAnchors.Add(anchor);
visitedNode.Key.Anchor = anchor;
}
}
}
/// <summary>
/// Returns whether the visited node is a duplicate.
/// </summary>
private bool VisitNodeAndFindDuplicates(YamlNode node)
{
if (visitedNodes.TryGetValue(node, out var isDuplicate))
{
if (!isDuplicate)
{
visitedNodes[node] = true;
}
return !isDuplicate;
}
else
{
visitedNodes.Add(node, false);
return false;
}
}
public override void Visit(YamlScalarNode scalar)
{
VisitNodeAndFindDuplicates(scalar);
}
public override void Visit(YamlMappingNode mapping)
{
if (!VisitNodeAndFindDuplicates(mapping))
{
base.Visit(mapping);
}
}
public override void Visit(YamlSequenceNode sequence)
{
if (!VisitNodeAndFindDuplicates(sequence))
{
base.Visit(sequence);
}
}
}
private void AssignAnchors()
{
var visitor = new AnchorAssigningVisitor();
visitor.AssignAnchors(this);
}
internal void Save(IEmitter emitter, bool assignAnchors = true)
{
if (assignAnchors)
{
AssignAnchors();
}
emitter.Emit(new DocumentStart());
RootNode.Save(emitter, new EmitterState());
emitter.Emit(new DocumentEnd(false));
}
/// <summary>
/// Accepts the specified visitor by calling the appropriate Visit method on it.
/// </summary>
/// <param name="visitor">
/// A <see cref="IYamlVisitor"/>.
/// </param>
public void Accept(IYamlVisitor visitor)
{
visitor.Visit(this);
}
/// <summary>
/// Gets all nodes from the document.
/// <see cref="MaximumRecursionLevelReachedException"/> is thrown if an infinite recursion is detected.
/// </summary>
public IEnumerable<YamlNode> AllNodes
{
get
{
return RootNode.AllNodes;
}
}
}
}

12
Assets/YamlDotNet/RepresentationModel/YamlDocument.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: aa500eae79de1e8429a325722afbf4e8
timeCreated: 1427145265
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

425
Assets/YamlDotNet/RepresentationModel/YamlMappingNode.cs Normal file
View File

@@ -0,0 +1,425 @@
// 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.Generic;
using System.Text;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using static YamlDotNet.Core.HashCode;
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Represents a mapping node in the YAML document.
/// </summary>
public sealed class YamlMappingNode : YamlNode, IEnumerable<KeyValuePair<YamlNode, YamlNode>>, IYamlConvertible
{
private readonly IOrderedDictionary<YamlNode, YamlNode> children = new OrderedDictionary<YamlNode, YamlNode>();
/// <summary>
/// Gets the children of the current node.
/// </summary>
/// <value>The children.</value>
public IOrderedDictionary<YamlNode, YamlNode> Children
{
get
{
return children;
}
}
/// <summary>
/// Gets or sets the style of the node.
/// </summary>
/// <value>The style.</value>
public MappingStyle Style { get; set; }
/// <summary>
/// Initializes a new instance of the <see cref="YamlMappingNode"/> class.
/// </summary>
internal YamlMappingNode(IParser parser, DocumentLoadingState state)
{
Load(parser, state);
}
private void Load(IParser parser, DocumentLoadingState state)
{
var mapping = parser.Consume<MappingStart>();
Load(mapping, state);
Style = mapping.Style;
var hasUnresolvedAliases = false;
while (!parser.TryConsume<MappingEnd>(out var _))
{
var key = ParseNode(parser, state);
var value = ParseNode(parser, state);
try
{
children.Add(key, value);
}
catch (ArgumentException err)
{
throw new YamlException(key.Start, key.End, "Duplicate key", err);
}
hasUnresolvedAliases |= key is YamlAliasNode || value is YamlAliasNode;
}
if (hasUnresolvedAliases)
{
state.AddNodeWithUnresolvedAliases(this);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlMappingNode"/> class.
/// </summary>
public YamlMappingNode()
{
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlMappingNode"/> class.
/// </summary>
public YamlMappingNode(params KeyValuePair<YamlNode, YamlNode>[] children)
: this((IEnumerable<KeyValuePair<YamlNode, YamlNode>>)children)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlMappingNode"/> class.
/// </summary>
public YamlMappingNode(IEnumerable<KeyValuePair<YamlNode, YamlNode>> children)
{
foreach (var child in children)
{
this.children.Add(child);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlMappingNode"/> class.
/// </summary>
/// <param name="children">A sequence of <see cref="YamlNode"/> where even elements are keys and odd elements are values.</param>
public YamlMappingNode(params YamlNode[] children)
: this((IEnumerable<YamlNode>)children)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlMappingNode"/> class.
/// </summary>
/// <param name="children">A sequence of <see cref="YamlNode"/> where even elements are keys and odd elements are values.</param>
public YamlMappingNode(IEnumerable<YamlNode> children)
{
using var enumerator = children.GetEnumerator();
while (enumerator.MoveNext())
{
var key = enumerator.Current;
if (!enumerator.MoveNext())
{
throw new ArgumentException("When constructing a mapping node with a sequence, the number of elements of the sequence must be even.");
}
Add(key, enumerator.Current);
}
}
/// <summary>
/// Adds the specified mapping to the <see cref="Children"/> collection.
/// </summary>
/// <param name="key">The key node.</param>
/// <param name="value">The value node.</param>
public void Add(YamlNode key, YamlNode value)
{
children.Add(key, value);
}
/// <summary>
/// Adds the specified mapping to the <see cref="Children"/> collection.
/// </summary>
/// <param name="key">The key node.</param>
/// <param name="value">The value node.</param>
public void Add(string key, YamlNode value)
{
children.Add(new YamlScalarNode(key), value);
}
/// <summary>
/// Adds the specified mapping to the <see cref="Children"/> collection.
/// </summary>
/// <param name="key">The key node.</param>
/// <param name="value">The value node.</param>
public void Add(YamlNode key, string value)
{
children.Add(key, new YamlScalarNode(value));
}
/// <summary>
/// Adds the specified mapping to the <see cref="Children"/> collection.
/// </summary>
/// <param name="key">The key node.</param>
/// <param name="value">The value node.</param>
public void Add(string key, string value)
{
children.Add(new YamlScalarNode(key), new YamlScalarNode(value));
}
/// <summary>
/// Resolves the aliases that could not be resolved when the node was created.
/// </summary>
/// <param name="state">The state of the document.</param>
internal override void ResolveAliases(DocumentLoadingState state)
{
Dictionary<YamlNode, YamlNode>? keysToUpdate = null;
Dictionary<YamlNode, YamlNode>? valuesToUpdate = null;
foreach (var entry in children)
{
if (entry.Key is YamlAliasNode)
{
if (keysToUpdate == null)
{
keysToUpdate = new Dictionary<YamlNode, YamlNode>();
}
// TODO: The representation model should be redesigned, because here the anchor could be null but that would be invalid YAML
keysToUpdate.Add(entry.Key, state.GetNode(entry.Key.Anchor!, entry.Key.Start, entry.Key.End));
}
if (entry.Value is YamlAliasNode)
{
if (valuesToUpdate == null)
{
valuesToUpdate = new Dictionary<YamlNode, YamlNode>();
}
// TODO: The representation model should be redesigned, because here the anchor could be null but that would be invalid YAML
valuesToUpdate.Add(entry.Key, state.GetNode(entry.Value.Anchor!, entry.Value.Start, entry.Value.End));
}
}
if (valuesToUpdate != null)
{
foreach (var entry in valuesToUpdate)
{
children[entry.Key] = entry.Value;
}
}
if (keysToUpdate != null)
{
foreach (var entry in keysToUpdate)
{
var value = children[entry.Key];
children.Remove(entry.Key);
children.Add(entry.Value, value);
}
}
}
/// <summary>
/// Saves the current node to the specified emitter.
/// </summary>
/// <param name="emitter">The emitter where the node is to be saved.</param>
/// <param name="state">The state.</param>
internal override void Emit(IEmitter emitter, EmitterState state)
{
emitter.Emit(new MappingStart(Anchor, Tag, true, Style));
foreach (var entry in children)
{
entry.Key.Save(emitter, state);
entry.Value.Save(emitter, state);
}
emitter.Emit(new MappingEnd());
}
/// <summary>
/// Accepts the specified visitor by calling the appropriate Visit method on it.
/// </summary>
/// <param name="visitor">
/// A <see cref="IYamlVisitor"/>.
/// </param>
public override void Accept(IYamlVisitor visitor)
{
visitor.Visit(this);
}
/// <summary />
public override bool Equals(object? obj)
{
var other = obj as YamlMappingNode;
var areEqual = other != null
&& Equals(Tag, other.Tag)
&& children.Count == other.children.Count;
if (!areEqual)
{
return false;
}
foreach (var entry in children)
{
if (!other!.children.TryGetValue(entry.Key, out var otherNode) || !Equals(entry.Value, otherNode))
{
return false;
}
}
return true;
}
/// <summary>
/// Serves as a hash function for a particular type.
/// </summary>
/// <returns>
/// A hash code for the current <see cref="T:System.Object"/>.
/// </returns>
public override int GetHashCode()
{
var hashCode = base.GetHashCode();
foreach (var entry in children)
{
hashCode = CombineHashCodes(hashCode, entry.Key);
hashCode = CombineHashCodes(hashCode, entry.Value);
}
return hashCode;
}
/// <summary>
/// Recursively enumerates all the nodes from the document, starting on the current node,
/// and throwing <see cref="MaximumRecursionLevelReachedException"/>
/// if <see cref="RecursionLevel.Maximum"/> is reached.
/// </summary>
internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
{
level.Increment();
yield return this;
foreach (var child in children)
{
foreach (var node in child.Key.SafeAllNodes(level))
{
yield return node;
}
foreach (var node in child.Value.SafeAllNodes(level))
{
yield return node;
}
}
level.Decrement();
}
/// <summary>
/// Gets the type of node.
/// </summary>
public override YamlNodeType NodeType
{
get { return YamlNodeType.Mapping; }
}
/// <summary>
/// Returns a <see cref="string"/> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="string"/> that represents this instance.
/// </returns>
internal override string ToString(RecursionLevel level)
{
if (!level.TryIncrement())
{
return MaximumRecursionLevelReachedToStringValue;
}
var text = new StringBuilder("{ ");
foreach (var child in children)
{
if (text.Length > 2)
{
text.Append(", ");
}
text.Append("{ ").Append(child.Key.ToString(level)).Append(", ").Append(child.Value.ToString(level)).Append(" }");
}
text.Append(" }");
level.Decrement();
return text.ToString();
}
#region IEnumerable<KeyValuePair<YamlNode,YamlNode>> Members
/// <summary />
public IEnumerator<KeyValuePair<YamlNode, YamlNode>> GetEnumerator()
{
return children.GetEnumerator();
}
#endregion
#region IEnumerable Members
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
#endregion
void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
{
Load(parser, new DocumentLoadingState());
}
void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
{
Emit(emitter, new EmitterState());
}
/// <summary>
/// Creates a <see cref="YamlMappingNode" /> containing a key-value pair for each property of the specified object.
/// </summary>
public static YamlMappingNode FromObject(object mapping)
{
if (mapping == null)
{
throw new ArgumentNullException(nameof(mapping));
}
var result = new YamlMappingNode();
foreach (var property in mapping.GetType().GetPublicProperties())
{
// CanRead == true => GetGetMethod() != null
if (property.CanRead && property.GetGetMethod(false)!.GetParameters().Length == 0)
{
var value = property.GetValue(mapping, null);
if (!(value is YamlNode valueNode))
{
var valueAsString = Convert.ToString(value);
valueNode = valueAsString ?? string.Empty;
}
result.Add(property.Name, valueNode);
}
}
return result;
}
}
}

12
Assets/YamlDotNet/RepresentationModel/YamlMappingNode.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 283c72dc1a159584988a79dd9d0a0a93
timeCreated: 1427145263
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

236
Assets/YamlDotNet/RepresentationModel/YamlNode.cs Normal file
View File

@@ -0,0 +1,236 @@
// 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.Generic;
using System.Linq;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Represents a single node in the YAML document.
/// </summary>
public abstract class YamlNode
{
private const int MaximumRecursionLevel = 1000;
internal const string MaximumRecursionLevelReachedToStringValue = "WARNING! INFINITE RECURSION!";
/// <summary>
/// Gets or sets the anchor of the node.
/// </summary>
/// <value>The anchor.</value>
public AnchorName Anchor { get; set; }
/// <summary>
/// Gets or sets the tag of the node.
/// </summary>
/// <value>The tag.</value>
public TagName Tag { get; set; }
/// <summary>
/// Gets the position in the input stream where the event that originated the node starts.
/// </summary>
public Mark Start { get; private set; } = Mark.Empty;
/// <summary>
/// Gets the position in the input stream where the event that originated the node ends.
/// </summary>
public Mark End { get; private set; } = Mark.Empty;
/// <summary>
/// Loads the specified event.
/// </summary>
/// <param name="yamlEvent">The event.</param>
/// <param name="state">The state of the document.</param>
internal void Load(NodeEvent yamlEvent, DocumentLoadingState state)
{
Tag = yamlEvent.Tag;
if (!yamlEvent.Anchor.IsEmpty)
{
Anchor = yamlEvent.Anchor;
state.AddAnchor(this);
}
Start = yamlEvent.Start;
End = yamlEvent.End;
}
/// <summary>
/// Parses the node represented by the next event in <paramref name="parser" />.
/// </summary>
/// <returns>Returns the node that has been parsed.</returns>
internal static YamlNode ParseNode(IParser parser, DocumentLoadingState state)
{
if (parser.Accept<Scalar>(out var _))
{
return new YamlScalarNode(parser, state);
}
if (parser.Accept<SequenceStart>(out var _))
{
return new YamlSequenceNode(parser, state);
}
if (parser.Accept<MappingStart>(out var _))
{
return new YamlMappingNode(parser, state);
}
if (parser.TryConsume<AnchorAlias>(out var alias))
{
return state.TryGetNode(alias.Value, out var node) ? node : new YamlAliasNode(alias.Value);
}
throw new ArgumentException("The current event is of an unsupported type.", nameof(parser));
}
/// <summary>
/// Resolves the aliases that could not be resolved when the node was created.
/// </summary>
/// <param name="state">The state of the document.</param>
internal abstract void ResolveAliases(DocumentLoadingState state);
/// <summary>
/// Saves the current node to the specified emitter.
/// </summary>
/// <param name="emitter">The emitter where the node is to be saved.</param>
/// <param name="state">The state.</param>
internal void Save(IEmitter emitter, EmitterState state)
{
if (!Anchor.IsEmpty && !state.EmittedAnchors.Add(Anchor))
{
emitter.Emit(new AnchorAlias(Anchor));
}
else
{
Emit(emitter, state);
}
}
/// <summary>
/// Saves the current node to the specified emitter.
/// </summary>
/// <param name="emitter">The emitter where the node is to be saved.</param>
/// <param name="state">The state.</param>
internal abstract void Emit(IEmitter emitter, EmitterState state);
/// <summary>
/// Accepts the specified visitor by calling the appropriate Visit method on it.
/// </summary>
/// <param name="visitor">
/// A <see cref="IYamlVisitor"/>.
/// </param>
public abstract void Accept(IYamlVisitor visitor);
public override string ToString()
{
var level = new RecursionLevel(MaximumRecursionLevel);
return ToString(level);
}
internal abstract string ToString(RecursionLevel level);
/// <summary>
/// Gets all nodes from the document, starting on the current node.
/// <see cref="MaximumRecursionLevelReachedException"/> is thrown if an infinite recursion is detected.
/// </summary>
public IEnumerable<YamlNode> AllNodes
{
get
{
var level = new RecursionLevel(MaximumRecursionLevel);
return SafeAllNodes(level);
}
}
/// <summary>
/// When implemented, recursively enumerates all the nodes from the document, starting on the current node.
/// If <see cref="RecursionLevel.Maximum"/> is reached, a <see cref="MaximumRecursionLevelReachedException"/> is thrown
/// instead of continuing and crashing with a <see cref="StackOverflowException"/>.
/// </summary>
internal abstract IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level);
/// <summary>
/// Gets the type of node.
/// </summary>
public abstract YamlNodeType NodeType
{
get;
}
/// <summary>
/// Performs an implicit conversion from <see cref="string"/> to <see cref="YamlNode"/>.
/// </summary>
/// <param name="value">The value.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator YamlNode(string value)
{
return new YamlScalarNode(value);
}
/// <summary>
/// Performs an implicit conversion from string[] to <see cref="YamlNode"/>.
/// </summary>
/// <param name="sequence">The value.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator YamlNode(string[] sequence)
{
return new YamlSequenceNode(sequence.Select(i => (YamlNode)i));
}
/// <summary>
/// Converts a <see cref="YamlScalarNode" /> to a string by returning its value.
/// </summary>
public static explicit operator string?(YamlNode node)
{
return node is YamlScalarNode scalar
? scalar.Value
: throw new ArgumentException($"Attempted to convert a '{node.NodeType}' to string. This conversion is valid only for Scalars.");
}
/// <summary>
/// Gets the nth element in a <see cref="YamlSequenceNode" />.
/// </summary>
public YamlNode this[int index]
{
get
{
return this is YamlSequenceNode sequence
? sequence.Children[index]
: throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {index}. Only Sequences can be indexed by number.");
}
}
/// <summary>
/// Gets the value associated with a key in a <see cref="YamlMappingNode" />.
/// </summary>
public YamlNode this[YamlNode key]
{
get
{
return this is YamlMappingNode mapping
? mapping.Children[key]
: throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {key}. Only Mappings can be indexed by key.");
}
}
}
}

12
Assets/YamlDotNet/RepresentationModel/YamlNode.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: b80625eae8f97124f832aed15c4c6b57
timeCreated: 1427145265
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

48
Assets/YamlDotNet/RepresentationModel/YamlNodeIdentityEqualityComparer.cs Normal file
View File

@@ -0,0 +1,48 @@
// 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.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Comparer that is based on identity comparisons.
/// </summary>
public sealed class YamlNodeIdentityEqualityComparer : IEqualityComparer<YamlNode>
{
#region IEqualityComparer<YamlNode> Members
/// <summary />
public bool Equals([AllowNull] YamlNode x, [AllowNull] YamlNode y)
{
return ReferenceEquals(x, y);
}
/// <summary />
public int GetHashCode(YamlNode obj)
{
return obj.GetHashCode();
}
#endregion
}
}

11
Assets/YamlDotNet/RepresentationModel/YamlNodeIdentityEqualityComparer.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 70ec622c4d503a448ba4d5410c55d8bd
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

49
Assets/YamlDotNet/RepresentationModel/YamlNodeType.cs Normal file
View File

@@ -0,0 +1,49 @@
// 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.
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Specifies the type of node in the representation model.
/// </summary>
public enum YamlNodeType
{
/// <summary>
/// The node is a <see cref="YamlAliasNode"/>.
/// </summary>
Alias,
/// <summary>
/// The node is a <see cref="YamlMappingNode"/>.
/// </summary>
Mapping,
/// <summary>
/// The node is a <see cref="YamlScalarNode"/>.
/// </summary>
Scalar,
/// <summary>
/// The node is a <see cref="YamlSequenceNode"/>.
/// </summary>
Sequence
}
}

11
Assets/YamlDotNet/RepresentationModel/YamlNodeType.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 6fedd304363f0ee4a9d32ea69940e2c9
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

180
Assets/YamlDotNet/RepresentationModel/YamlScalarNode.cs Normal file
View File

@@ -0,0 +1,180 @@
// 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.Generic;
using System.Diagnostics;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Serialization;
using static YamlDotNet.Core.HashCode;
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Represents a scalar node in the YAML document.
/// </summary>
[DebuggerDisplay("{Value}")]
public sealed class YamlScalarNode : YamlNode, IYamlConvertible
{
/// <summary>
/// Gets or sets the value of the node.
/// </summary>
/// <value>The value.</value>
public string? Value { get; set; }
/// <summary>
/// Gets or sets the style of the node.
/// </summary>
/// <value>The style.</value>
public ScalarStyle Style { get; set; }
/// <summary>
/// Initializes a new instance of the <see cref="YamlScalarNode"/> class.
/// </summary>
internal YamlScalarNode(IParser parser, DocumentLoadingState state)
{
Load(parser, state);
}
private void Load(IParser parser, DocumentLoadingState state)
{
var scalar = parser.Consume<Scalar>();
Load(scalar, state);
Value = scalar.Value;
Style = scalar.Style;
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlScalarNode"/> class.
/// </summary>
public YamlScalarNode()
{
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlScalarNode"/> class.
/// </summary>
/// <param name="value">The value.</param>
public YamlScalarNode(string? value)
{
this.Value = value;
}
/// <summary>
/// Resolves the aliases that could not be resolved when the node was created.
/// </summary>
/// <param name="state">The state of the document.</param>
internal override void ResolveAliases(DocumentLoadingState state)
{
throw new NotSupportedException("Resolving an alias on a scalar node does not make sense");
}
/// <summary>
/// Saves the current node to the specified emitter.
/// </summary>
/// <param name="emitter">The emitter where the node is to be saved.</param>
/// <param name="state">The state.</param>
internal override void Emit(IEmitter emitter, EmitterState state)
{
emitter.Emit(new Scalar(Anchor, Tag, Value ?? string.Empty, Style, Tag.IsEmpty, false));
}
/// <summary>
/// Accepts the specified visitor by calling the appropriate Visit method on it.
/// </summary>
/// <param name="visitor">
/// A <see cref="IYamlVisitor"/>.
/// </param>
public override void Accept(IYamlVisitor visitor)
{
visitor.Visit(this);
}
/// <summary />
public override bool Equals(object? obj)
{
return obj is YamlScalarNode other
&& Equals(Tag, other.Tag)
&& Equals(Value, other.Value);
}
/// <summary>
/// Serves as a hash function for a particular type.
/// </summary>
/// <returns>
/// A hash code for the current <see cref="T:System.Object"/>.
/// </returns>
public override int GetHashCode()
{
return CombineHashCodes(Tag, Value);
}
/// <summary>
/// Performs an explicit conversion from <see cref="YamlScalarNode"/> to <see cref="string"/>.
/// </summary>
/// <param name="value">The value.</param>
/// <returns>The result of the conversion.</returns>
public static explicit operator string?(YamlScalarNode value)
{
return value.Value;
}
/// <summary>
/// Returns a <see cref="string"/> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="string"/> that represents this instance.
/// </returns>
internal override string ToString(RecursionLevel level)
{
return Value ?? string.Empty;
}
/// <summary>
/// Recursively enumerates all the nodes from the document, starting on the current node,
/// and throwing <see cref="MaximumRecursionLevelReachedException"/>
/// if <see cref="RecursionLevel.Maximum"/> is reached.
/// </summary>
internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
{
yield return this;
}
/// <summary>
/// Gets the type of node.
/// </summary>
public override YamlNodeType NodeType
{
get { return YamlNodeType.Scalar; }
}
void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
{
Load(parser, new DocumentLoadingState());
}
void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
{
Emit(emitter, new EmitterState());
}
}
}

12
Assets/YamlDotNet/RepresentationModel/YamlScalarNode.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: d8152305d4536da4c91eb19aa04b401c
timeCreated: 1427145266
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

301
Assets/YamlDotNet/RepresentationModel/YamlSequenceNode.cs Normal file
View File

@@ -0,0 +1,301 @@
// 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.Generic;
using System.Diagnostics;
using System.Text;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Serialization;
using static YamlDotNet.Core.HashCode;
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Represents a sequence node in the YAML document.
/// </summary>
[DebuggerDisplay("Count = {children.Count}")]
public sealed class YamlSequenceNode : YamlNode, IEnumerable<YamlNode>, IYamlConvertible
{
private readonly IList<YamlNode> children = new List<YamlNode>();
/// <summary>
/// Gets the collection of child nodes.
/// </summary>
/// <value>The children.</value>
public IList<YamlNode> Children
{
get
{
return children;
}
}
/// <summary>
/// Gets or sets the style of the node.
/// </summary>
/// <value>The style.</value>
public SequenceStyle Style { get; set; }
/// <summary>
/// Initializes a new instance of the <see cref="YamlSequenceNode"/> class.
/// </summary>
internal YamlSequenceNode(IParser parser, DocumentLoadingState state)
{
Load(parser, state);
}
private void Load(IParser parser, DocumentLoadingState state)
{
var sequence = parser.Consume<SequenceStart>();
Load(sequence, state);
Style = sequence.Style;
var hasUnresolvedAliases = false;
while (!parser.TryConsume<SequenceEnd>(out var _))
{
var child = ParseNode(parser, state);
children.Add(child);
hasUnresolvedAliases |= child is YamlAliasNode;
}
if (hasUnresolvedAliases)
{
state.AddNodeWithUnresolvedAliases(this);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlSequenceNode"/> class.
/// </summary>
public YamlSequenceNode()
{
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlSequenceNode"/> class.
/// </summary>
public YamlSequenceNode(params YamlNode[] children)
: this((IEnumerable<YamlNode>)children)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlSequenceNode"/> class.
/// </summary>
public YamlSequenceNode(IEnumerable<YamlNode> children)
{
foreach (var child in children)
{
this.children.Add(child);
}
}
/// <summary>
/// Adds the specified child to the <see cref="Children"/> collection.
/// </summary>
/// <param name="child">The child.</param>
public void Add(YamlNode child)
{
children.Add(child);
}
/// <summary>
/// Adds a scalar node to the <see cref="Children"/> collection.
/// </summary>
/// <param name="child">The child.</param>
public void Add(string child)
{
children.Add(new YamlScalarNode(child));
}
/// <summary>
/// Resolves the aliases that could not be resolved when the node was created.
/// </summary>
/// <param name="state">The state of the document.</param>
internal override void ResolveAliases(DocumentLoadingState state)
{
for (var i = 0; i < children.Count; ++i)
{
if (children[i] is YamlAliasNode)
{
children[i] = state.GetNode(children[i].Anchor!, children[i].Start, children[i].End);
}
}
}
/// <summary>
/// Saves the current node to the specified emitter.
/// </summary>
/// <param name="emitter">The emitter where the node is to be saved.</param>
/// <param name="state">The state.</param>
internal override void Emit(IEmitter emitter, EmitterState state)
{
emitter.Emit(new SequenceStart(Anchor, Tag, Tag.IsEmpty, Style));
foreach (var node in children)
{
node.Save(emitter, state);
}
emitter.Emit(new SequenceEnd());
}
/// <summary>
/// Accepts the specified visitor by calling the appropriate Visit method on it.
/// </summary>
/// <param name="visitor">
/// A <see cref="IYamlVisitor"/>.
/// </param>
public override void Accept(IYamlVisitor visitor)
{
visitor.Visit(this);
}
/// <summary />
public override bool Equals(object? obj)
{
var other = obj as YamlSequenceNode;
var areEqual = other != null
&& Equals(Tag, other.Tag)
&& children.Count == other.children.Count;
if (!areEqual)
{
return false;
}
for (var i = 0; i < children.Count; ++i)
{
if (!Equals(children[i], other!.children[i]))
{
return false;
}
}
return true;
}
/// <summary>
/// Serves as a hash function for a particular type.
/// </summary>
/// <returns>
/// A hash code for the current <see cref="T:System.Object"/>.
/// </returns>
public override int GetHashCode()
{
var hashCode = 0;
foreach (var item in children)
{
hashCode = CombineHashCodes(hashCode, item);
}
hashCode = CombineHashCodes(hashCode, Tag);
return hashCode;
}
/// <summary>
/// Recursively enumerates all the nodes from the document, starting on the current node,
/// and throwing <see cref="MaximumRecursionLevelReachedException"/>
/// if <see cref="RecursionLevel.Maximum"/> is reached.
/// </summary>
internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
{
level.Increment();
yield return this;
foreach (var child in children)
{
foreach (var node in child.SafeAllNodes(level))
{
yield return node;
}
}
level.Decrement();
}
/// <summary>
/// Gets the type of node.
/// </summary>
public override YamlNodeType NodeType
{
get { return YamlNodeType.Sequence; }
}
/// <summary>
/// Returns a <see cref="string"/> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="string"/> that represents this instance.
/// </returns>
internal override string ToString(RecursionLevel level)
{
if (!level.TryIncrement())
{
return MaximumRecursionLevelReachedToStringValue;
}
var text = new StringBuilder("[ ");
foreach (var child in children)
{
if (text.Length > 2)
{
text.Append(", ");
}
text.Append(child.ToString(level));
}
text.Append(" ]");
level.Decrement();
return text.ToString();
}
#region IEnumerable<YamlNode> Members
/// <summary />
public IEnumerator<YamlNode> GetEnumerator()
{
return Children.GetEnumerator();
}
#endregion
#region IEnumerable Members
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
#endregion
void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
{
Load(parser, new DocumentLoadingState());
}
void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
{
Emit(emitter, new EmitterState());
}
}
}

12
Assets/YamlDotNet/RepresentationModel/YamlSequenceNode.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 58e9eea9b495b2f478b639f1d20a8951
timeCreated: 1427145264
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

172
Assets/YamlDotNet/RepresentationModel/YamlStream.cs Normal file
View File

@@ -0,0 +1,172 @@
// 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.Collections.Generic;
using System.IO;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Represents an YAML stream.
/// </summary>
public class YamlStream : IEnumerable<YamlDocument>
{
private readonly IList<YamlDocument> documents = new List<YamlDocument>();
/// <summary>
/// Gets the documents inside the stream.
/// </summary>
/// <value>The documents.</value>
public IList<YamlDocument> Documents
{
get
{
return documents;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlStream"/> class.
/// </summary>
public YamlStream()
{
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlStream"/> class.
/// </summary>
public YamlStream(params YamlDocument[] documents)
: this((IEnumerable<YamlDocument>)documents)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlStream"/> class.
/// </summary>
public YamlStream(IEnumerable<YamlDocument> documents)
{
foreach (var document in documents)
{
this.documents.Add(document);
}
}
/// <summary>
/// Adds the specified document to the <see cref="Documents"/> collection.
/// </summary>
/// <param name="document">The document.</param>
public void Add(YamlDocument document)
{
documents.Add(document);
}
/// <summary>
/// Loads the stream from the specified input.
/// </summary>
/// <param name="input">The input.</param>
public void Load(TextReader input)
{
Load(new Parser(input));
}
/// <summary>
/// Loads the stream from the specified <see cref="IParser"/>.
/// </summary>
public void Load(IParser parser)
{
documents.Clear();
parser.Consume<StreamStart>();
while (!parser.TryConsume<StreamEnd>(out var _))
{
var document = new YamlDocument(parser);
documents.Add(document);
}
}
/// <summary>
/// Saves the stream to the specified output.
/// </summary>
/// <param name="output">The output.</param>
public void Save(TextWriter output)
{
Save(output, true);
}
/// <summary>
/// Saves the stream to the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="assignAnchors">Indicates whether or not to assign node anchors.</param>
public void Save(TextWriter output, bool assignAnchors)
{
Save(new Emitter(output), assignAnchors);
}
/// <summary>
/// Saves the stream to the specified emitter.
/// </summary>
/// <param name="emitter">The emitter.</param>
/// <param name="assignAnchors">Indicates whether or not to assign node anchors.</param>
public void Save(IEmitter emitter, bool assignAnchors)
{
emitter.Emit(new StreamStart());
foreach (var document in documents)
{
document.Save(emitter, assignAnchors);
}
emitter.Emit(new StreamEnd());
}
/// <summary>
/// Accepts the specified visitor by calling the appropriate Visit method on it.
/// </summary>
/// <param name="visitor">
/// A <see cref="IYamlVisitor"/>.
/// </param>
public void Accept(IYamlVisitor visitor)
{
visitor.Visit(this);
}
#region IEnumerable<YamlDocument> Members
/// <summary />
public IEnumerator<YamlDocument> GetEnumerator()
{
return documents.GetEnumerator();
}
#endregion
#region IEnumerable Members
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
#endregion
}
}

12
Assets/YamlDotNet/RepresentationModel/YamlStream.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 8da956833fe9bb440be293c2b18b1e29
timeCreated: 1427145265
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

233
Assets/YamlDotNet/RepresentationModel/YamlVisitor.cs Normal file
View File

@@ -0,0 +1,233 @@
// 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;
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Abstract implementation of <see cref="IYamlVisitor"/> that knows how to walk a complete Yaml object model.
/// </summary>
[Obsolete("Use YamlVisitorBase")]
public abstract class YamlVisitor : IYamlVisitor
{
/// <summary>
/// Called when this object is visiting a <see cref="YamlStream"/>.
/// </summary>
/// <param name="stream">
/// The <see cref="YamlStream"/> that is being visited.
/// </param>
protected virtual void Visit(YamlStream stream)
{
// Do nothing.
}
/// <summary>
/// Called after this object finishes visiting a <see cref="YamlStream"/>.
/// </summary>
/// <param name="stream">
/// The <see cref="YamlStream"/> that has been visited.
/// </param>
protected virtual void Visited(YamlStream stream)
{
// Do nothing.
}
/// <summary>
/// Called when this object is visiting a <see cref="YamlDocument"/>.
/// </summary>
/// <param name="document">
/// The <see cref="YamlDocument"/> that is being visited.
/// </param>
protected virtual void Visit(YamlDocument document)
{
// Do nothing.
}
/// <summary>
/// Called after this object finishes visiting a <see cref="YamlDocument"/>.
/// </summary>
/// <param name="document">
/// The <see cref="YamlDocument"/> that has been visited.
/// </param>
protected virtual void Visited(YamlDocument document)
{
// Do nothing.
}
/// <summary>
/// Called when this object is visiting a <see cref="YamlScalarNode"/>.
/// </summary>
/// <param name="scalar">
/// The <see cref="YamlScalarNode"/> that is being visited.
/// </param>
protected virtual void Visit(YamlScalarNode scalar)
{
// Do nothing.
}
/// <summary>
/// Called after this object finishes visiting a <see cref="YamlScalarNode"/>.
/// </summary>
/// <param name="scalar">
/// The <see cref="YamlScalarNode"/> that has been visited.
/// </param>
protected virtual void Visited(YamlScalarNode scalar)
{
// Do nothing.
}
/// <summary>
/// Called when this object is visiting a <see cref="YamlSequenceNode"/>.
/// </summary>
/// <param name="sequence">
/// The <see cref="YamlSequenceNode"/> that is being visited.
/// </param>
protected virtual void Visit(YamlSequenceNode sequence)
{
// Do nothing.
}
/// <summary>
/// Called after this object finishes visiting a <see cref="YamlSequenceNode"/>.
/// </summary>
/// <param name="sequence">
/// The <see cref="YamlSequenceNode"/> that has been visited.
/// </param>
protected virtual void Visited(YamlSequenceNode sequence)
{
// Do nothing.
}
/// <summary>
/// Called when this object is visiting a <see cref="YamlMappingNode"/>.
/// </summary>
/// <param name="mapping">
/// The <see cref="YamlMappingNode"/> that is being visited.
/// </param>
protected virtual void Visit(YamlMappingNode mapping)
{
// Do nothing.
}
/// <summary>
/// Called after this object finishes visiting a <see cref="YamlMappingNode"/>.
/// </summary>
/// <param name="mapping">
/// The <see cref="YamlMappingNode"/> that has been visited.
/// </param>
protected virtual void Visited(YamlMappingNode mapping)
{
// Do nothing.
}
/// <summary>
/// Visits every child of a <see cref="YamlStream"/>.
/// </summary>
/// <param name="stream">
/// The <see cref="YamlStream"/> that is being visited.
/// </param>
protected virtual void VisitChildren(YamlStream stream)
{
foreach (var document in stream.Documents)
{
document.Accept(this);
}
}
/// <summary>
/// Visits every child of a <see cref="YamlDocument"/>.
/// </summary>
/// <param name="document">
/// The <see cref="YamlDocument"/> that is being visited.
/// </param>
protected virtual void VisitChildren(YamlDocument document)
{
if (document.RootNode != null)
{
document.RootNode.Accept(this);
}
}
/// <summary>
/// Visits every child of a <see cref="YamlSequenceNode"/>.
/// </summary>
/// <param name="sequence">
/// The <see cref="YamlSequenceNode"/> that is being visited.
/// </param>
protected virtual void VisitChildren(YamlSequenceNode sequence)
{
foreach (var node in sequence.Children)
{
node.Accept(this);
}
}
/// <summary>
/// Visits every child of a <see cref="YamlMappingNode"/>.
/// </summary>
/// <param name="mapping">
/// The <see cref="YamlMappingNode"/> that is being visited.
/// </param>
protected virtual void VisitChildren(YamlMappingNode mapping)
{
foreach (var pair in mapping.Children)
{
pair.Key.Accept(this);
pair.Value.Accept(this);
}
}
void IYamlVisitor.Visit(YamlStream stream)
{
Visit(stream);
VisitChildren(stream);
Visited(stream);
}
void IYamlVisitor.Visit(YamlDocument document)
{
Visit(document);
VisitChildren(document);
Visited(document);
}
void IYamlVisitor.Visit(YamlScalarNode scalar)
{
Visit(scalar);
Visited(scalar);
}
void IYamlVisitor.Visit(YamlSequenceNode sequence)
{
Visit(sequence);
VisitChildren(sequence);
Visited(sequence);
}
void IYamlVisitor.Visit(YamlMappingNode mapping)
{
Visit(mapping);
VisitChildren(mapping);
Visited(mapping);
}
}
}

11
Assets/YamlDotNet/RepresentationModel/YamlVisitor.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: f0c6d456c0cd3544f98e1dac39bf17ed
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

151
Assets/YamlDotNet/RepresentationModel/YamlVisitorBase.cs Normal file
View File

@@ -0,0 +1,151 @@
// 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.
namespace YamlDotNet.RepresentationModel
{
/// <summary>
/// Abstract implementation of <see cref="IYamlVisitor"/> that knows how to walk a complete YAML object model.
/// </summary>
public abstract class YamlVisitorBase : IYamlVisitor
{
/// <summary>
/// Called when this object is visiting a <see cref="YamlStream"/>.
/// </summary>
/// <param name="stream">
/// The <see cref="YamlStream"/> that is being visited.
/// </param>
public virtual void Visit(YamlStream stream)
{
VisitChildren(stream);
}
/// <summary>
/// Called when this object is visiting a <see cref="YamlDocument"/>.
/// </summary>
/// <param name="document">
/// The <see cref="YamlDocument"/> that is being visited.
/// </param>
public virtual void Visit(YamlDocument document)
{
VisitChildren(document);
}
/// <summary>
/// Called when this object is visiting a <see cref="YamlScalarNode"/>.
/// </summary>
/// <param name="scalar">
/// The <see cref="YamlScalarNode"/> that is being visited.
/// </param>
public virtual void Visit(YamlScalarNode scalar)
{
// Do nothing.
}
/// <summary>
/// Called when this object is visiting a <see cref="YamlSequenceNode"/>.
/// </summary>
/// <param name="sequence">
/// The <see cref="YamlSequenceNode"/> that is being visited.
/// </param>
public virtual void Visit(YamlSequenceNode sequence)
{
VisitChildren(sequence);
}
/// <summary>
/// Called when this object is visiting a <see cref="YamlMappingNode"/>.
/// </summary>
/// <param name="mapping">
/// The <see cref="YamlMappingNode"/> that is being visited.
/// </param>
public virtual void Visit(YamlMappingNode mapping)
{
VisitChildren(mapping);
}
/// <summary>
/// Called when this object is visiting a key-value pair.
/// </summary>
/// <param name="key">The left (key) <see cref="YamlNode"/> that is being visited.</param>
/// <param name="value">The right (value) <see cref="YamlNode"/> that is being visited.</param>
protected virtual void VisitPair(YamlNode key, YamlNode value)
{
key.Accept(this);
value.Accept(this);
}
/// <summary>
/// Visits every child of a <see cref="YamlStream"/>.
/// </summary>
/// <param name="stream">
/// The <see cref="YamlStream"/> that is being visited.
/// </param>
protected virtual void VisitChildren(YamlStream stream)
{
foreach (var document in stream.Documents)
{
document.Accept(this);
}
}
/// <summary>
/// Visits every child of a <see cref="YamlDocument"/>.
/// </summary>
/// <param name="document">
/// The <see cref="YamlDocument"/> that is being visited.
/// </param>
protected virtual void VisitChildren(YamlDocument document)
{
if (document.RootNode != null)
{
document.RootNode.Accept(this);
}
}
/// <summary>
/// Visits every child of a <see cref="YamlSequenceNode"/>.
/// </summary>
/// <param name="sequence">
/// The <see cref="YamlSequenceNode"/> that is being visited.
/// </param>
protected virtual void VisitChildren(YamlSequenceNode sequence)
{
foreach (var node in sequence.Children)
{
node.Accept(this);
}
}
/// <summary>
/// Visits every child of a <see cref="YamlMappingNode"/>.
/// </summary>
/// <param name="mapping">
/// The <see cref="YamlMappingNode"/> that is being visited.
/// </param>
protected virtual void VisitChildren(YamlMappingNode mapping)
{
foreach (var pair in mapping.Children)
{
VisitPair(pair.Key, pair.Value);
}
}
}
}

11
Assets/YamlDotNet/RepresentationModel/YamlVisitorBase.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 2776bd25d70b784469150ddda10b614e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: