/// <inheritdoc/>
public override void Initialize(SerializerSelector serializerSelector)
{
// Key should never be null
keySerializer = MemberSerializer <TKey> .Create(serializerSelector, false);
valueSerializer = MemberSerializer <TValue> .Create(serializerSelector);
}
/// <inheritdoc/>
public void EnumerateGenericInstantiations(SerializerSelector serializerSelector, [NotNull] IList <Type> genericInstantiations)
{
genericInstantiations.Add(typeof(T));
// Force concrete type to be implemented (that's what will likely be used with this interface)
genericInstantiations.Add(typeof(List <T>));
}
public void EnumerateGenericInstantiations(SerializerSelector serializerSelector, IList <Type> genericInstantiations)
{
genericInstantiations.Add(typeof(TKey));
genericInstantiations.Add(typeof(TValue));
// Force concrete type to be implemented (that's what will likely be used with this interface)
genericInstantiations.Add(typeof(Dictionary <TKey, TValue>));
}
/// <inheritdoc/>
public override void Initialize(SerializerSelector serializerSelector)
{
guidSerializer = MemberSerializer <Guid> .Create(serializerSelector);
stringSerializer = MemberSerializer <string> .Create(serializerSelector);
componentCollectionSerializer = MemberSerializer <EntityComponentCollection> .Create(serializerSelector);
}
public override void Initialize(SerializerSelector serializerSelector)
{
parentSerializer = SerializerSelector.Default.GetSerializer <SpriteFont>();
if (parentSerializer == null)
{
throw new InvalidOperationException(string.Format("Could not find parent serializer for type {0}", "SiliconStudio.Xenko.Graphics.SpriteFont"));
}
}
static AssetCloner()
{
ClonerSelector = new SerializerSelector();
ClonerSelector.RegisterProfile("Default");
ClonerSelector.RegisterProfile("Asset");
ClonerSelector.RegisterProfile("AssetClone");
ClonerSelector.ReuseReferences = true;
}
/// <inheritdoc/>
public void Initialize(SerializerSelector serializerSelector)
{
guidSerializer = MemberSerializer <Guid> .Create(serializerSelector);
stringSerializer = MemberSerializer <string> .Create(serializerSelector);
entityGroupSerializer = MemberSerializer <EntityGroup> .Create(serializerSelector);
componentCollectionSerializer = serializerSelector.GetSerializer <EntityComponentCollection>();
}
public override void Initialize(SerializerSelector serializerSelector)
{
// We should use serializerSelector, but DataContentSerializerHelper we might have wrong context; make sure parent is resolved through proper context
// (maybe we should have separate contexts for parent and members?)
parentSerializer = SerializerSelector.Default.GetSerializer <SpriteFont>();
if (parentSerializer == null)
{
throw new InvalidOperationException(string.Format("Could not find parent serializer for type {0}", "Stride.Graphics.SpriteFont"));
}
}
public override void Initialize(SerializerSelector serializerSelector)
{
// Get parent serializer
parentSerializer = serializerSelector.GetSerializer <SiliconStudio.Xenko.Engine.AsyncScript>();
if (parentSerializer == null)
{
throw new InvalidOperationException(string.Format("Could not find parent serializer for type {0}", @"SiliconStudio.Xenko.Engine.AsyncScript"));
}
// Cache member serializers
}
/// <summary>
/// Clones the specified object, taking special care of <see cref="Entity"/>, <see cref="EntityComponent"/> and external assets.
/// User can optionally provides list of cloned objects (list of data reference objects that should be cloned)
/// and mapped objects (list of data reference objects that should be ducplicated using the given instance).
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="clonedObjects">The cloned objects.</param>
/// <param name="mappedObjects">The mapped objects.</param>
/// <param name="entity">The entity.</param>
/// <returns></returns>
private static T Clone <T>(HashSet <object> clonedObjects, TryGetValueFunction <object, object> mappedObjects, T entity) where T : class
{
if (cloneSerializerSelector == null)
{
cloneSerializerSelector = new SerializerSelector();
cloneSerializerSelector.ReuseReferences = true;
cloneSerializerSelector
.RegisterProfile("Default")
.RegisterProfile("Clone")
.RegisterSerializer(new EntitySerializer())
.RegisterSerializer(new CloneSerializer <string>())
.RegisterSerializer(new CloneSerializer <Effect>())
.RegisterSerializer(new CloneSerializer <Mesh>())
.RegisterSerializer(new CloneSerializer <Model>())
.RegisterSerializer(new CloneSerializer <AnimationClip>());
}
// Initialize CloneContext
lock (cloneContext)
{
try
{
cloneContext.EntitySerializerSelector = cloneSerializerSelector;
cloneContext.ClonedObjects = clonedObjects;
cloneContext.MappedObjects = mappedObjects;
// Serialize
var memoryStream = cloneContext.MemoryStream;
var writer = new BinarySerializationWriter(memoryStream);
writer.Context.SerializerSelector = cloneSerializerSelector;
writer.Context.Set(CloneContextProperty, cloneContext);
writer.SerializeExtended(entity, ArchiveMode.Serialize, null);
// Deserialization reuses this list and expect it to be empty at the beginning.
cloneContext.SerializedObjects.Clear();
// Deserialize
T result = null;
memoryStream.Seek(0, SeekOrigin.Begin);
var reader = new BinarySerializationReader(memoryStream);
reader.Context.SerializerSelector = cloneSerializerSelector;
reader.Context.Set(CloneContextProperty, cloneContext);
reader.SerializeExtended(ref result, ArchiveMode.Deserialize, null);
return(result);
}
finally
{
cloneContext.Cleanup();
}
}
}
public override void Initialize(SerializerSelector serializerSelector)
{
// Get parent serializer
parentSerializer = serializerSelector.GetSerializer <SiliconStudio.Xenko.Engine.AsyncScript>();
if (parentSerializer == null)
{
throw new InvalidOperationException(string.Format("Could not find parent serializer for type {0}", @"SiliconStudio.Xenko.Engine.AsyncScript"));
}
// Cache member serializers
staffSerializer = MemberSerializer <System.Collections.Generic.List <Strategy.Government_Staff_Person> > .Create(serializerSelector);
leaderSerializer = MemberSerializer <Strategy.Government_Staff_Person> .Create(serializerSelector);
}
public override void Initialize(SerializerSelector serializerSelector)
{
// Get parent serializer
parentSerializer = serializerSelector.GetSerializer <SiliconStudio.Xenko.Engine.AsyncScript>();
if (parentSerializer == null)
{
throw new InvalidOperationException(string.Format("Could not find parent serializer for type {0}", @"SiliconStudio.Xenko.Engine.AsyncScript"));
}
// Cache member serializers
populationsSerializer = MemberSerializer <System.Collections.Generic.Dictionary <System.Int32, System.Int32> > .Create(serializerSelector);
classificationSerializer = MemberSerializer <System.Int32> .Create(serializerSelector);
}
public override void Initialize(SerializerSelector serializerSelector)
{
// Get parent serializer
parentSerializer = serializerSelector.GetSerializer <SiliconStudio.Xenko.Engine.AsyncScript>();
if (parentSerializer == null)
{
throw new InvalidOperationException(string.Format("Could not find parent serializer for type {0}", @"SiliconStudio.Xenko.Engine.AsyncScript"));
}
// Cache member serializers
nameSerializer = MemberSerializer <System.String> .Create(serializerSelector);
religionSerializer = MemberSerializer <Strategy.Religion> .Create(serializerSelector);
believerSerializer = MemberSerializer <Strategy.Believe> .Create(serializerSelector);
}
public override void Initialize(SerializerSelector serializerSelector)
{
// Get parent serializer
parentSerializer = serializerSelector.GetSerializer <SiliconStudio.Xenko.Engine.SyncScript>();
if (parentSerializer == null)
{
throw new InvalidOperationException(string.Format("Could not find parent serializer for type {0}", @"SiliconStudio.Xenko.Engine.SyncScript"));
}
// Cache member serializers
KeyboardMovementSpeedSerializer = MemberSerializer <SiliconStudio.Core.Mathematics.Vector3> .Create(serializerSelector);
SpeedFactorSerializer = MemberSerializer <System.Single> .Create(serializerSelector);
KeyboardRotationSpeedSerializer = MemberSerializer <SiliconStudio.Core.Mathematics.Vector2> .Create(serializerSelector);
}
public override DataSerializer GetSerializer(SerializerSelector selector, Type type)
{
DataSerializer dataSerializer;
if (!serializersByType.TryGetValue(type, out dataSerializer))
{
if (baseType.GetTypeInfo().IsAssignableFrom(type.GetTypeInfo()))
{
dataSerializer = (DataSerializer)Activator.CreateInstance(serializerGenericType.MakeGenericType(type));
selector.EnsureInitialized(dataSerializer);
serializersByTypeId.TryAdd(dataSerializer.SerializationTypeId, dataSerializer);
}
// Add it even if null (so that failures are cached too)
serializersByType.TryAdd(type, dataSerializer);
}
return dataSerializer;
}
protected override YardarmTypeInfo GetTypeInfo()
{
SerializerDescriptor?serializerDescriptor = SerializerSelector.Select(Element)?.Descriptor;
if (serializerDescriptor == null)
{
throw new InvalidOperationException($"No serializer configured for {Element}.");
}
INameFormatter formatter = Context.NameFormatterSelector.GetFormatter(NameKind.Class);
NameSyntax ns = Context.NamespaceProvider.GetNamespace(RequestTypeGenerator.Element);
TypeSyntax name = QualifiedName(ns,
IdentifierName(formatter.Format($"{RequestTypeGenerator.Element.Element.OperationId}-{serializerDescriptor.NameSegment}-Request")));
return(new YardarmTypeInfo(name));
}
public override void Initialize(SerializerSelector serializerSelector)
{
// Get parent serializer
parentSerializer = serializerSelector.GetSerializer <SiliconStudio.Xenko.Engine.AsyncScript>();
if (parentSerializer == null)
{
throw new InvalidOperationException(string.Format("Could not find parent serializer for type {0}", @"SiliconStudio.Xenko.Engine.AsyncScript"));
}
// Cache member serializers
country_nameSerializer = MemberSerializer <System.String> .Create(serializerSelector);
country_idSerializer = MemberSerializer <System.Int32> .Create(serializerSelector);
statesSerializer = MemberSerializer <System.Collections.Generic.List <System.Int32> > .Create(serializerSelector);
populationsSerializer = MemberSerializer <System.Collections.Generic.Dictionary <Strategy.Population, System.Int32> > .Create(serializerSelector);
governmentSerializer = MemberSerializer <Strategy.Government> .Create(serializerSelector);
}
public override void Initialize(SerializerSelector serializerSelector)
{
// Get parent serializer
parentSerializer = serializerSelector.GetSerializer <SiliconStudio.Xenko.Engine.StartupScript>();
if (parentSerializer == null)
{
throw new InvalidOperationException(string.Format("Could not find parent serializer for type {0}", @"SiliconStudio.Xenko.Engine.StartupScript"));
}
// Cache member serializers
populationsSerializer = MemberSerializer <System.Collections.Generic.Dictionary <System.Int32, Strategy.Population> > .Create(serializerSelector);
countriesSerializer = MemberSerializer <System.Collections.Generic.Dictionary <System.Int32, Strategy.Country> > .Create(serializerSelector);
believesSerializer = MemberSerializer <System.Collections.Generic.Dictionary <System.Int32, Strategy.Believe> > .Create(serializerSelector);
statesSerializer = MemberSerializer <System.Collections.Generic.Dictionary <System.Int32, Strategy.State> > .Create(serializerSelector);
provincesSerializer = MemberSerializer <System.Collections.Generic.Dictionary <System.Int32, Strategy.Province> > .Create(serializerSelector);
}
private static T Clone <T>(HashSet <object> clonedObjects, T entity) where T : class
{
if (cloneSerializerSelector == null)
{
cloneSerializerSelector = new SerializerSelector(true, "Default", "Clone");
}
// Initialize CloneContext
lock (CloneContext)
{
try
{
CloneContext.EntitySerializerSelector = cloneSerializerSelector;
CloneContext.ClonedObjects = clonedObjects;
// Serialize
var memoryStream = CloneContext.MemoryStream;
var writer = new BinarySerializationWriter(memoryStream);
writer.Context.SerializerSelector = cloneSerializerSelector;
writer.Context.Set(EntityCloner.CloneContextProperty, CloneContext);
writer.SerializeExtended(entity, ArchiveMode.Serialize);
// Deserialization reuses this list and expect it to be empty at the beginning.
CloneContext.SerializedObjects.Clear();
// Deserialize
T result = null;
memoryStream.Seek(0, SeekOrigin.Begin);
var reader = new BinarySerializationReader(memoryStream);
reader.Context.SerializerSelector = cloneSerializerSelector;
reader.Context.Set(EntityCloner.CloneContextProperty, CloneContext);
reader.SerializeExtended(ref result, ArchiveMode.Deserialize);
return(result);
}
finally
{
CloneContext.Cleanup();
}
}
}
/// <inheritdoc/>
public override void Initialize(SerializerSelector serializerSelector)
{
guidSerializer = MemberSerializer <Guid> .Create(serializerSelector);
}
static ParameterContainerExtensions()
{
DefaultSceneSerializerSelector = new SerializerSelector("Default", "Asset");
}
public override void Initialize(SerializerSelector serializerSelector)
{
parameterKeySerializer = serializerSelector.GetSerializer <ParameterKey>();
}
/// <inheritdoc/>
public override void Initialize(SerializerSelector serializerSelector)
{
itemSerializer = serializerSelector.GetSerializer <T>();
}
/// <inheritdoc/>
public override void Initialize(SerializerSelector serializerSelector)
{
itemDataSerializer = serializerSelector.GetSerializer <KeyValuePair <string, IComputeColorParameter> >();
}
/// <inheritdoc/>
public void EnumerateGenericInstantiations(SerializerSelector serializerSelector, IList <Type> genericInstantiations)
{
genericInstantiations.Add(typeof(T));
}
public override void Initialize(SerializerSelector serializerSelector)
{
pointSerializer = MemberSerializer <Vector3> .Create(serializerSelector);
}
public override void Initialize(SerializerSelector serializerSelector)
{
parentSerializer = serializerSelector.GetSerializer(typeof(T).BaseType);
}
static ParameterContainerExtensions()
{
DefaultSceneSerializerSelector = new SerializerSelector("Default", "Content");
}
/// <summary>
/// Initializes the specified serializer.
/// </summary>
/// <remarks>This method should be thread-safe and OK to call multiple times.</remarks>
/// <param name="serializerSelector">The serializer.</param>
public virtual void Initialize(SerializerSelector serializerSelector)
{
}
/// <inheritdoc/>
public override void Initialize(SerializerSelector serializerSelector)
{
itemDataSerializer = MemberSerializer <T> .Create(serializerSelector);
}
static AssetCloner()
{
ClonerSelector = new SerializerSelector(true, "Default", "Asset", "AssetClone");
}
/// <inheritdoc/>
public void EnumerateGenericInstantiations(SerializerSelector serializerSelector, [NotNull] IList <Type> genericInstantiations)
{
genericInstantiations.Add(typeof(TKey));
genericInstantiations.Add(typeof(TValue));
}
static ParameterContainerExtensions()
{
DefaultSceneSerializerSelector = new SerializerSelector()
.RegisterProfile("Default")
.RegisterProfile("Asset");
}
public void EnumerateGenericInstantiations(SerializerSelector serializerSelector, IList <Type> genericInstantiations)
{
genericInstantiations.Add(typeof(KeyValuePair <string, IComputeColorParameter>));
}
public override DataSerializer GetSerializer(SerializerSelector selector, ref ObjectId typeId)
{
DataSerializer dataSerializer;
serializersByTypeId.TryGetValue(typeId, out dataSerializer);
return dataSerializer;
}
static AssetCloner()
{
ClonerSelector = new SerializerSelector(true, true, "Default", "Content", "AssetClone");
ClonerSelector.SerializerFactories.Add(new GenericSerializerFactory(typeof(IUnloadable), typeof(UnloadableCloneSerializer <>)));
}
public abstract DataSerializer GetSerializer(SerializerSelector selector, ref ObjectId typeId);
public AssetSerializer()
{
LowLevelSerializerSelector = SerializerSelector.Asset;
LowLevelSerializerSelectorWithReuse = SerializerSelector.AssetWithReuse;
}
public abstract DataSerializer GetSerializer(SerializerSelector selector, Type type);
