public DataNode BaselineWriteSeedDataDefinition()
{
var mapping = new MappingDataNode();
mapping.Add("id", Seed.ID);
mapping.Add("name", Seed.Name);
mapping.Add("seedName", Seed.SeedName);
mapping.Add("displayName", Seed.DisplayName);
mapping.Add("productPrototypes", Seed.ProductPrototypes);
mapping.Add("harvestRepeat", Seed.HarvestRepeat.ToString());
mapping.Add("lifespan", Seed.Lifespan.ToString(CultureInfo.InvariantCulture));
mapping.Add("maturation", Seed.Maturation.ToString(CultureInfo.InvariantCulture));
mapping.Add("production", Seed.Production.ToString(CultureInfo.InvariantCulture));
mapping.Add("yield", Seed.Yield.ToString(CultureInfo.InvariantCulture));
mapping.Add("potency", Seed.Potency.ToString(CultureInfo.InvariantCulture));
mapping.Add("growthStages", Seed.GrowthStages.ToString(CultureInfo.InvariantCulture));
mapping.Add("idealLight", Seed.IdealLight.ToString(CultureInfo.InvariantCulture));
mapping.Add("idealHeat", Seed.IdealHeat.ToString(CultureInfo.InvariantCulture));
var chemicals = new MappingDataNode();
foreach (var(name, quantity) in Seed.Chemicals)
{
chemicals.Add(name, new MappingDataNode
{
["Min"] = new ValueDataNode(quantity.Min.ToString(CultureInfo.InvariantCulture)),
["Max"] = new ValueDataNode(quantity.Max.ToString(CultureInfo.InvariantCulture)),
["PotencyDivisor"] = new ValueDataNode(quantity.PotencyDivisor.ToString(CultureInfo.InvariantCulture))
});
}
mapping.Add("chemicals", chemicals);
return(mapping);
}
public void DeserializeNullDefinitionTest()
{
var node = new MappingDataNode().Add("unit", "null");
var definition = Serialization.Read <FixedPoint2TestDefinition>(node);
Assert.That(definition.Unit, Is.Null);
}
ValidationNode ITypeValidator <Rsi, MappingDataNode> .Validate(ISerializationManager serializationManager,
MappingDataNode node,
IDependencyCollection dependencies,
ISerializationContext?context)
{
if (!node.TryGet("sprite", out var pathNode) || pathNode is not ValueDataNode valuePathNode)
{
return(new ErrorNode(node, "Missing/Invalid sprite node"));
}
if (!node.TryGet("state", out var stateNode) || stateNode is not ValueDataNode)
{
return(new ErrorNode(node, "Missing/Invalid state node"));
}
var path = serializationManager.ValidateNode(typeof(ResourcePath),
new ValueDataNode($"{SharedSpriteComponent.TextureRoot / valuePathNode.Value}"), context);
if (path is ErrorNode)
{
return(path);
}
return(new ValidatedValueNode(node));
}
DeserializationResult ITypeReader <SpriteSpecifier, MappingDataNode> .Read(
ISerializationManager serializationManager, MappingDataNode node,
IDependencyCollection dependencies,
bool skipHook, ISerializationContext?context)
{
return(((ITypeReader <Rsi, MappingDataNode>) this).Read(serializationManager, node, dependencies, skipHook, context));
}
public void DeserializeNullDefinitionTest()
{
var node = new MappingDataNode().Add("unit", "null");
var definition = Serialization.ReadValueOrThrow <ReagentUnitTestDefinition>(node);
Assert.That(definition.Unit, Is.Null);
}
ValidationNode ITypeValidator <SpriteSpecifier, MappingDataNode> .Validate(
ISerializationManager serializationManager, MappingDataNode node,
IDependencyCollection dependencies,
ISerializationContext?context)
{
return(((ITypeReader <Rsi, MappingDataNode>) this).Validate(serializationManager, node, dependencies, context));
}
public DataNode Write(ISerializationManager serializationManager, Rsi value, bool alwaysWrite = false,
ISerializationContext?context = null)
{
var mapping = new MappingDataNode();
mapping.Add("sprite", serializationManager.WriteValue(value.RsiPath));
mapping.Add("state", new ValueDataNode(value.RsiState));
return(mapping);
}
public DeserializationResult Populate(
object target,
MappingDataNode mapping,
ISerializationManager serialization,
ISerializationContext?context,
bool skipHook)
{
var fields = _deserialize(mapping, serialization, context, skipHook);
return(_populate(target, fields, DefaultValues));
}
ValidationNode Validate(ISerializationManager serializationManager, MappingDataNode node, ISerializationContext?context)
{
var mapping = new Dictionary <ValidationNode, ValidationNode>();
foreach (var(key, val) in node.Children)
{
mapping.Add(serializationManager.ValidateNode(typeof(TKey), key, context), serializationManager.ValidateNode(typeof(TValue), val, context));
}
return(new ValidatedMappingNode(mapping));
}
private SerializeDelegateSignature EmitSerializeDelegate()
{
MappingDataNode SerializeDelegate(
object obj,
ISerializationManager manager,
ISerializationContext?context,
bool alwaysWrite,
object?[] defaultValues)
{
var mapping = new MappingDataNode();
for (var i = BaseFieldDefinitions.Length - 1; i >= 0; i--)
{
var fieldDefinition = BaseFieldDefinitions[i];
if (fieldDefinition.Attribute.ReadOnly)
{
continue;
}
if (fieldDefinition.Attribute.ServerOnly &&
!IoCManager.Resolve <INetManager>().IsServer)
{
continue;
}
var value = FieldAccessors[i](ref obj);
if (value == null)
{
continue;
}
if (!fieldDefinition.Attribute.Required &&
!alwaysWrite &&
Equals(value, defaultValues[i]))
{
continue;
}
var type = fieldDefinition.FieldType;
var node = fieldDefinition.Attribute.CustomTypeSerializer != null
? manager.WriteWithTypeSerializer(type, fieldDefinition.Attribute.CustomTypeSerializer,
value, alwaysWrite, context)
: manager.WriteValue(type, value, alwaysWrite, context);
mapping[fieldDefinition.Attribute.Tag] = node;
}
return(mapping);
}
return(SerializeDelegate);
}
public SerializationReadBenchmark()
{
InitializeSerialization();
StringDataDefNode = new MappingDataNode();
StringDataDefNode.Add(new ValueDataNode("string"), new ValueDataNode("ABC"));
var yamlStream = new YamlStream();
yamlStream.Load(new StringReader(SeedDataDefinition.Prototype));
SeedNode = yamlStream.Documents[0].RootNode.ToDataNodeCast <SequenceDataNode>().Cast <MappingDataNode>(0);
}
public void PopulateElementDescriptor(MappingDataNode node, ISerializationManager serializationManager)
{
MappingDataNode original = (MappingDataNode)serializationManager.WriteValue(ElementDescriptor.GetType(), ElementDescriptor);
foreach (var key in node.Keys)
{
original.Remove(key);
}
MappingDataNode newNode = original.Merge(node);
ElementDescriptor = (ElementDescriptor)serializationManager.Read(ElementDescriptor.GetType(), newNode);
UpdateElementDescriptor();
}
public void SerializeListTest()
{
// Arrange
var data = _serializableList;
var serMan = IoCManager.Resolve <ISerializationManager>();
var sequence = (SequenceDataNode)serMan.WriteValue(data);
var mapping = new MappingDataNode();
mapping.Add("datalist", sequence);
// Assert
var result = NodeToYamlText(mapping);
Assert.That(result, Is.EqualTo(_serializedListYaml));
}
public DeserializationResult Read(ISerializationManager serializationManager,
MappingDataNode node, IDependencyCollection dependencies, bool skipHook, ISerializationContext?context)
{
var dict = new Dictionary <TKey, TValue>();
var mappedFields = new Dictionary <DeserializationResult, DeserializationResult>();
foreach (var(key, value) in node.Children)
{
var(keyVal, keyResult) = serializationManager.ReadWithValueOrThrow <TKey>(key, context, skipHook);
var(valueResult, valueVal) = serializationManager.ReadWithValueCast <TValue>(typeof(TValue), value, context, skipHook);
dict.Add(keyVal, valueVal !);
mappedFields.Add(keyResult, valueResult);
}
return(new DeserializedDictionary <Dictionary <TKey, TValue>, TKey, TValue>(dict, mappedFields, dictInstance => dictInstance));
}
private MappingDataNode InterfaceWrite(
ISerializationManager serializationManager,
IDictionary <TKey, TValue> value,
bool alwaysWrite = false,
ISerializationContext?context = null)
{
var mappingNode = new MappingDataNode();
foreach (var(key, val) in value)
{
mappingNode.Add(
serializationManager.WriteValue(key, alwaysWrite, context),
serializationManager.WriteValue(typeof(TValue), val, alwaysWrite, context));
}
return(mappingNode);
}
public void DeserializationTest()
{
var dictionary = new Dictionary <int, string>
{
[1] = "A",
[2] = "B",
[3] = "C"
};
var node = new MappingDataNode();
node.Add("1", new ValueDataNode("A"));
node.Add("2", new ValueDataNode("B"));
node.Add("3", new ValueDataNode("C"));
var deserializedDictionary = Serialization.ReadValue <Dictionary <int, string> >(node);
Assert.That(deserializedDictionary, Is.EqualTo(dictionary));
}
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(new DeserializedValue <Rsi>(new Rsi(path, valueDataNode.Value)));
}
public MappingDataNode Attributes()
{
var node = new MappingDataNode();
while (TryGetAttribute(out var key, out var value))
{
if (value == "none")
{
continue;
}
if (value[0] == '"')
{
value = value.Substring(1, value.Length - 2);
}
node.Add(key, value);
}
return(node);
}
public ValidationNode Validate(ISerializationManager serializationManager, MappingDataNode node,
IDependencyCollection dependencies,
ISerializationContext?context = null)
{
if (node.Children.Count != 1)
{
return(new ErrorNode(node, "More or less than 1 Mapping for ValueTuple found."));
}
var entry = node.Children.First();
var dict = new Dictionary <ValidationNode, ValidationNode>
{
{
serializationManager.ValidateNode(typeof(T1), entry.Key, context),
serializationManager.ValidateNode(typeof(T2), entry.Value, context)
}
};
return(new ValidatedMappingNode(dict));
}
public ValidationNode Validate(
ISerializationManager serialization,
MappingDataNode mapping,
ISerializationContext?context)
{
var validatedMapping = new Dictionary <ValidationNode, ValidationNode>();
foreach (var(key, val) in mapping.Children)
{
if (key is not ValueDataNode valueDataNode)
{
validatedMapping.Add(new ErrorNode(key, "Key not ValueDataNode."), new InconclusiveNode(val));
continue;
}
var field = BaseFieldDefinitions.FirstOrDefault(f => f.Attribute.Tag == valueDataNode.Value);
if (field == null)
{
var error = new ErrorNode(
key,
$"Field \"{valueDataNode.Value}\" not found in \"{Type}\".",
false);
validatedMapping.Add(error, new InconclusiveNode(val));
continue;
}
var keyValidated = serialization.ValidateNode(typeof(string), key, context);
ValidationNode valValidated = field.Attribute.CustomTypeSerializer != null
? serialization.ValidateNodeWith(field.FieldType,
field.Attribute.CustomTypeSerializer, val, context)
: serialization.ValidateNode(field.FieldType, val, context);
validatedMapping.Add(keyValidated, valValidated);
}
return(new ValidatedMappingNode(validatedMapping));
}
private SerializeDelegateSignature EmitSerializeDelegate()
{
MappingDataNode SerializeDelegate(
object obj,
ISerializationManager manager,
ISerializationContext?context,
bool alwaysWrite,
object?[] defaultValues)
{
var mapping = new MappingDataNode();
for (var i = BaseFieldDefinitions.Length - 1; i >= 0; i--)
{
var fieldDefinition = BaseFieldDefinitions[i];
if (fieldDefinition.Attribute.ReadOnly)
{
continue;
}
if (fieldDefinition.Attribute.ServerOnly &&
!IoCManager.Resolve <INetManager>().IsServer)
{
continue;
}
var value = FieldAccessors[i](ref obj);
if (value == null)
{
continue;
}
if (!fieldDefinition.Attribute.Required &&
!alwaysWrite &&
Equals(value, defaultValues[i]))
{
continue;
}
var type = fieldDefinition.FieldType;
DataNode node;
if (fieldDefinition.Attribute.CustomTypeSerializer != null)
{
var foundInterface = false;
foreach (var @interface in fieldDefinition.Attribute.CustomTypeSerializer.GetInterfaces())
{
if (@interface.GetGenericTypeDefinition() != typeof(ITypeWriter <>))
{
continue;
}
if (@interface.GenericTypeArguments[0] == type)
{
foundInterface = true;
}
}
if (!foundInterface)
{
throw new InvalidOperationException(
$"Could not find implementation of ITypeWriter for type {type} on customtypeserializer {fieldDefinition.Attribute.CustomTypeSerializer}");
}
node = manager.WriteWithTypeSerializer(type, fieldDefinition.Attribute.CustomTypeSerializer,
value, alwaysWrite, context);
}
else
{
node = manager.WriteValue(type, value, alwaysWrite, context);
}
mapping[fieldDefinition.Attribute.Tag] = node;
}
return(mapping);
}
return(SerializeDelegate);
}
ValidationNode ITypeValidator <Dictionary <TKey, TValue>, MappingDataNode> .Validate(
ISerializationManager serializationManager,
MappingDataNode node, IDependencyCollection dependencies, ISerializationContext?context)
{
return(Validate(serializationManager, node, context));
}
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(new DeserializedValue <ValueTuple <T1, T2> >(new ValueTuple <T1, T2>(v1, v2)));
}
public void ParityTest()
{
var mapping = new MappingDataNode();
mapping.Add(GetOnlyPropertyName, new ValueDataNode("5"));
mapping.Add(GetOnlyPropertyFieldTargetedName, new ValueDataNode("10"));
mapping.Add(GetAndSetPropertyName, new ValueDataNode("15"));
mapping.Add(FieldName, new ValueDataNode("20"));
mapping.Add(GetOnlyPropertyWithOtherAttributeFieldTargetedName, new ValueDataNode("25"));
mapping.Add(GetOnlyPropertyFieldTargetedAndOtherAttributeName, new ValueDataNode("30"));
var definition = Serialization.ReadValue <PropertyAndFieldDefinitionTestDefinition>(mapping);
Assert.NotNull(definition);
// Get only property with backing field, property targeted
Assert.That(definition !.GetOnlyProperty, Is.EqualTo(5));
var backingField = definition.GetType().GetBackingField(GetOnlyPropertyName);
Assert.NotNull(backingField);
var backingFieldValue = backingField !.GetValue(definition);
Assert.That(backingFieldValue, Is.EqualTo(5));
// Get only property with backing field, field targeted
Assert.That(definition.GetOnlyPropertyFieldTargeted, Is.EqualTo(10));
// Get and set property with backing field, property targeted
Assert.That(definition.GetAndSetProperty, Is.EqualTo(15));
// Field
Assert.That(definition.Field, Is.EqualTo(20));
// Get only property with backing field, property targeted with another attribute field targeted
Assert.That(definition.GetOnlyPropertyWithOtherAttributeFieldTargeted, Is.EqualTo(25));
var property = definition.GetType().GetProperty(GetOnlyPropertyWithOtherAttributeFieldTargetedName);
Assert.NotNull(property);
var propertyInfo = new SpecificPropertyInfo(property !);
Assert.NotNull(propertyInfo.GetAttribute <DataFieldAttribute>());
Assert.NotNull(propertyInfo.GetBackingField() !.GetAttribute <AlwaysPushInheritanceAttribute>());
// We check for the property info properly finding field targeted attributes as
// well, otherwise we run the risk of the data field being targeted to the
// property but an additional attribute like AlwaysPushInheritance being targeted
// to the field, as was the case in EntityPrototype.
// And I don't want to debug that ever again.
Assert.NotNull(propertyInfo.DeclaringType);
var dataDefinition = ((SerializationManager)Serialization).GetDefinition(propertyInfo.DeclaringType !);
Assert.NotNull(dataDefinition);
var alwaysPushDataField = propertyInfo.GetAttribute <DataFieldAttribute>();
var propertyDefinition =
dataDefinition !.BaseFieldDefinitions.Single(e => e.Attribute.Equals(alwaysPushDataField));
var inheritanceBehaviour = propertyDefinition.InheritanceBehavior;
Assert.That(inheritanceBehaviour, Is.EqualTo(InheritanceBehavior.Always));
// Get only property with backing field, field targeted with another attribute property targeted
Assert.That(definition.GetOnlyPropertyFieldTargetedAndOtherAttribute, Is.EqualTo(30));
property = definition.GetType().GetProperty(GetOnlyPropertyFieldTargetedAndOtherAttributeName);
Assert.NotNull(property);
propertyInfo = new SpecificPropertyInfo(property !);
// Data field is targeted to the backing field
Assert.NotNull(propertyInfo.GetBackingField() !.GetAttribute <DataFieldAttribute>());
Assert.Null(propertyInfo.GetAttribute <DataFieldAttribute>());
Assert.NotNull(propertyInfo.GetAttribute <DataFieldAttribute>(true));
// NeverPushInheritanceAttribute is targeted to the property
Assert.NotNull(propertyInfo.GetAttribute <NeverPushInheritanceAttribute>());
Assert.Null(propertyInfo.GetBackingField() !.GetAttribute <NeverPushInheritanceAttribute>());
Assert.NotNull(propertyInfo.GetAttribute <NeverPushInheritanceAttribute>(true));
var neverPushDataField = propertyInfo.GetBackingField() !.GetAttribute <DataFieldAttribute>();
propertyDefinition =
dataDefinition !.BaseFieldDefinitions.Single(e => e.Attribute.Equals(neverPushDataField));
inheritanceBehaviour = propertyDefinition.InheritanceBehavior;
dataDefinition = ((SerializationManager)Serialization).GetDefinition(property !.DeclaringType !);
Assert.NotNull(dataDefinition);
Assert.That(inheritanceBehaviour, Is.EqualTo(InheritanceBehavior.Never));
}
