/// <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);