DeserializationResult ITypeReader <EntityPrototype, ValueDataNode> .Read(
ISerializationManager serializationManager, ValueDataNode node,
IDependencyCollection dependencies,
bool skipHook, ISerializationContext?context)
{
return(DeserializationResult.Value(new EntityPrototype(node.Value)));
}
DeserializationResult ITypeReader <Texture, ValueDataNode> .Read(ISerializationManager serializationManager,
ValueDataNode node,
IDependencyCollection dependencies,
bool skipHook, ISerializationContext?context)
{
var path = serializationManager.ReadValueOrThrow <ResourcePath>(node, context, skipHook);
return(DeserializationResult.Value(new Texture(path)));
}
public async ValueTask <DeserializationResult <TResult> > TryDeserializeAsync <TResult>(Stream stream)
{
try
{
var result = await JsonSerializer.DeserializeAsync <TResult>(stream, serializerOptions).ConfigureAwait(false);
return(DeserializationResult <TResult> .Success(result));
}
catch (Exception ex)
{
return(DeserializationResult <TResult> .Failed(ex));
}
}
public DeserializationResult Read(ISerializationManager serializationManager, MappingDataNode node,
IDependencyCollection dependencies,
bool skipHook,
ISerializationContext?context = null)
{
if (node.Children.Count != 1)
{
throw new InvalidMappingException("Less than or more than 1 mappings provided to ValueTupleSerializer");
}
var entry = node.Children.First();
var v1 = serializationManager.ReadValueOrThrow <T1>(entry.Key, context, skipHook);
var v2 = serializationManager.ReadValueOrThrow <T2>(entry.Value, context, skipHook);
return(DeserializationResult.Value(new ValueTuple <T1, T2>(v1, v2)));
}
DeserializationResult ITypeReader <Rsi, MappingDataNode> .Read(ISerializationManager serializationManager,
MappingDataNode node,
IDependencyCollection dependencies,
bool skipHook, ISerializationContext?context)
{
if (!node.TryGet("sprite", out var pathNode))
{
throw new InvalidMappingException("Expected sprite-node");
}
if (!node.TryGet("state", out var stateNode) || stateNode is not ValueDataNode valueDataNode)
{
throw new InvalidMappingException("Expected state-node as a valuenode");
}
var path = serializationManager.ReadValueOrThrow <ResourcePath>(pathNode, context, skipHook);
return(DeserializationResult.Value(new Rsi(path, valueDataNode.Value)));
}
private void ThrowOnWrongResult(DeserializationResult result)
{
switch (result)
{
case DeserializationResult.OK:
return;
case DeserializationResult.WrongMagic:
throw new InvalidOperationException("Cound not find proper magic.");
case DeserializationResult.WrongVersion:
throw new InvalidOperationException("Could not deserialize data serialized with another version of serializer.");
case DeserializationResult.StreamCorrupted:
throw lastException;
default:
throw new ArgumentOutOfRangeException();
}
}
public DeserializationResult Read(ISerializationManager serializationManager,
SequenceDataNode node,
IDependencyCollection dependencies,
bool skipHook,
ISerializationContext?context = null)
{
var factory = dependencies.Resolve <IComponentFactory>();
var components = new ComponentRegistry();
var mappings = new Dictionary <DeserializationResult, DeserializationResult>();
foreach (var componentMapping in node.Sequence.Cast <MappingDataNode>())
{
string compType = ((ValueDataNode)componentMapping.Get("type")).Value;
// See if type exists to detect errors.
switch (factory.GetComponentAvailability(compType))
{
case ComponentAvailability.Available:
break;
case ComponentAvailability.Ignore:
continue;
case ComponentAvailability.Unknown:
Logger.ErrorS(SerializationManager.LogCategory, $"Unknown component '{compType}' in prototype!");
continue;
}
// Has this type already been added?
if (components.Keys.Contains(compType))
{
Logger.ErrorS(SerializationManager.LogCategory, $"Component of type '{compType}' defined twice in prototype!");
continue;
}
var copy = componentMapping.Copy() !;
copy.Remove("type");
var type = factory.GetRegistration(compType).Type;
var read = serializationManager.ReadWithValueOrThrow <IComponent>(type, copy, skipHook: skipHook);
components[compType] = read.value;
mappings.Add(DeserializationResult.Value(compType), read.result);
}
var referenceTypes = new List <Type>();
// Assert that there are no conflicting component references.
foreach (var componentName in components.Keys)
{
var registration = factory.GetRegistration(componentName);
foreach (var compType in registration.References)
{
if (referenceTypes.Contains(compType))
{
throw new InvalidOperationException(
$"Duplicate component reference in prototype: '{compType}'");
}
referenceTypes.Add(compType);
}
}
return(new DeserializedComponentRegistry(components, mappings));
}
public override DeserializationResult PushInheritanceFrom(DeserializationResult source)
{
return(source.Copy().Cast <DeserializedValue>());
}
public DeserializationResult Read(ISerializationManager serializationManager, ValueDataNode node,
IDependencyCollection dependencies, bool skipHook, ISerializationContext?context = null)
{
return(DeserializationResult.Value(node.Value));
}
public abstract DeserializationResult PushInheritanceFrom(DeserializationResult source);
