/// <inheritdoc/>
protected override object ReadCollectionItem(ref ObjectContext objectContext, Type itemType)
{
// Save the Yaml stream, in case loading fails we can keep this representation
var parsingEvents = new List<ParsingEvent>();
var reader = objectContext.Reader;
var startDepth = reader.CurrentDepth;
do
{
parsingEvents.Add(reader.Expect<ParsingEvent>());
} while (reader.CurrentDepth > startDepth);
// Save states
var previousReader = objectContext.SerializerContext.Reader;
var previousAllowErrors = objectContext.SerializerContext.AllowErrors;
objectContext.SerializerContext.Reader = new EventReader(new MemoryParser(parsingEvents));
objectContext.SerializerContext.AllowErrors = true;
try
{
return objectContext.ObjectSerializerBackend.ReadCollectionItem(ref objectContext, itemType);
}
catch (YamlException)
{
// There was a failure, let's keep this object so that it can be serialized back later
return new UnloadableScript(parsingEvents);
}
finally
{
// Restore states
objectContext.SerializerContext.Reader = previousReader;
objectContext.SerializerContext.AllowErrors = previousAllowErrors;
}
}
public override string ReadMemberName(ref ObjectContext objectContext, string memberName)
{
var newMemberName = memberName.Trim(PostFixSealed, PostFixNew);
if (newMemberName.Length != memberName.Length)
{
var overrideType = OverrideType.Base;
if (memberName.Contains(PostFixNewSealed) || memberName.EndsWith(PostFixNewSealedAlt))
{
overrideType = OverrideType.New | OverrideType.Sealed;
}
else if (memberName.EndsWith(PostFixNew))
{
overrideType = OverrideType.New;
}
else if (memberName.EndsWith(PostFixSealed))
{
overrideType = OverrideType.Sealed;
}
if (overrideType != OverrideType.Base)
{
var objectType = objectContext.Instance.GetType();
if (cachedDescriptor == null || cachedDescriptor.Type != objectType)
{
cachedDescriptor = typeDescriptorFactory.Find(objectType);
}
var memberDescriptor = cachedDescriptor[newMemberName];
objectContext.Instance.SetOverride(memberDescriptor, overrideType);
}
}
return base.ReadMemberName(ref objectContext, newMemberName);
}
public override void WriteMemberName(ref ObjectContext objectContext, SharpYaml.Serialization.IMemberDescriptor member, string memberName)
{
// Replace the key with SiliconStudio.Core.Reflection IMemberDescriptor
// Cache previous
if (member != null)
{
var customDescriptor = (IMemberDescriptor)member.Tag;
if (customDescriptor == null)
{
customDescriptor = typeDescriptorFactory.Find(objectContext.Instance.GetType())[memberName];
member.Tag = customDescriptor;
}
if (customDescriptor != null)
{
var overrideType = objectContext.Instance.GetOverride(customDescriptor);
if (!keepOnlySealedOverrides && (overrideType & OverrideType.New) != 0)
{
memberName += PostFixNew;
}
if ((overrideType & OverrideType.Sealed) != 0)
{
memberName += PostFixSealed;
}
}
}
base.WriteMemberName(ref objectContext, member, memberName);
}
protected override void WriteScalar(ref ObjectContext objectContext, ScalarEventInfo scalar)
{
// TODO: if ParameterKey is written to an object, It will not serialized a tag
scalar.Tag = null;
scalar.IsPlainImplicit = true;
base.WriteScalar(ref objectContext, scalar);
}
public override string ConvertTo(ref ObjectContext objectContext)
{
var attachedReference = AttachedReferenceManager.GetAttachedReference(objectContext.Instance);
if (attachedReference == null)
throw new YamlException(string.Format("Unable to extract asset reference from object [{0}]", objectContext.Instance));
return string.Format("{0}:{1}", attachedReference.Id, attachedReference.Url);
}
protected override void WriteDictionaryItems(ref ObjectContext objectContext)
{
// Don't sort dictionary keys
var savedSettings = objectContext.Settings.SortKeyForMapping;
objectContext.Settings.SortKeyForMapping = false;
base.WriteDictionaryItems(ref objectContext);
objectContext.Settings.SortKeyForMapping = savedSettings;
}
protected override void WriteDictionaryItem(ref ObjectContext objectContext, KeyValuePair<object, object> keyValue, KeyValuePair<Type, Type> types)
{
var propertyKey = (PropertyKey)keyValue.Key;
objectContext.SerializerContext.WriteYaml(propertyKey, types.Key);
// Deduce expected value type from PropertyKey
objectContext.SerializerContext.WriteYaml(keyValue.Value, propertyKey.PropertyType);
}
protected override void WriteDictionaryItems(ref ObjectContext objectContext)
{
//TODO: make SortKeyForMapping accessible in object context since it modifies the behavior of the serializer for children of the ComputeColorParameters
var savedSettings = objectContext.Settings.SortKeyForMapping;
objectContext.Settings.SortKeyForMapping = false;
base.WriteDictionaryItems(ref objectContext);
objectContext.Settings.SortKeyForMapping = savedSettings;
}
public override string ConvertTo(ref ObjectContext objectContext)
{
var attachedReference = AttachedReferenceManager.GetAttachedReference(objectContext.Instance);
if (attachedReference == null)
throw new YamlException($"Unable to extract asset reference from object [{objectContext.Instance}]");
var referenceId = IdentifiableHelper.GetId(objectContext.Instance);
return $"{referenceId}/{attachedReference.Id}:{attachedReference.Url}";
}
public override object ConvertFrom(ref ObjectContext context, Scalar fromScalar)
{
PackageVersion packageVersion;
if (!PackageVersion.TryParse(fromScalar.Value, out packageVersion))
{
throw new YamlException(fromScalar.Start, fromScalar.End, "Invalid version format. Unable to decode [{0}]".ToFormat(fromScalar.Value));
}
return packageVersion;
}
public override object ConvertFrom(ref ObjectContext context, Scalar fromScalar)
{
PackageReference packageReference;
if (!PackageReference.TryParse(fromScalar.Value, out packageReference))
{
throw new YamlException(fromScalar.Start, fromScalar.End, "Unable to decode package reference [{0}]. Expecting format GUID:LOCATION".ToFormat(fromScalar.Value));
}
return packageReference;
}
public override object ConvertFrom(ref ObjectContext context, Scalar fromScalar)
{
AssetReference assetReference;
if (!AssetReference.TryParse(context.Descriptor.Type, fromScalar.Value, out assetReference))
{
throw new YamlException(fromScalar.Start, fromScalar.End, "Unable to decode asset reference [{0}]. Expecting format GUID:LOCATION".ToFormat(fromScalar.Value));
}
return assetReference;
}
public override object ConvertFrom(ref ObjectContext objectContext, Scalar fromScalar)
{
var parameterKey = ParameterKeys.FindByName(fromScalar.Value);
if (parameterKey == null)
{
throw new YamlException(fromScalar.Start, fromScalar.End, "Unable to find registered ParameterKey [{0}]".ToFormat(fromScalar.Value));
}
return parameterKey;
}
protected override KeyValuePair<object, object> ReadDictionaryItem(ref ObjectContext objectContext, KeyValuePair<Type, Type> keyValueType)
{
// Read PropertyKey
var keyResult = (PropertyKey)objectContext.SerializerContext.ReadYaml(null, keyValueType.Key);
// Deduce expected value type from PropertyKey
var valueResult = objectContext.SerializerContext.ReadYaml(null, keyResult.PropertyType);
return new KeyValuePair<object, object>(keyResult, valueResult);
}
public override object ConvertFrom(ref ObjectContext objectContext, Scalar fromScalar)
{
Guid id;
if (!Guid.TryParse(fromScalar.Value, out id))
{
throw new YamlException(fromScalar.Start, fromScalar.End, $"Unable to parse id [{fromScalar.Value}]");
}
var materialNull = new MaterialNull();
IdentifiableHelper.SetId(materialNull, id);
return materialNull;
}
public override object ConvertFrom(ref ObjectContext context, Scalar fromScalar)
{
Guid guid;
UFile location;
if (!AssetReference.TryParse(fromScalar.Value, out guid, out location))
{
throw new YamlException(fromScalar.Start, fromScalar.End, "Unable to decode asset reference [{0}]. Expecting format GUID:LOCATION".ToFormat(fromScalar.Value));
}
return AttachedReferenceManager.CreateSerializableVersion(context.Descriptor.Type, guid, location);
}
public override object ConvertFrom(ref ObjectContext objectContext, Scalar fromScalar)
{
var parameterKey = ParameterKeys.FindByName(fromScalar.Value);
if (parameterKey == null)
{
parameterKey = ParameterKeys.New<object>(null, fromScalar.Value);
// Dont' throw an exception if keys was not found
//throw new YamlException(fromScalar.Start, fromScalar.End, "Unable to find registered ParameterKey [{0}]".ToFormat(fromScalar.Value));
}
return parameterKey;
}
protected override void TransformObjectAfterRead(ref ObjectContext objectContext)
{
if (!objectContext.SerializerContext.IsSerializing)
{
var settingsDictionary = (SettingsDictionary)objectContext.Instance;
var settingsProfile = settingsDictionary.Profile;
settingsProfile.Container.DecodeSettings(settingsDictionary, settingsProfile);
objectContext.Instance = settingsProfile;
}
}
protected override void TransformObjectAfterRead(ref ObjectContext objectContext)
{
if (!objectContext.SerializerContext.IsSerializing)
{
var settingsDictionary = (SettingsDictionary)objectContext.Instance;
var settingsCollection = (SettingsCollection)settingsDictionary.Tags;
settingsCollection.Profile.Group.DecodeSettings(settingsDictionary, settingsCollection.Profile);
objectContext.Instance = settingsCollection;
}
}
public override string ConvertTo(ref ObjectContext objectContext)
{
var propertyKey = (PropertyKey)objectContext.Instance;
var className = objectContext.SerializerContext.TagFromType(propertyKey.OwnerType);
var sb = new StringBuilder(className.Length + 1 + propertyKey.Name.Length);
sb.Append(className, 1, className.Length - 1); // Ignore initial '!'
sb.Append('.');
sb.Append(propertyKey.Name);
return sb.ToString();
}
protected override void WriteDictionaryItem(ref ObjectContext objectContext, KeyValuePair<object, object> keyValue, KeyValuePair<Type, Type> types)
{
var propertyKey = (UFile)keyValue.Key;
objectContext.SerializerContext.WriteYaml(propertyKey, types.Key);
// Deduce expected value type from PropertyKey
var parsingEvents = (List<ParsingEvent>)keyValue.Value;
var writer = objectContext.Writer;
foreach (var parsingEvent in parsingEvents)
{
writer.Emit(parsingEvent);
}
}
protected override void CreateOrTransformObject(ref ObjectContext objectContext)
{
var settingsProfile = (SettingsProfile)objectContext.Instance;
var settingsDictionary = new SettingsDictionary { Profile = settingsProfile };
if (objectContext.SerializerContext.IsSerializing)
{
settingsProfile.Container.EncodeSettings(settingsProfile, settingsDictionary);
}
objectContext.Instance = settingsDictionary;
base.CreateOrTransformObject(ref objectContext);
}
protected override void CreateOrTransformObject(ref ObjectContext objectContext)
{
var settingsCollection = (SettingsCollection)objectContext.Instance;
var settingsDictionary = new SettingsDictionary { Tags = settingsCollection };
if (objectContext.SerializerContext.IsSerializing)
{
settingsCollection.Profile.Group.EncodeSettings(settingsCollection.Profile, settingsDictionary);
}
objectContext.Instance = settingsDictionary;
base.CreateOrTransformObject(ref objectContext);
}
/// <inheritdoc/>
protected override void WriteCollectionItem(ref ObjectContext objectContext, object item, Type itemType)
{
// Check if we have a Yaml representation (in case loading failed)
var unloadableScript = item as UnloadableScript;
if (unloadableScript != null)
{
var writer = objectContext.Writer;
foreach (var parsingEvent in unloadableScript.ParsingEvents)
{
writer.Emit(parsingEvent);
}
return;
}
base.WriteCollectionItem(ref objectContext, item, itemType);
}
protected override void ReadAddCollectionItem(ref ObjectContext objectContext, Type elementType, CollectionDescriptor collectionDescriptor, object thisObject, int index)
{
var scriptCollection = (ScriptCollection)objectContext.Instance;
object value = null;
bool needAdd = true; // If we could get existing value, no need add to collection
if (scriptCollection.Count > index)
{
value = scriptCollection[index];
needAdd = false;
}
value = ReadCollectionItem(ref objectContext, value, elementType);
if (needAdd)
collectionDescriptor.CollectionAdd(thisObject, value);
}
/// <inheritdoc/>
protected override void TransformObjectAfterRead(ref ObjectContext objectContext)
{
if (recursionLevel >= 2)
{
// We are inside a Script
if (!objectContext.SerializerContext.IsSerializing)
{
if (objectContext.Instance is CloneReference)
{
objectContext.Instance = References[((CloneReference)objectContext.Instance).Id];
return;
}
}
}
base.TransformObjectAfterRead(ref objectContext);
}
protected override void ReadAddCollectionItem(ref ObjectContext objectContext, Type elementType, CollectionDescriptor collectionDescriptor, object thisObject, int index)
{
var scriptCollection = (EntityComponentCollection)objectContext.Instance;
EntityComponent value = null;
bool needAdd = true; // If we could get existing value, no need add to collection
if (index < scriptCollection.Count)
{
value = scriptCollection[index];
needAdd = false;
}
value = (EntityComponent)ReadCollectionItem(ref objectContext, value, elementType, index);
if (needAdd)
{
scriptCollection.Add(value);
}
}
protected override void CreateOrTransformObject(ref ObjectContext objectContext)
{
if (isSerializingAsReference)
{
// Create appropriate reference type for both serialization and deserialization
if (objectContext.SerializerContext.IsSerializing)
{
var entityComponent = objectContext.Instance as EntityComponent;
var entityScript = objectContext.Instance as Script;
if (entityComponent != null)
{
objectContext.Instance = new EntityComponentReference(entityComponent);
}
else if (entityScript != null && scriptLevel > 1)
{
var script = new EntityScriptReference(entityScript);
objectContext.Instance = script;
objectContext.Tag = objectContext.Settings.TagTypeRegistry.TagFromType(entityScript.GetType());
}
else if (objectContext.Instance is Entity)
{
objectContext.Instance = new EntityReference { Id = ((Entity)objectContext.Instance).Id };
}
}
else
{
var type = objectContext.Descriptor.Type;
if (typeof(EntityComponent).IsAssignableFrom(type))
{
objectContext.Instance = new EntityComponentReference();
}
else if (typeof(Script).IsAssignableFrom(type) && scriptLevel > 1)
{
objectContext.Instance = new EntityScriptReference { ScriptType = objectContext.Descriptor.Type };
}
else if (type == typeof(Entity))
{
objectContext.Instance = new EntityReference();
}
}
}
base.CreateOrTransformObject(ref objectContext);
}
protected override KeyValuePair<object, object> ReadDictionaryItem(ref ObjectContext objectContext, KeyValuePair<Type, Type> keyValueType)
{
// Read PropertyKey
var keyResult = (UFile)objectContext.SerializerContext.ReadYaml(null, keyValueType.Key);
// Save the Yaml stream, in case loading fails we can keep this representation
var parsingEvents = new List<ParsingEvent>();
var reader = objectContext.Reader;
var startDepth = reader.CurrentDepth;
do
{
parsingEvents.Add(reader.Expect<ParsingEvent>());
} while (reader.CurrentDepth > startDepth);
var valueResult = parsingEvents;
return new KeyValuePair<object, object>(keyResult, valueResult);
}
protected override void CreateOrTransformObject(ref ObjectContext objectContext)
{
if (recursionLevel >= recursionMaxExpectedDepth)
{
if (objectContext.SerializerContext.IsSerializing)
{
var entityComponent = objectContext.Instance as EntityComponent;
var entityScript = objectContext.Instance as Script;
if (entityComponent != null)
{
objectContext.Instance = new EntityComponentReference(entityComponent);
}
else if (entityScript != null && levelSinceScriptComponent != 1)
{
var script = new EntityScriptReference(entityScript);
objectContext.Instance = script;
objectContext.Tag = objectContext.Settings.TagTypeRegistry.TagFromType(entityScript.GetType());
}
else if (objectContext.Instance is Entity)
{
objectContext.Instance = new EntityReference { Id = ((Entity)objectContext.Instance).Id };
}
}
else
{
var type = objectContext.Descriptor.Type;
if (typeof(EntityComponent).IsAssignableFrom(type))
{
objectContext.Instance = new EntityComponentReference();
}
else if (typeof(Script).IsAssignableFrom(type) && levelSinceScriptComponent != 1)
{
objectContext.Instance = new EntityScriptReference { ScriptType = objectContext.Descriptor.Type };
}
else if (type == typeof(Entity))
{
objectContext.Instance = new EntityReference();
}
}
}
base.CreateOrTransformObject(ref objectContext);
}