DeserializationResult ITypeReader <IReadOnlyList <string>, SequenceDataNode> .Read(
ISerializationManager serializationManager,
SequenceDataNode node,
IDependencyCollection dependencies,
bool skipHook,
ISerializationContext?context)
{
var list = new List <string>();
var mappings = new List <DeserializationResult>();
foreach (var dataNode in node.Sequence)
{
var result = _prototypeSerializer.Read(
serializationManager,
(ValueDataNode)dataNode,
dependencies,
skipHook,
context);
list.Add((string)result.RawValue !);
mappings.Add(result);
}
return(new DeserializedCollection <IReadOnlyList <string>, string>(list, mappings,
elements => new List <string>(elements)));
}
public DataNode Write(ISerializationManager serializationManager, int value, bool alwaysWrite = false,
ISerializationContext?context = null)
{
var sequenceNode = new SequenceDataNode();
var flagType = serializationManager.GetFlagTypeFromTag(typeof(TTag));
// Assumption: a bitflag enum has a constructor for every bit value such that
// that bit is set in some other constructor i.e. if a 1 appears somewhere in
// the bits of one of the enum constructors, there is an enum constructor which
// is 1 just in that position.
//
// Otherwise, this code may throw an exception
var maxFlagValue = serializationManager.GetFlagHighestBit(typeof(TTag));
for (var bitIndex = 1; bitIndex <= maxFlagValue; bitIndex++)
{
var bitValue = 1 << bitIndex;
if ((bitValue & value) == bitValue)
{
var flagName = Enum.GetName(flagType, bitValue);
if (flagName == null)
{
throw new InvalidOperationException($"No bitflag corresponding to bit {bitIndex} in {flagType}, but it was set anyways.");
}
sequenceNode.Add(new ValueDataNode(flagName));
}
}
return(sequenceNode);
}
public void ValidationInvalidTest()
{
var invalidSequence = new SequenceDataNode(TestInvalidEntityId);
var validations = Serialization.ValidateNodeWith <
List <string>,
PrototypeIdListSerializer <EntityPrototype>,
SequenceDataNode>(invalidSequence);
Assert.False(validations.Valid);
validations = Serialization.ValidateNodeWith <
IReadOnlyList <string>,
PrototypeIdListSerializer <EntityPrototype>,
SequenceDataNode>(invalidSequence);
Assert.False(validations.Valid);
validations = Serialization.ValidateNodeWith <
IReadOnlyCollection <string>,
PrototypeIdListSerializer <EntityPrototype>,
SequenceDataNode>(invalidSequence);
Assert.False(validations.Valid);
validations = Serialization.ValidateNodeWith <
ImmutableList <string>,
PrototypeIdListSerializer <EntityPrototype>,
SequenceDataNode>(invalidSequence);
Assert.False(validations.Valid);
}
ValidationNode ITypeValidator <IReadOnlyCollection <string>, SequenceDataNode> .Validate(
ISerializationManager serializationManager,
SequenceDataNode node,
IDependencyCollection dependencies,
ISerializationContext?context)
{
return(ValidateInternal(serializationManager, node, dependencies, context));
}
public void DeserializationTest()
{
var list = new[] { "A", "E" };
var node = new SequenceDataNode("A", "E");
var deserializedList = Serialization.ReadValue <string[]>(node);
Assert.That(deserializedList, Is.EqualTo(list));
}
ValidationNode Validate(ISerializationManager serializationManager, SequenceDataNode node, ISerializationContext?context)
{
var list = new List <ValidationNode>();
foreach (var elem in node.Sequence)
{
list.Add(serializationManager.ValidateNode(typeof(T), elem, context));
}
return(new ValidatedSequenceNode(list));
}
private DataNode WriteInternal(ISerializationManager serializationManager, IEnumerable <T> value, bool alwaysWrite = false,
ISerializationContext?context = null)
{
var sequence = new SequenceDataNode();
foreach (var elem in value)
{
sequence.Add(serializationManager.WriteValue(typeof(T), elem, alwaysWrite, context));
}
return(sequence);
}
public DataNode Write(ISerializationManager serializationManager, HashSet <T> value, bool alwaysWrite = false,
ISerializationContext?context = null)
{
var sequence = new SequenceDataNode();
foreach (var elem in value)
{
sequence.Add(serializationManager.WriteValue(typeof(T), elem, alwaysWrite, context));
}
return(sequence);
}
public void CustomReadTest()
{
var node = new SequenceDataNode("A", "E");
var result = Serialization.ReadWithTypeSerializer(typeof(List <string>), typeof(ListSerializers <string>), node);
var list = (List <string>?)result.RawValue;
Assert.NotNull(list);
Assert.IsNotEmpty(list !);
Assert.That(list, Has.Count.EqualTo(2));
Assert.That(list, Does.Contain("A"));
Assert.That(list, Does.Contain("E"));
}
DeserializationResult ITypeReader <IReadOnlyCollection <T>, SequenceDataNode> .Read(
ISerializationManager serializationManager, SequenceDataNode node,
IDependencyCollection dependencies,
bool skipHook, ISerializationContext?context)
{
var list = new List <T>();
var results = new List <DeserializationResult>();
foreach (var dataNode in node.Sequence)
{
var(value, result) = serializationManager.ReadWithValueOrThrow <T>(dataNode, context, skipHook);
list.Add(value);
results.Add(result);
}
return(new DeserializedCollection <IReadOnlyCollection <T>, T>(list, results, l => l));
}
DeserializationResult ITypeReader <ImmutableList <T>, SequenceDataNode> .Read(
ISerializationManager serializationManager, SequenceDataNode node,
IDependencyCollection dependencies,
bool skipHook, ISerializationContext?context)
{
var list = ImmutableList.CreateBuilder <T>();
var results = new List <DeserializationResult>();
foreach (var dataNode in node.Sequence)
{
var(value, result) = serializationManager.ReadWithValueOrThrow <T>(dataNode, context, skipHook);
list.Add(value);
results.Add(result);
}
return(new DeserializedCollection <ImmutableList <T>, T>(list.ToImmutable(), results, elements => ImmutableList.Create(elements.ToArray())));
}
public ValidationNode Validate(ISerializationManager serializationManager, SequenceDataNode node,
IDependencyCollection dependencies, ISerializationContext?context = null)
{
var list = new List <ValidationNode>();
foreach (var dataNode in node.Sequence)
{
if (dataNode is not ValueDataNode value)
{
list.Add(new ErrorNode(dataNode, $"Cannot cast node {dataNode} to ValueDataNode."));
continue;
}
list.Add(serializationManager.ValidateNodeWith <string, PrototypeIdSerializer <T>, ValueDataNode>(value, context));
}
return(new ValidatedSequenceNode(list));
}
public ValidationNode Validate(ISerializationManager serializationManager, SequenceDataNode node,
IDependencyCollection dependencies, ISerializationContext?context = null)
{
var flagType = serializationManager.GetFlagTypeFromTag(typeof(TTag));
foreach (var elem in node.Sequence)
{
if (elem is not ValueDataNode valueDataNode)
{
return(new ErrorNode(node, "Invalid flagtype in flag-sequence.", true));
}
if (!Enum.TryParse(flagType, valueDataNode.Value, out _))
{
return(new ErrorNode(node, "Failed parsing flag in flag-sequence", false));
}
}
return(new ValidatedValueNode(node));
}
DeserializationResult ITypeReader <HashSet <T>, SequenceDataNode> .Read(ISerializationManager serializationManager,
SequenceDataNode node,
IDependencyCollection dependencies,
bool skipHook,
ISerializationContext?context)
{
var set = new HashSet <T>();
var mappings = new List <DeserializationResult>();
foreach (var dataNode in node.Sequence)
{
var(value, result) = serializationManager.ReadWithValueOrThrow <T>(dataNode, context, skipHook);
set.Add(value);
mappings.Add(result);
}
return(new DeserializedCollection <HashSet <T>, T>(set, mappings, elements => new HashSet <T>(elements)));
}
public SerializationArrayBenchmark()
{
InitializeSerialization();
OneStringDefNode = new SequenceDataNode();
OneStringDefNode.Add(new MappingDataNode
{
["string"] = new ValueDataNode("ABC")
});
TenStringDefsNode = new SequenceDataNode();
for (var i = 0; i < 10; i++)
{
TenStringDefsNode.Add(new MappingDataNode
{
["string"] = new ValueDataNode("ABC")
});
}
}
ValidationNode ITypeValidator <IReadOnlyList <string>, SequenceDataNode> .Validate(
ISerializationManager serializationManager,
SequenceDataNode node,
IDependencyCollection dependencies,
ISerializationContext?context)
{
var list = new List <ValidationNode>();
foreach (var dataNode in node.Sequence)
{
if (dataNode is not ValueDataNode value)
{
list.Add(new ErrorNode(dataNode, $"Cannot cast node {dataNode} to ValueDataNode."));
continue;
}
list.Add(_prototypeSerializer.Validate(serializationManager, value, dependencies, context));
}
return(new ValidatedSequenceNode(list));
}
public ValidationNode Validate(ISerializationManager serializationManager, SequenceDataNode node,
IDependencyCollection dependencies, ISerializationContext?context = null)
{
return(ValidateInternal(serializationManager, node, dependencies, context));
}
ValidationNode ITypeValidator <HashSet <T>, SequenceDataNode> .Validate(ISerializationManager serializationManager,
SequenceDataNode node, IDependencyCollection dependencies, ISerializationContext?context)
{
return(Validate(serializationManager, node, context));
}
public DeserializationResult Read(ISerializationManager serializationManager, SequenceDataNode node,
IDependencyCollection dependencies, bool skipHook, ISerializationContext?context = null)
{
var builder = ImmutableList.CreateBuilder <string>();
var mappings = new List <DeserializationResult>();
foreach (var dataNode in node.Sequence)
{
var result = _prototypeSerializer.Read(
serializationManager,
(ValueDataNode)dataNode,
dependencies,
skipHook,
context);
builder.Add((string)result.RawValue !);
mappings.Add(result);
}
return(new DeserializedCollection <ImmutableList <string>, string>(builder.ToImmutable(), mappings,
ImmutableList.CreateRange));
}
public DeserializationResult Read(ISerializationManager serializationManager, SequenceDataNode node,
IDependencyCollection dependencies, bool skipHook, ISerializationContext?context = null)
{
var flagType = serializationManager.GetFlagTypeFromTag(typeof(TTag));
var flags = 0;
foreach (var elem in node.Sequence)
{
if (elem is not ValueDataNode valueDataNode)
{
throw new InvalidNodeTypeException();
}
flags |= (int)Enum.Parse(flagType, valueDataNode.Value);
}
return(new DeserializedValue(flags));
}
public DeserializationResult Read(ISerializationManager serializationManager, SequenceDataNode node,
IDependencyCollection dependencies, bool skipHook, ISerializationContext?context = null)
{
var flags = new List <string>(node.Sequence.Count);
foreach (var dataNode in node.Sequence)
{
if (dataNode is not ValueDataNode value)
{
continue;
}
flags.Add(value.Value);
}
return(new DeserializedValue <PrototypeFlags <T> >(new PrototypeFlags <T>(flags)));
}
