/// <summary>
/// Initializes a new instance of <see cref="Deserializer" /> using the default configuration.
/// </summary>
/// <remarks>
/// To customize the bahavior of the deserializer, use <see cref="DeserializerBuilder" />.
/// </remarks>
public Deserializer()
// TODO: When the backwards compatibility is dropped, uncomment the following line and remove the body of this constructor.
// : this(new DeserializerBuilder().BuildValueDeserializer())
{
backwardsCompatibleConfiguration = new BackwardsCompatibleConfiguration(null, null, false, null);
valueDeserializer = backwardsCompatibleConfiguration.valueDeserializer;
}
public object DeserializeValue(EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
var nodeEvent = reader.Peek<NodeEvent>();
var nodeType = GetTypeFromEvent(nodeEvent, expectedType);
try
{
foreach (var deserializer in deserializers)
{
object value;
if (deserializer.Deserialize(reader, nodeType, (r, t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out value))
{
return value;
}
}
}
catch (YamlException)
{
throw;
}
catch (Exception ex)
{
throw new YamlException(nodeEvent.Start, nodeEvent.End, "Exception during deserialization", ex);
}
throw new YamlException(
nodeEvent.Start,
nodeEvent.End,
string.Format(
"No node deserializer was able to deserialize the node into type {0}",
expectedType.AssemblyQualifiedName
)
);
}
public Deserializer(
IObjectFactory objectFactory = null,
INamingConvention namingConvention = null,
bool ignoreUnmatched = false,
YamlAttributeOverrides overrides = null)
{
objectFactory = objectFactory ?? new DefaultObjectFactory();
namingConvention = namingConvention ?? new NullNamingConvention();
typeDescriptor.TypeDescriptor =
new CachedTypeInspector(
new YamlAttributesTypeInspector(
new YamlAttributeOverridesInspector(
new NamingConventionTypeInspector(
new ReadableAndWritablePropertiesTypeInspector(
new ReadablePropertiesTypeInspector(
new StaticTypeResolver()
)
),
namingConvention
),
overrides
)
)
);
converters = new List <IYamlTypeConverter>();
foreach (IYamlTypeConverter yamlTypeConverter in YamlTypeConverters.GetBuiltInConverters(false))
{
converters.Add(yamlTypeConverter);
}
NodeDeserializers = new List <INodeDeserializer>();
NodeDeserializers.Add(new YamlConvertibleNodeDeserializer(objectFactory));
NodeDeserializers.Add(new YamlSerializableNodeDeserializer(objectFactory));
NodeDeserializers.Add(new TypeConverterNodeDeserializer(converters));
NodeDeserializers.Add(new NullNodeDeserializer());
NodeDeserializers.Add(new ScalarNodeDeserializer());
NodeDeserializers.Add(new ArrayNodeDeserializer());
NodeDeserializers.Add(new DictionaryNodeDeserializer(objectFactory));
NodeDeserializers.Add(new CollectionNodeDeserializer(objectFactory));
NodeDeserializers.Add(new EnumerableNodeDeserializer());
NodeDeserializers.Add(new ObjectNodeDeserializer(objectFactory, typeDescriptor, ignoreUnmatched));
tagMappings = new Dictionary <string, Type>(predefinedTagMappings);
TypeResolvers = new List <INodeTypeResolver>();
TypeResolvers.Add(new YamlConvertibleTypeResolver());
TypeResolvers.Add(new YamlSerializableTypeResolver());
TypeResolvers.Add(new TagNodeTypeResolver(tagMappings));
TypeResolvers.Add(new TypeNameInTagNodeTypeResolver());
TypeResolvers.Add(new DefaultContainersNodeTypeResolver());
valueDeserializer =
new AliasValueDeserializer(
new NodeValueDeserializer(
NodeDeserializers,
TypeResolvers
)
);
}
public AliasValueDeserializer(IValueDeserializer innerDeserializer)
{
if (innerDeserializer == null)
{
throw new ArgumentNullException("innerDeserializer");
}
this.innerDeserializer = innerDeserializer;
}
private Deserializer(IValueDeserializer valueDeserializer)
{
if (valueDeserializer == null)
{
throw new ArgumentNullException("valueDeserializer");
}
this.valueDeserializer = valueDeserializer;
}
public PlaceholderValueDeserializer(IValueDeserializer innerDeserializer, string replacer)
{
if (innerDeserializer == null)
{
throw new ArgumentNullException(nameof(innerDeserializer));
}
_innerDeserializer = innerDeserializer;
_replacer = replacer;
}
public YamlDeserializer(
IObjectFactory objectFactory = null,
INamingConvention namingConvention = null,
bool ignoreUnmatched = false)
{
objectFactory = objectFactory ?? new DefaultEmitObjectFactory();
namingConvention = namingConvention ?? new NullNamingConvention();
_typeDescriptor.TypeDescriptor =
new CachedTypeInspector(
new YamlAttributesTypeInspector(
new NamingConventionTypeInspector(
new ReadableAndWritablePropertiesTypeInspector(
new EmitTypeInspector(
new StaticTypeResolver()
)
),
namingConvention
)
)
);
_converters = new List <IYamlTypeConverter>();
foreach (IYamlTypeConverter yamlTypeConverter in YamlTypeConverters.BuiltInConverters)
{
_converters.Add(yamlTypeConverter);
}
NodeDeserializers = new List <INodeDeserializer>();
NodeDeserializers.Add(new TypeConverterNodeDeserializer(_converters));
NodeDeserializers.Add(new NullNodeDeserializer());
NodeDeserializers.Add(new ScalarNodeDeserializer());
NodeDeserializers.Add(new EmitArrayNodeDeserializer());
NodeDeserializers.Add(new GenericDictionaryNodeDeserializer(objectFactory));
NodeDeserializers.Add(new NonGenericDictionaryNodeDeserializer(objectFactory));
NodeDeserializers.Add(new EmitGenericCollectionNodeDeserializer(objectFactory));
NodeDeserializers.Add(new NonGenericListNodeDeserializer(objectFactory));
NodeDeserializers.Add(new EnumerableNodeDeserializer());
NodeDeserializers.Add(new ObjectNodeDeserializer(objectFactory, _typeDescriptor, ignoreUnmatched));
_tagMappings = new Dictionary <string, Type>(PredefinedTagMappings);
TypeResolvers = new List <INodeTypeResolver>();
TypeResolvers.Add(new TagNodeTypeResolver(_tagMappings));
TypeResolvers.Add(new TypeNameInTagNodeTypeResolver());
TypeResolvers.Add(new DefaultContainersNodeTypeResolver());
TypeResolvers.Add(new ScalarYamlNodeTypeResolver());
_valueDeserializer =
new AliasValueDeserializer(
new NodeValueDeserializer(
NodeDeserializers,
TypeResolvers
)
);
}
public Deserializer(IObjectFactory objectFactory = null, INamingConvention namingConvention = null)
{
objectFactory = objectFactory ?? new DefaultObjectFactory();
namingConvention = namingConvention ?? new NullNamingConvention();
typeDescriptor.TypeDescriptor =
new YamlAttributesTypeInspector(
new NamingConventionTypeInspector(
new ReadableAndWritablePropertiesTypeInspector(
new ReadablePropertiesTypeInspector(
new StaticTypeResolver()
)
),
namingConvention
)
);
converters = new List <IYamlTypeConverter>();
NodeDeserializers = new List <INodeDeserializer>();
NodeDeserializers.Add(new TypeConverterNodeDeserializer(converters));
NodeDeserializers.Add(new NullNodeDeserializer());
NodeDeserializers.Add(new ScalarNodeDeserializer());
NodeDeserializers.Add(new ArrayNodeDeserializer());
NodeDeserializers.Add(new GenericDictionaryNodeDeserializer(objectFactory));
NodeDeserializers.Add(new NonGenericDictionaryNodeDeserializer(objectFactory));
NodeDeserializers.Add(new GenericCollectionNodeDeserializer(objectFactory));
NodeDeserializers.Add(new NonGenericListNodeDeserializer(objectFactory));
NodeDeserializers.Add(new EnumerableNodeDeserializer());
NodeDeserializers.Add(new ObjectNodeDeserializer(objectFactory, typeDescriptor));
tagMappings = new Dictionary <string, Type>(predefinedTagMappings);
TypeResolvers = new List <INodeTypeResolver>();
TypeResolvers.Add(new TagNodeTypeResolver(tagMappings));
TypeResolvers.Add(new TypeNameInTagNodeTypeResolver());
TypeResolvers.Add(new DefaultContainersNodeTypeResolver());
valueDeserializer =
new AliasValueDeserializer(
new NodeValueDeserializer(
NodeDeserializers,
TypeResolvers
)
);
}
/// <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);
}
public object DeserializeValue (EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
var nodeEvent = reader.Peek<NodeEvent>();
var nodeType = GetTypeFromEvent(nodeEvent, expectedType);
foreach (var deserializer in deserializers)
{
object value;
if (deserializer.Deserialize(reader, nodeType, (r, t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out value))
{
return value;
}
}
throw new SerializationException(
string.Format(
"No node deserializer was able to deserialize the node at {0} into type {1}",
reader.Parser.Current.Start,
expectedType.AssemblyQualifiedName
)
);
}
public T Deserialize <T>(TextReader input, IValueDeserializer deserializer = null)
{
return((T)Deserialize(input, typeof(T), deserializer));
}
/// <summary>
/// AWARENESS: not thread safe
/// </summary>
/// <param name="reader"></param>
/// <param name="expectedType"></param>
/// <param name="state"></param>
/// <param name="nestedObjectDeserializer"></param>
/// <returns></returns>
public object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
object value = _innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
if (value is string str && str.Trim() == Constants.ContentPlaceholder)
{
ContainPlaceholder = true;
return(_replacer);
}
return(value);
}
public object?DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
parser.Accept <NodeEvent>(out var nodeEvent);
var nodeType = GetTypeFromEvent(nodeEvent, expectedType);
try
{
foreach (var deserializer in deserializers)
{
if (deserializer.Deserialize(parser, nodeType, (r, t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out var value))
{
return(TypeConverter.ChangeType(value, expectedType));
}
}
}
catch (YamlException)
{
throw;
}
catch (Exception ex)
{
throw new YamlException(
nodeEvent?.Start ?? Mark.Empty,
nodeEvent?.End ?? Mark.Empty,
"Exception during deserialization",
ex
);
}
throw new YamlException(
nodeEvent?.Start ?? Mark.Empty,
nodeEvent?.End ?? Mark.Empty,
$"No node deserializer was able to deserialize the node into type {expectedType.AssemblyQualifiedName}"
);
}
public object DeserializeValue(EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
var nodeEvent = reader.Peek <NodeEvent>();
var nodeType = GetTypeFromEvent(nodeEvent, expectedType);
try
{
foreach (var deserializer in deserializers)
{
object value;
if (deserializer.Deserialize(reader, nodeType, (r, t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out value))
{
return(value);
}
}
}
catch (YamlException)
{
throw;
}
catch (Exception ex)
{
throw new YamlException(nodeEvent.Start, nodeEvent.End, "Exception during deserialization", ex);
}
throw new YamlException(
nodeEvent.Start,
nodeEvent.End,
string.Format(
"No node deserializer was able to deserialize the node into type {0}",
expectedType.AssemblyQualifiedName
)
);
}
public object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
object value;
var alias = parser.Allow <AnchorAlias>();
if (alias != null)
{
var aliasState = state.Get <AliasState>();
ValuePromise valuePromise;
if (!aliasState.TryGetValue(alias.Value, out valuePromise))
{
valuePromise = new ValuePromise(alias);
aliasState.Add(alias.Value, valuePromise);
}
return(valuePromise.HasValue ? valuePromise.Value : valuePromise);
}
string anchor = null;
var nodeEvent = parser.Peek <NodeEvent>();
if (nodeEvent != null && !string.IsNullOrEmpty(nodeEvent.Anchor))
{
anchor = nodeEvent.Anchor;
}
value = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
if (anchor != null)
{
var aliasState = state.Get <AliasState>();
ValuePromise valuePromise;
if (!aliasState.TryGetValue(anchor, out valuePromise))
{
aliasState.Add(anchor, new ValuePromise(value));
}
else if (!valuePromise.HasValue)
{
valuePromise.Value = value;
}
else
{
aliasState[anchor] = new ValuePromise(value);
}
}
return(value);
}
/// <summary>
/// AWARENESS: not thread safe
/// </summary>
/// <param name="reader"></param>
/// <param name="expectedType"></param>
/// <param name="state"></param>
/// <param name="nestedObjectDeserializer"></param>
/// <returns></returns>
public object DeserializeValue(EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
object value = _innerDeserializer.DeserializeValue(reader, expectedType, state, nestedObjectDeserializer);
var str = value as string;
if (str != null && str.Trim() == Constants.ContentPlaceholder)
{
ContainPlaceholder = true;
return(_replacer);
}
return(value);
}
public LooseAliasValueDeserializer(IValueDeserializer innerDeserializer)
{
_innerDeserializer = innerDeserializer ?? throw new ArgumentNullException("innerDeserializer");
}
public T Deserialize <T>(IParser reader, IValueDeserializer deserializer = null)
{
return((T)Deserialize(reader, typeof(T), deserializer));
}
public object Deserialize(IParser reader, IValueDeserializer deserializer = null)
{
return(Deserialize(reader, typeof(object), deserializer));
}
/// <summary>
/// Creates a new <see cref="Deserializer" /> that uses the specified <see cref="IValueDeserializer" />.
/// This method is available for advanced scenarios. The preferred way to customize the behavior of the
/// deserializer is to use <see cref="DeserializerBuilder" />.
/// </summary>
public static Deserializer FromValueDeserializer(IValueDeserializer valueDeserializer)
{
return(new Deserializer(valueDeserializer));
}
public object DeserializeValue(EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
AnchorAlias alias = reader.Allow <AnchorAlias>();
if (alias != null)
{
ValuePromise promise;
AliasState state2 = state.Get <AliasState>();
if (!state2.TryGetValue(alias.Value, out promise))
{
promise = new ValuePromise(alias);
state2.Add(alias.Value, promise);
}
return(!promise.HasValue ? promise : promise.Value);
}
string key = null;
NodeEvent event2 = reader.Peek <NodeEvent>();
if ((event2 != null) && !string.IsNullOrEmpty(event2.Anchor))
{
key = event2.Anchor;
}
object obj2 = this.innerDeserializer.DeserializeValue(reader, expectedType, state, nestedObjectDeserializer);
if (key != null)
{
ValuePromise promise2;
AliasState state3 = state.Get <AliasState>();
if (!state3.TryGetValue(key, out promise2))
{
state3.Add(key, new ValuePromise(obj2));
}
else
{
if (promise2.HasValue)
{
throw new DuplicateAnchorException(event2.Start, event2.End, $"Anchor '{key}' already defined");
}
promise2.Value = obj2;
}
}
return(obj2);
}
public object DeserializeValue(EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
public object?DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
object?value;
if (parser.TryConsume <AnchorAlias>(out var alias))
{
var aliasState = state.Get <AliasState>();
if (!aliasState.TryGetValue(alias.Value, out var valuePromise))
{
throw new AnchorNotFoundException(alias.Start, alias.End, $"Alias ${alias.Value} cannot precede anchor declaration");
}
return(valuePromise.HasValue ? valuePromise.Value : valuePromise);
}
var anchor = AnchorName.Empty;
if (parser.Accept <NodeEvent>(out var nodeEvent) && !nodeEvent.Anchor.IsEmpty)
{
anchor = nodeEvent.Anchor;
}
value = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
if (!anchor.IsEmpty)
{
var aliasState = state.Get <AliasState>();
if (!aliasState.TryGetValue(anchor, out var valuePromise))
{
aliasState.Add(anchor, new ValuePromise(value));
}
else if (!valuePromise.HasValue)
{
valuePromise.Value = value;
}
else
{
aliasState[anchor] = new ValuePromise(value);
}
}
return(value);
}
public object DeserializeValue(EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
var nodeEvent = reader.Peek <NodeEvent>();
var nodeType = GetTypeFromEvent(nodeEvent, expectedType);
foreach (var deserializer in deserializers)
{
object value;
if (deserializer.Deserialize(reader, nodeType, (r, t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out value))
{
return(value);
}
}
throw new SerializationException(
string.Format(
"No node deserializer was able to deserialize the node at {0} into type {1}",
reader.Parser.Current.Start,
expectedType.AssemblyQualifiedName
)
);
}
public object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
AnchorAlias anchorAlias = parser.Allow <AnchorAlias>();
if (anchorAlias != null)
{
AliasState aliasState = state.Get <AliasState>();
if (!aliasState.TryGetValue(anchorAlias.Value, out ValuePromise value))
{
value = new ValuePromise(anchorAlias);
aliasState.Add(anchorAlias.Value, value);
}
return((!value.HasValue) ? value : value.Value);
}
string text = null;
NodeEvent nodeEvent = parser.Peek <NodeEvent>();
if (nodeEvent != null && !string.IsNullOrEmpty(nodeEvent.Anchor))
{
text = nodeEvent.Anchor;
}
object obj = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
if (text != null)
{
AliasState aliasState2 = state.Get <AliasState>();
if (!aliasState2.TryGetValue(text, out ValuePromise value2))
{
aliasState2.Add(text, new ValuePromise(obj));
}
else if (!value2.HasValue)
{
value2.Value = obj;
}
else
{
aliasState2[text] = new ValuePromise(obj);
}
}
return(obj);
}
public object DeserializeValue(EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
object value;
var alias = reader.Allow <AnchorAlias>();
if (alias != null)
{
var aliasState = state.Get <AliasState>();
if (aliasState.TryGetValue(alias.Value, out value))
{
return(value);
}
throw new AnchorNotFoundException(alias.Start, alias.End, string.Format(
"Anchor '{0}' not found",
alias.Value
));
}
string anchor = null;
var nodeEvent = reader.Peek <NodeEvent>();
if (nodeEvent != null && !string.IsNullOrEmpty(nodeEvent.Anchor))
{
anchor = nodeEvent.Anchor;
}
value = innerDeserializer.DeserializeValue(reader, expectedType, state, nestedObjectDeserializer);
if (anchor != null)
{
var aliasState = state.Get <AliasState>();
aliasState.Add(anchor, value);
}
return(value);
}
public AliasValueDeserializer(IValueDeserializer innerDeserializer)
{
this.innerDeserializer = innerDeserializer ?? throw new ArgumentNullException(nameof(innerDeserializer));
}
public object Deserialize(TextReader input, IValueDeserializer deserializer = null)
{
return(Deserialize(input, typeof(object), deserializer));
}
/// <remarks>
/// This constructor is private to discourage its use.
/// To invoke it, call the <see cref="FromValueDeserializer"/> method.
/// </remarks>
private Deserializer(IValueDeserializer valueDeserializer)
{
this.valueDeserializer = valueDeserializer ?? throw new ArgumentNullException(nameof(valueDeserializer));
}
public object Deserialize(TextReader input, Type type, IValueDeserializer deserializer = null)
{
return(Deserialize(new Parser(input), type, deserializer));
}
public object DeserializeValue(EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
object value;
var alias = reader.Allow <AnchorAlias>();
if (alias != null)
{
var aliasState = state.Get <AliasState>();
ValuePromise valuePromise;
if (!aliasState.TryGetValue(alias.Value, out valuePromise))
{
valuePromise = new ValuePromise(alias);
aliasState.Add(alias.Value, valuePromise);
}
return(valuePromise.HasValue ? valuePromise.Value : valuePromise);
}
string anchor = null;
var nodeEvent = reader.Peek <NodeEvent>();
if (nodeEvent != null && !string.IsNullOrEmpty(nodeEvent.Anchor))
{
anchor = nodeEvent.Anchor;
}
value = innerDeserializer.DeserializeValue(reader, expectedType, state, nestedObjectDeserializer);
if (anchor != null)
{
var aliasState = state.Get <AliasState>();
ValuePromise valuePromise;
if (!aliasState.TryGetValue(anchor, out valuePromise))
{
aliasState.Add(anchor, new ValuePromise(value));
}
else if (!valuePromise.HasValue)
{
valuePromise.Value = value;
}
else
{
throw new DuplicateAnchorException(nodeEvent.Start, nodeEvent.End, string.Format(
"Anchor '{0}' already defined",
anchor
));
}
}
return(value);
}
public object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
{
NodeEvent nodeEvent = parser.Peek <NodeEvent>();
Type typeFromEvent = GetTypeFromEvent(nodeEvent, expectedType);
try
{
foreach (INodeDeserializer deserializer in deserializers)
{
if (deserializer.Deserialize(parser, typeFromEvent, (IParser r, Type t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out object value))
{
return(TypeConverter.ChangeType(value, expectedType));
}
}
}
catch (YamlException)
{
throw;
}
catch (Exception innerException)
{
throw new YamlException(nodeEvent.Start, nodeEvent.End, "Exception during deserialization", innerException);
}
throw new YamlException(nodeEvent.Start, nodeEvent.End, $"No node deserializer was able to deserialize the node into type {expectedType.AssemblyQualifiedName}");
}
