public void Serialize(SerializationStream stream, ArchiveMode mode)
{
// Check version number (should be 0 for now, for future use)
if (mode == ArchiveMode.Serialize)
{
stream.Write(0);
}
else if (mode == ArchiveMode.Deserialize)
{
if (stream.ReadInt32() != 0)
throw new InvalidOperationException("Unexpected version number.");
}
// Serialize content
stream.Serialize(ref IsBinary);
if (IsBinary)
{
stream.Serialize(ref BinaryFormat);
stream.Serialize(ref Binary, mode);
}
else
{
stream.Serialize(ref Profile);
stream.Serialize(ref EntryPoint);
stream.Serialize(ref Source);
}
}
/// <inheritdoc/> public abstract void PreSerialize(ref object obj, ArchiveMode mode, SerializationStream stream);
/// <inheritdoc/> public abstract void PreSerialize(ref object obj, ArchiveMode mode, SerializationStream stream);
public static void Write <T>([NotNull] this SerializationStream stream, T obj)
{
Serialize(stream, ref obj, ArchiveMode.Serialize);
}
public static void SerializeExtended <T>([NotNull] this SerializationStream stream, ref T obj, ArchiveMode mode, DataSerializer <T> dataSerializer = null)
{
MemberReuseSerializer <T> .SerializeExtended(ref obj, mode, stream, dataSerializer);
}
public static SerializationStream Write([NotNull] this SerializationStream stream, byte[] values, int offset, int count)
{
stream.Serialize(values, offset, count);
return(stream);
}
public static SerializationStream Write([NotNull] this SerializationStream stream, sbyte value)
{
stream.Serialize(ref value);
return(stream);
}
/// <summary> /// Serializes or deserializes the given object <paramref name="obj"/>. /// </summary> /// <param name="obj">The object to serialize or deserialize.</param> /// <param name="mode">The serialization mode.</param> /// <param name="stream">The stream to serialize or deserialize to.</param> public abstract void Serialize(ref object obj, ArchiveMode mode, [NotNull] SerializationStream stream);
public static SerializationStream Write(this SerializationStream stream, char value)
{
stream.Serialize(ref value);
return(stream);
}
public static byte[] ReadBytes(this SerializationStream stream, int count)
{
byte[] value = new byte[count];
stream.Serialize(value, 0, count);
return(value);
}
public override void Serialize(ref T obj, ArchiveMode mode, SerializationStream stream)
{
var referenceSerialization = stream.Context.Get(ContentSerializerContext.SerializeAttachedReferenceProperty);
var contentSerializerContext = stream.Context.Get(ContentSerializerContext.ContentSerializerContextProperty);
if (contentSerializerContext != null)
{
if (mode == ArchiveMode.Serialize)
{
var contentReference = new ContentReference <T> {
Value = obj
};
int index = contentSerializerContext.AddContentReference(contentReference);
stream.Write(index);
}
else
{
int index = stream.ReadInt32();
var contentReference = contentSerializerContext.GetContentReference <T>(index);
obj = contentReference.Value;
if (obj == null)
{
// Check if already deserialized
var assetReference = contentSerializerContext.AssetManager.FindDeserializedObject(contentReference.Location, typeof(T));
if (assetReference != null)
{
obj = (T)assetReference.Object;
if (obj != null)
{
contentReference.Value = obj;
}
}
}
if (obj == null && contentSerializerContext.LoadContentReferences)
{
var contentSerializer = cachedContentSerializer ?? (cachedContentSerializer = contentSerializerContext.AssetManager.Serializer.GetSerializer(null, typeof(T)));
if (contentSerializer == null)
{
// Need to read chunk header to know actual type (note that we can't cache it in cachedContentSerializer as it depends on content)
var chunkHeader = contentSerializerContext.AssetManager.ReadChunkHeader(contentReference.Location);
if (chunkHeader == null || (contentSerializer = contentSerializerContext.AssetManager.Serializer.GetSerializer(AssemblyRegistry.GetType(chunkHeader.Type), typeof(T))) == null)
{
throw new InvalidOperationException(string.Format("Could not find a valid content serializer for {0} when loading {1}", typeof(T), contentReference.Location));
}
}
// First time, let's create it
obj = (T)contentSerializer.Construct(contentSerializerContext);
contentSerializerContext.AssetManager.RegisterDeserializedObject(contentReference.Location, obj);
contentReference.Value = obj;
}
}
}
else if (referenceSerialization == ContentSerializerContext.AttachedReferenceSerialization.AsNull)
{
if (mode == ArchiveMode.Deserialize)
{
obj = default(T);
}
}
else if (referenceSerialization == ContentSerializerContext.AttachedReferenceSerialization.AsSerializableVersion)
{
if (mode == ArchiveMode.Serialize)
{
// This case will happen when serializing build engine command hashes: we still want Location to still be written
var attachedReference = AttachedReferenceManager.GetAttachedReference(obj);
if (attachedReference == null || attachedReference.Url == null)
{
throw new InvalidOperationException("Error when serializing reference.");
}
// TODO: Do not use string
stream.Write(obj.GetType().AssemblyQualifiedName);
stream.Write(attachedReference.Id);
stream.Write(attachedReference.Url);
}
else
{
var type = AssemblyRegistry.GetType(stream.ReadString());
var id = stream.Read <Guid>();
var url = stream.ReadString();
obj = (T)AttachedReferenceManager.CreateSerializableVersion(type, id, url);
}
}
else
{
// This case will happen when serializing build engine command hashes: we still want Location to still be written
if (mode == ArchiveMode.Serialize)
{
// This case will happen when serializing build engine command hashes: we still want Location to still be written
var attachedReference = AttachedReferenceManager.GetAttachedReference(obj);
if (attachedReference == null || attachedReference.Url == null)
{
throw new InvalidOperationException("Error when serializing reference.");
}
stream.Write(attachedReference.Url);
}
else
{
// No real case yet
throw new NotSupportedException();
}
}
}
public override void Serialize(ref ContentReference <T> contentReference, ArchiveMode mode, SerializationStream stream)
{
var contentSerializerContext = stream.Context.Get(ContentSerializerContext.ContentSerializerContextProperty);
if (contentSerializerContext != null)
{
if (mode == ArchiveMode.Serialize)
{
int index = contentSerializerContext.AddContentReference(contentReference);
stream.Write(index);
}
else
{
int index = stream.ReadInt32();
contentReference = contentSerializerContext.GetContentReference <T>(index);
}
}
else
{
// This case will happen when serializing build engine command hashes: we still want Location to still be written
if (mode == ArchiveMode.Serialize)
{
{
// This case will happen when serializing build engine command hashes: we still want Location to still be written
stream.Write(contentReference.Location);
}
}
else
{
// No real case yet
throw new NotSupportedException();
}
}
}
public override void Serialize(ref T obj, ArchiveMode mode, SerializationStream stream)
{
var referenceSerialization = stream.Context.Get(ContentSerializerContext.SerializeAttachedReferenceProperty);
var contentSerializerContext = stream.Context.Get(ContentSerializerContext.ContentSerializerContextProperty);
if (contentSerializerContext != null)
{
if (mode == ArchiveMode.Serialize)
{
var contentReference = new ContentReference <T> {
Value = obj
};
int index = contentSerializerContext.AddContentReference(contentReference);
stream.Write(index);
}
else
{
int index = stream.ReadInt32();
var contentReference = contentSerializerContext.GetContentReference <T>(index);
obj = contentReference.Value;
if (obj == null)
{
// Check if already deserialized
var assetReference = contentSerializerContext.AssetManager.FindDeserializedObject(contentReference.Location, typeof(T));
if (assetReference != null)
{
obj = (T)assetReference.Object;
if (obj != null)
{
contentReference.Value = obj;
}
}
}
if (obj == null)
{
// First time, let's create it
obj = (T)AttachedReferenceManager.CreateSerializableVersion(typeof(T), contentReference.Id, contentReference.Location);
contentSerializerContext.AssetManager.RegisterDeserializedObject(contentReference.Location, obj);
contentReference.Value = obj;
}
}
}
else if (referenceSerialization == ContentSerializerContext.AttachedReferenceSerialization.AsNull)
{
if (mode == ArchiveMode.Deserialize)
{
obj = default(T);
}
}
else if (referenceSerialization == ContentSerializerContext.AttachedReferenceSerialization.AsSerializableVersion)
{
if (mode == ArchiveMode.Serialize)
{
// This case will happen when serializing build engine command hashes: we still want Location to still be written
var attachedReference = AttachedReferenceManager.GetAttachedReference(obj);
if (attachedReference == null || attachedReference.Url == null)
{
throw new InvalidOperationException("Error when serializing reference.");
}
// TODO: Do not use string
stream.Write(obj.GetType().AssemblyQualifiedName);
stream.Write(attachedReference.Id);
stream.Write(attachedReference.Url);
}
else
{
var type = Type.GetType(stream.ReadString());
var id = stream.Read <Guid>();
var url = stream.ReadString();
obj = (T)AttachedReferenceManager.CreateSerializableVersion(type, id, url);
}
}
else
{
// This case will happen when serializing build engine command hashes: we still want Location to still be written
if (mode == ArchiveMode.Serialize)
{
// This case will happen when serializing build engine command hashes: we still want Location to still be written
var attachedReference = AttachedReferenceManager.GetAttachedReference(obj);
if (attachedReference == null || attachedReference.Url == null)
{
throw new InvalidOperationException("Error when serializing reference.");
}
stream.Write(attachedReference.Url);
}
else
{
// No real case yet
throw new NotSupportedException();
}
}
}
