internal static IDictionary <String, Object> ReadMapping(IParser parser, Int32 depth = 1)
{
var mappingStart = parser.Expect <MappingStart>();
if (depth > MaxObjectDepth)
{
throw new SyntaxErrorException(mappingStart.Start, mappingStart.End, $"Max object depth of {MaxObjectDepth} exceeded.");
}
var mapping = new Dictionary <String, Object>();
depth++; // Optimistically increment the depth to avoid addition within the loop.
while (!parser.Accept <MappingEnd>())
{
String key = parser.Expect <Scalar>().Value;
Object value;
if (parser.Accept <Scalar>())
{
value = parser.Expect <Scalar>().Value;
}
else if (parser.Accept <SequenceStart>())
{
value = ReadSequence(parser, depth);
}
else
{
value = ReadMapping(parser, depth);
}
mapping.Add(key, value);
}
parser.Expect <MappingEnd>();
return(mapping);
}
internal static IList <Object> ReadSequence(IParser parser, Int32 depth = 1)
{
var sequenceStart = parser.Expect <SequenceStart>();
if (depth > MaxObjectDepth)
{
throw new SyntaxErrorException(sequenceStart.Start, sequenceStart.End, $"Max object depth of {MaxObjectDepth} exceeded.");
}
var sequence = new List <Object>();
depth++; // Optimistically increment the depth to avoid addition within the loop.
while (!parser.Accept <SequenceEnd>())
{
if (parser.Accept <Scalar>())
{
sequence.Add(parser.Expect <Scalar>());
}
else if (parser.Accept <SequenceStart>())
{
sequence.Add(ReadSequence(parser, depth));
}
else
{
sequence.Add(ReadMapping(parser, depth));
}
}
parser.Expect <SequenceEnd>();
return(sequence);
}
/// <summary>
/// Parses the node represented by the next event in <paramref name="parser" />.
/// </summary>
/// <returns>Returns the node that has been parsed.</returns>
static internal YamlNode ParseNode(IParser parser, DocumentLoadingState state)
{
if (parser.Accept <Scalar>())
{
return(new YamlScalarNode(parser, state));
}
if (parser.Accept <SequenceStart>())
{
return(new YamlSequenceNode(parser, state));
}
if (parser.Accept <MappingStart>())
{
return(new YamlMappingNode(parser, state));
}
if (parser.Accept <AnchorAlias>())
{
var alias = parser.Expect <AnchorAlias>();
return(state.GetNode(alias.Value, false, alias.Start, alias.End) ?? new YamlAliasNode(alias.Value));
}
throw new ArgumentException("The current event is of an unsupported type.", "events");
}
public object ReadYaml(IParser parser, Type type)
{
// Handle empty objects
if (parser.Accept <Scalar>())
{
parser.Allow <Scalar>();
return(null);
}
var result = new PSObject();
if (parser.Accept <MappingStart>())
{
parser.MoveNext();
while (!parser.Accept <MappingEnd>())
{
var property = ReadNoteProperty(parser);
if (property == null)
{
throw new NotImplementedException();
}
result.Properties.Add(property);
}
parser.MoveNext();
}
return(result);
}
public object Deserialize(IParser parser, Type type)
{
if (parser == null)
{
throw new ArgumentNullException("reader");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
bool flag = parser.Allow <StreamStart>() != null;
bool flag2 = parser.Allow <DocumentStart>() != null;
object result = null;
if (!parser.Accept <DocumentEnd>() && !parser.Accept <StreamEnd>())
{
using (SerializerState serializerState = new SerializerState())
{
result = valueDeserializer.DeserializeValue(parser, type, serializerState, valueDeserializer);
serializerState.OnDeserialization();
}
}
if (flag2)
{
parser.Expect <DocumentEnd>();
}
if (flag)
{
parser.Expect <StreamEnd>();
}
return(result);
}
public object ReadYaml(IParser parser, Type type)
{
var result = new FieldMap();
if (parser.Accept <MappingStart>())
{
parser.MoveNext();
while (!parser.Accept <MappingEnd>())
{
var fieldName = parser.Allow <Scalar>().Value;
if (parser.Accept <SequenceStart>())
{
parser.MoveNext();
var fields = new List <string>();
while (!parser.Accept <SequenceEnd>())
{
fields.Add(parser.Allow <Scalar>().Value);
}
result.Set(fieldName, fields.ToArray());
parser.MoveNext();
}
}
parser.MoveNext();
}
return(result);
}
public object ReadYaml(IParser parser, Type type)
{
if (parser.TryConsume <Scalar>(out var nameValueScalar))
{
var runtimeName = DeserializeName(nameValueScalar, type);
return(new ProjectRuntime(runtimeName));
}
if (!parser.TryConsume <MappingStart>(out _))
{
throw new YamlException($"Unable to deserialize [{type.FullName}]. Expecting string or object.");
}
if (!parser.TryConsume <Scalar>(out var namePropertyScalar) ||
!string.Equals(nameof(ProjectRuntime.Name), namePropertyScalar.Value, StringComparison.OrdinalIgnoreCase))
{
throw new YamlException($"Unable to deserialize [{type.FullName}]. Expecting runtime name property.");
}
if (!parser.TryConsume <Scalar>(out var nameValueScalar2))
{
throw new YamlException($"Unable to deserialize [{type.FullName}]. Runtime name property should be a string.");
}
var name = DeserializeName(nameValueScalar2, type);
// early mapping end is ok
if (parser.Accept <MappingEnd>(out _))
{
parser.MoveNext(); // read final MappingEnd since Accept doesn't call MoveNext
return(new ProjectRuntime(name));
}
if (!parser.TryConsume <Scalar>(out var optionsPropertyScalar) ||
!string.Equals(nameof(ProjectRuntime.Options), optionsPropertyScalar.Value, StringComparison.OrdinalIgnoreCase))
{
throw new YamlException($"Unable to deserialize [{type.FullName}]. Expecting runtime options property.");
}
if (!parser.Accept <MappingStart>(out _))
{
throw new YamlException($"Unable to deserialize [{type.FullName}]. Runtime options property should be an object.");
}
var runtimeOptionsObj = this._optionsConverter.ReadYaml(parser, _optionsType);
if (!(runtimeOptionsObj is ProjectRuntimeOptions runtimeOptions))
{
throw new YamlException("There was an issue deserializing the runtime options object.");
}
parser.MoveNext(); // read final MappingEnd event
return(new ProjectRuntime(name)
{
Options = runtimeOptions
});
public object ReadYaml(IParser parser, Type type)
{
var allowedFailuresCollection = new AllowedFailuresCollection();
// discard SequenceStart
parser.Expect <SequenceStart>();
do
{
string os = null;
string configuration = null;
string platform = null;
string testCategory = null;
var variables = new List <Variable>();
parser.Expect <MappingStart>();
do
{
var possibleVar = _deserializer.Deserialize <InternalVariable>(parser);
switch (possibleVar.Name)
{
case "os":
os = possibleVar.Value;
break;
case "configuration":
configuration = possibleVar.Value;
break;
case "platform":
platform = possibleVar.Value;
break;
case "test_category":
testCategory = possibleVar.Value;
break;
default:
variables.Add(possibleVar.ToVariable());
break;
}
} while (!parser.Accept <MappingEnd>());
parser.Expect <MappingEnd>();
allowedFailuresCollection.Add(
new AllowedJobFailureConditions(os, configuration, platform, testCategory, variables.AsReadOnly()));
} while (!parser.Accept <SequenceEnd>());
parser.Expect <SequenceEnd>();
return(allowedFailuresCollection);
}
public object ReadYaml(IParser parser, Type type)
{
var env = new InternalEnvironmentVariables();
parser.Expect <MappingStart>();
do
{
var scalar = parser.Peek <Scalar>();
if (scalar != null)
{
if (scalar.Value == "matrix")
{
// discard "matrix" value itself
parser.Expect <Scalar>();
// discard SequenceStart
parser.Expect <SequenceStart>();
do
{
var matrixItemVariables = new List <InternalVariable>();
parser.Expect <MappingStart>();
do
{
matrixItemVariables.Add(deserializer.Deserialize <InternalVariable>(parser));
} while (!parser.Accept <MappingEnd>());
parser.Expect <MappingEnd>();
env.InternalMatrix.Add(matrixItemVariables.AsReadOnly());
} while (!parser.Accept <SequenceEnd>());
parser.Expect <SequenceEnd>();
}
else
{
var variable = deserializer.Deserialize <InternalVariable>(parser);
env.InternalCommonVariables.Add(variable);
}
}
} while (!parser.Accept <MappingEnd>());
parser.Expect <MappingEnd>();
return(env);
}
internal static void DeserializeHelper(Type tItem, IParser parser, Func <IParser, Type, object> nestedObjectDeserializer, IList result, bool canUpdate)
{
parser.Expect <SequenceStart>();
while (!parser.Accept <SequenceEnd>())
{
ParsingEvent current = parser.Current;
object obj = nestedObjectDeserializer(parser, tItem);
IValuePromise valuePromise = obj as IValuePromise;
if (valuePromise == null)
{
result.Add(TypeConverter.ChangeType(obj, tItem));
}
else
{
if (!canUpdate)
{
throw new ForwardAnchorNotSupportedException(current.Start, current.End, "Forward alias references are not allowed because this type does not implement IList<>");
}
int index = result.Add((!tItem.IsValueType()) ? null : Activator.CreateInstance(tItem));
valuePromise.ValueAvailable += delegate(object v)
{
result[index] = TypeConverter.ChangeType(v, tItem);
};
}
}
parser.Expect <SequenceEnd>();
}
public object ReadYaml(IParser parser, Type type)
{
var result = new FieldMap();
if (parser.TryConsume <MappingStart>(out _))
{
while (parser.TryConsume(out Scalar scalar))
{
var fieldName = scalar.Value;
if (parser.TryConsume <SequenceStart>(out _))
{
var fields = new List <string>();
while (!parser.Accept <SequenceEnd>(out _))
{
if (parser.TryConsume <Scalar>(out scalar))
{
fields.Add(scalar.Value);
}
}
result.Set(fieldName, fields.ToArray());
parser.Require <SequenceEnd>();
parser.MoveNext();
}
}
parser.Require <MappingEnd>();
parser.MoveNext();
}
return(result);
}
private void Load(IParser parser, DocumentLoadingState state)
{
MappingStart mappingStart = parser.Expect <MappingStart>();
Load(mappingStart, state);
Style = mappingStart.Style;
bool flag = false;
while (!parser.Accept <MappingEnd>())
{
YamlNode yamlNode = YamlNode.ParseNode(parser, state);
YamlNode yamlNode2 = YamlNode.ParseNode(parser, state);
try
{
children.Add(yamlNode, yamlNode2);
}
catch (ArgumentException innerException)
{
throw new YamlException(yamlNode.Start, yamlNode.End, "Duplicate key", innerException);
}
flag |= (yamlNode is YamlAliasNode || yamlNode2 is YamlAliasNode);
}
if (flag)
{
state.AddNodeWithUnresolvedAliases(this);
}
parser.Expect <MappingEnd>();
}
private void Load(IParser parser, DocumentLoadingState state)
{
var sequence = parser.Expect <SequenceStart>();
Load(sequence, state);
Style = sequence.Style;
bool hasUnresolvedAliases = false;
while (!parser.Accept <SequenceEnd>())
{
var child = ParseNode(parser, state);
children.Add(child);
hasUnresolvedAliases |= child is YamlAliasNode;
}
if (hasUnresolvedAliases)
{
state.AddNodeWithUnresolvedAliases(this);
}
#if DEBUG
else
{
foreach (var child in children)
{
if (child is YamlAliasNode)
{
throw new InvalidOperationException("Error in alias resolution.");
}
}
}
#endif
parser.Expect <SequenceEnd>();
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlDocument"/> class.
/// </summary>
internal YamlDocument(IParser parser)
{
var state = new DocumentLoadingState();
parser.Expect <DocumentStart>();
while (!parser.Accept <DocumentEnd>())
{
Debug.Assert(RootNode == null);
RootNode = YamlNode.ParseNode(parser, state);
if (RootNode is YamlAliasNode)
{
throw new YamlException();
}
}
state.ResolveAliases();
#if DEBUG
foreach (var node in AllNodes)
{
if (node is YamlAliasNode)
{
throw new InvalidOperationException("Error in alias resolution.");
}
}
#endif
parser.Expect <DocumentEnd>();
}
bool INodeDeserializer.Deserialize(IParser reader, Type expectedType, Func <IParser, Type, object> nestedObjectDeserializer, out object value)
{
var mapping = reader.Allow <MappingStart>();
if (mapping == null)
{
value = null;
return(false);
}
value = _objectFactory.Create(expectedType);
while (!reader.Accept <MappingEnd>())
{
var propertyName = reader.Expect <Scalar>();
var property = _typeDescriptor.GetProperty(expectedType, value, propertyName.Value, _ignoreUnmatched);
if (property == null)
{
reader.SkipThisAndNestedEvents();
continue;
}
var propertyValue = nestedObjectDeserializer(reader, property.Type);
if (!(propertyValue is IValuePromise propertyValuePromise))
{
var convertedValue = TypeConverter.ChangeType(propertyValue, property.Type);
property.Write(value, convertedValue);
}
public static void DeserializeHelper <TItem>(IParser reader, Type expectedType, Func <IParser, Type, object> nestedObjectDeserializer, ICollection <TItem> result)
{
var list = result as IList <TItem>;
reader.Expect <SequenceStart>();
while (!reader.Accept <SequenceEnd>())
{
var current = reader.Current;
var value = nestedObjectDeserializer(reader, typeof(TItem));
var promise = value as IValuePromise;
if (promise == null)
{
result.Add(TypeConverter.ChangeType <TItem>(value));
}
else if (list != null)
{
var index = list.Count;
result.Add(default(TItem));
promise.ValueAvailable += v => list[index] = TypeConverter.ChangeType <TItem>(v);
}
else
{
throw new ForwardAnchorNotSupportedException(
current.Start,
current.End,
"Forward alias references are not allowed because this type does not implement IList<>"
);
}
}
reader.Expect <SequenceEnd>();
}
private void Load(IParser parser, DocumentLoadingState state)
{
var mapping = parser.Expect <MappingStart>();
Load(mapping, state);
Style = mapping.Style;
bool hasUnresolvedAliases = false;
while (!parser.Accept <MappingEnd>())
{
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);
}
parser.Expect <MappingEnd>();
}
internal static void DeserializeHelper(Type tItem, IParser parser, Func <IParser, Type, object> nestedObjectDeserializer, IList result, bool canUpdate)
{
parser.Expect <SequenceStart>();
while (!parser.Accept <SequenceEnd>())
{
var current = parser.Current;
var value = nestedObjectDeserializer(parser, tItem);
var promise = value as IValuePromise;
if (promise == null)
{
result.Add(TypeConverter.ChangeType(value, tItem));
}
else if (canUpdate)
{
var index = result.Add(tItem.IsValueType() ? Activator.CreateInstance(tItem) : null);
promise.ValueAvailable += v => result[index] = TypeConverter.ChangeType(v, tItem);
}
else
{
throw new ForwardAnchorNotSupportedException(
current.Start,
current.End,
"Forward alias references are not allowed because this type does not implement IList<>"
);
}
}
parser.Expect <SequenceEnd>();
}
/// <summary>
/// Gets the next event without consuming it.
/// </summary>
/// <typeparam name="T">Type of the <see cref="ParsingEvent"/>.</typeparam>
/// <returns>Returns the current event if it is of type T; otherwise returns null.</returns>
public static T Peek <T>(this IParser parser) where T : ParsingEvent
{
if (!parser.Accept <T>())
{
return(null);
}
return((T)parser.Current);
}
internal static IList <ProcessResource> ReadProcessResources(IParser parser)
{
var result = new List <ProcessResource>();
parser.Expect <SequenceStart>();
while (parser.Allow <SequenceEnd>() == null)
{
parser.Expect <MappingStart>();
Scalar scalar = parser.Expect <Scalar>();
switch (scalar.Value ?? String.Empty)
{
case YamlConstants.Endpoint:
case YamlConstants.Repo:
break;
default:
throw new SyntaxErrorException(scalar.Start, scalar.End, $"Unexpected resource type: '{scalar.Value}'");
}
var resource = new ProcessResource {
Type = scalar.Value
};
resource.Name = ReadNonEmptyString(parser);;
while (parser.Allow <MappingEnd>() == null)
{
string dataKey = ReadNonEmptyString(parser);
if (parser.Accept <MappingStart>())
{
resource.Data[dataKey] = ReadMapping(parser);
}
else if (parser.Accept <SequenceStart>())
{
resource.Data[dataKey] = ReadSequence(parser);
}
else
{
resource.Data[dataKey] = parser.Expect <Scalar>().Value ?? String.Empty;
}
}
result.Add(resource);
}
return(result);
}
private IResource MapResource(IParser reader, Func <IParser, Type, object> nestedObjectDeserializer, CommentMetadata comment)
{
IResource result = null;
string kind = null;
ResourceMetadata metadata = null;
if (reader.Accept <MappingStart>())
{
reader.MoveNext();
while (!reader.Accept <MappingEnd>())
{
// Read kind
var propertyName = reader.Allow <Scalar>().Value;
if (propertyName == "kind")
{
kind = reader.Allow <Scalar>().Value;
}
else if (propertyName == "metadata")
{
if (!TryMetadata(reader, nestedObjectDeserializer, out metadata))
{
reader.SkipThisAndNestedEvents();
}
}
else if (propertyName == "spec" && kind != null)
{
if (!TryResource(kind, reader, nestedObjectDeserializer, metadata, comment, out IResource resource))
{
reader.SkipThisAndNestedEvents();
}
result = resource;
}
else
{
reader.SkipThisAndNestedEvents();
}
}
reader.MoveNext();
}
return(result);
}
/// <summary>
/// Loads the stream from the specified <see cref="IParser"/>.
/// </summary>
public void Load(IParser parser)
{
documents.Clear();
parser.Expect <StreamStart>();
while (!parser.Accept <StreamEnd>())
{
var document = new YamlDocument(parser);
documents.Add(document);
}
parser.Expect <StreamEnd>();
}
/// <summary>
/// Checks whether the current event is of the specified type.
/// If the event is of the specified type, returns it and moves to the next event.
/// Otherwise retruns null.
/// </summary>
/// <typeparam name="T">Type of the <see cref="ParsingEvent"/>.</typeparam>
/// <returns>Returns the current event if it is of type T; otherwise returns null.</returns>
public static T Allow <T>(this IParser parser) where T : ParsingEvent
{
if (!parser.Accept <T>())
{
return(null);
}
var @event = (T)parser.Current;
parser.MoveNext();
return(@event);
}
private PSNoteProperty ReadNoteProperty(IParser parser)
{
var name = parser.Allow <Scalar>().Value;
if (parser.Accept <SequenceStart>())
{
parser.MoveNext();
var values = new List <PSObject>();
while (!parser.Accept <SequenceEnd>())
{
if (parser.Accept <MappingStart>())
{
values.Add(PSObject.AsPSObject(ReadYaml(parser, typeof(PSObject))));
}
else if (parser.Accept <Scalar>())
{
values.Add(PSObject.AsPSObject(parser.Allow <Scalar>().Value));
}
}
parser.MoveNext();
return(new PSNoteProperty(name, values.ToArray()));
}
else if (parser.Accept <MappingStart>())
{
return(new PSNoteProperty(name, ReadYaml(parser, typeof(PSObject))));
}
else if (parser.Accept <Scalar>())
{
return(new PSNoteProperty(name, parser.Allow <Scalar>().Value));
}
return(null);
}
/// <summary>
/// Deserializes an object of the specified type.
/// </summary>
/// <param name="parser">The <see cref="IParser" /> where to deserialize the object.</param>
/// <param name="type">The static type of the object to deserialize.</param>
/// <returns>Returns the deserialized object.</returns>
public object Deserialize(IParser parser, Type type, IValueDeserializer deserializer = null)
{
if (parser == null)
{
throw new ArgumentNullException("reader");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
var hasStreamStart = parser.Allow <StreamStart>() != null;
var hasDocumentStart = parser.Allow <DocumentStart>() != null;
deserializer = deserializer ?? _valueDeserializer;
object result = null;
if (!parser.Accept <DocumentEnd>() && !parser.Accept <StreamEnd>())
{
using (var state = new SerializerState())
{
result = deserializer.DeserializeValue(parser, type, state, deserializer);
state.OnDeserialization();
}
}
if (hasDocumentStart)
{
parser.Expect <DocumentEnd>();
}
if (hasStreamStart)
{
parser.Expect <StreamEnd>();
}
return(result);
}
/// <summary>
/// 查找一个能解析buf中内容的parser
/// </summary>
/// <param name="supportedFamily">The supported family.</param>
/// <param name="buf">The buf.</param>
/// <returns></returns>
private IParser FindParser(ProtocolFamily supportedFamily, ByteBuffer buf)
{
IParser parser = parsers[supportedFamily];
if (parser != null)
{
if (parser.Accept(buf))
{
return(parser);
}
}
return(null);
}
/// <summary>
/// Reads a mapping(string, string) from start to end using the specified <c>StringComparer</c>.
/// </summary>
/// <param name="parser">The parser instance from which to read</param>
/// <returns>A dictionary instance with the specified comparer</returns>
internal static IDictionary <String, String> ReadMappingOfStringString(IParser parser, StringComparer comparer)
{
parser.Expect <MappingStart>();
var mappingValue = new Dictionary <String, String>(comparer);
while (!parser.Accept <MappingEnd>())
{
mappingValue.Add(parser.Expect <Scalar>().Value, parser.Expect <Scalar>().Value);
}
parser.Expect <MappingEnd>();
return(mappingValue);
}
public object ReadYaml(IParser parser, Type type)
{
if (parser.Accept <Scalar>())
{
var scalar = parser.Expect <Scalar>();
return(new EntityMemberInfo {
Type = scalar.Value
});
}
else
{
return(_deserializerFactory().Deserialize <EntityMemberInfo>(parser));
}
}
public static void DeserializeHelper <TItem>(IParser reader, Type expectedType, Func <IParser, Type, object> nestedObjectDeserializer, ICollection <TItem> result)
{
var list = result as IList <TItem>;
reader.Expect <SequenceStart>();
while (!reader.Accept <SequenceEnd>())
{
var current = reader.Current;
var value = nestedObjectDeserializer(reader, typeof(TItem));
if (!(value is IValuePromise promise))
{
result.Add(TypeConverter.ChangeType <TItem>(value));
}
private void Load(IParser parser, DocumentLoadingState state)
{
var mapping = parser.Expect <MappingStart>();
Load(mapping, state);
Style = mapping.Style;
bool hasUnresolvedAliases = false;
while (!parser.Accept <MappingEnd>())
{
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);
}
#if DEBUG
else
{
foreach (var child in children)
{
if (child.Key is YamlAliasNode)
{
throw new InvalidOperationException("Error in alias resolution.");
}
if (child.Value is YamlAliasNode)
{
throw new InvalidOperationException("Error in alias resolution.");
}
}
}
#endif
parser.Expect <MappingEnd>();
}
bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
{
var mapping = parser.Allow<MappingStart>();
if (mapping == null)
{
value = null;
return false;
}
value = _objectFactory.Create(expectedType);
while (!parser.Accept<MappingEnd>())
{
var propertyName = parser.Expect<Scalar>();
var property = _typeDescriptor.GetProperty(expectedType, null, propertyName.Value, _ignoreUnmatched);
if (property == null)
{
parser.SkipThisAndNestedEvents();
continue;
}
var propertyValue = nestedObjectDeserializer(parser, property.Type);
var propertyValuePromise = propertyValue as IValuePromise;
if (propertyValuePromise == null)
{
var convertedValue = TypeConverter.ChangeType(propertyValue, property.Type);
property.Write(value, convertedValue);
}
else
{
var valueRef = value;
propertyValuePromise.ValueAvailable += v =>
{
var convertedValue = TypeConverter.ChangeType(v, property.Type);
property.Write(valueRef, convertedValue);
};
}
}
parser.Expect<MappingEnd>();
return true;
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlDocument"/> class.
/// </summary>
internal YamlDocument(IParser parser)
{
var state = new DocumentLoadingState();
parser.Expect<DocumentStart>();
while (!parser.Accept<DocumentEnd>())
{
Debug.Assert(RootNode == null);
RootNode = YamlNode.ParseNode(parser, state);
if (RootNode is YamlAliasNode)
{
throw new YamlException();
}
}
state.ResolveAliases();
parser.Expect<DocumentEnd>();
}
private static void DeserializeHelper(Type tKey, Type tValue, IParser parser, Func<IParser, Type, object> nestedObjectDeserializer, IDictionary result)
{
parser.Expect<MappingStart>();
while (!parser.Accept<MappingEnd>())
{
var key = nestedObjectDeserializer(parser, tKey);
var keyPromise = key as IValuePromise;
var value = nestedObjectDeserializer(parser, tValue);
var valuePromise = value as IValuePromise;
if (keyPromise == null)
{
if (valuePromise == null)
{
// Happy path: both key and value are known
result[key] = value;
}
else
{
// Key is known, value is pending
valuePromise.ValueAvailable += v => result[key] = v;
}
}
else
{
if (valuePromise == null)
{
// Key is pending, value is known
keyPromise.ValueAvailable += v => result[v] = value;
}
else
{
// Both key and value are pending. We need to wait until both of them becom available.
var hasFirstPart = false;
keyPromise.ValueAvailable += v =>
{
if (hasFirstPart)
{
result[v] = value;
}
else
{
key = v;
hasFirstPart = true;
}
};
valuePromise.ValueAvailable += v =>
{
if (hasFirstPart)
{
result[key] = v;
}
else
{
value = v;
hasFirstPart = true;
}
};
}
}
}
parser.Expect<MappingEnd>();
}
/// <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>())
{
return new YamlScalarNode(parser, state);
}
if (parser.Accept<SequenceStart>())
{
return new YamlSequenceNode(parser, state);
}
if (parser.Accept<MappingStart>())
{
return new YamlMappingNode(parser, state);
}
if (parser.Accept<AnchorAlias>())
{
var alias = parser.Expect<AnchorAlias>();
return state.GetNode(alias.Value, false, alias.Start, alias.End) ?? new YamlAliasNode(alias.Value);
}
throw new ArgumentException("The current event is of an unsupported type.", "events");
}
internal static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object> nestedObjectDeserializer, IList result, bool canUpdate)
{
parser.Expect<SequenceStart>();
while (!parser.Accept<SequenceEnd>())
{
var current = parser.Current;
var value = nestedObjectDeserializer(parser, tItem);
var promise = value as IValuePromise;
if (promise == null)
{
result.Add(TypeConverter.ChangeType(value, tItem));
}
else if (canUpdate)
{
var index = result.Add(tItem.IsValueType() ? Activator.CreateInstance(tItem) : null);
promise.ValueAvailable += v => result[index] = TypeConverter.ChangeType(v, tItem);
}
else
{
throw new ForwardAnchorNotSupportedException(
current.Start,
current.End,
"Forward alias references are not allowed because this type does not implement IList<>"
);
}
}
parser.Expect<SequenceEnd>();
}