public static bool DeserializeGZippedXML <T>(Stream reader, out T objectBuilder) where T : MyObjectBuilder_Base
{
objectBuilder = null;
try
{
using (GZipStream gz = new GZipStream(reader, CompressionMode.Decompress))
using (BufferedStream buffer = new BufferedStream(gz, 0x8000))
{
XmlSerializer serializer = MyXmlSerializerManager.GetSerializer(typeof(T));
objectBuilder = (T)serializer.Deserialize(buffer);
}
}
catch (Exception e)
{
MyLog.Default.WriteLine("ERROR: Exception during objectbuilder read! (xml): " + typeof(T).Name);
MyLog.Default.WriteLine(e);
if (Debugger.IsAttached)
{
Debugger.Break();
}
return(false);
}
return(true);
}
/// <summary>
/// Initalize the registry with all the defautl game assemblies.
/// </summary>
public void Init()
{
if (m_ready)
{
return;
}
#if XB1 // XB1_ALLINONEASSEMBLY
RegisterAssembly(MyAssembly.AllInOneAssembly);
#else // !XB1
MyXmlSerializerManager.RegisterSerializableBaseType(typeof(MyObjectBuilder_Base));
RegisterAssembly(GetType().Assembly); // VRage.Game
RegisterAssembly(MyPlugins.GameAssembly);
RegisterAssembly(MyPlugins.SandboxGameAssembly);
RegisterAssembly(MyPlugins.SandboxAssembly);
RegisterAssembly(MyPlugins.UserAssembly);
RegisterAssembly(MyPlugins.GameBaseObjectBuildersAssembly);
RegisterAssembly(MyPlugins.GameObjectBuildersAssembly);
foreach (var plugin in MyPlugins.Plugins)
{
RegisterAssembly(plugin.GetType().Assembly);
}
#endif // !XB1
MyObjectBuilderSerializer.LoadSerializers();
m_ready = true;
}
/// <param name="typeOverrideMap">Allows override of the type of the definition. Refer to MyDefinitionXmlSerializer</param>
internal static bool DeserializeXML(Stream reader, out MyObjectBuilder_Base objectBuilder, Type builderType, Dictionary <string, string> typeOverrideMap)
{
Debug.Assert(typeof(MyObjectBuilder_Base).IsAssignableFrom(builderType));
Debug.Assert(reader != null);
Debug.Assert(builderType != null);
objectBuilder = null;
try
{
XmlSerializer serializer = MyXmlSerializerManager.GetSerializer(builderType);
Debug.Assert(serializer != null);
XmlReaderSettings settings = new XmlReaderSettings()
{
CheckCharacters = true
};
MyXmlTextReader xmlReader = new MyXmlTextReader(reader, settings);
xmlReader.DefinitionTypeOverrideMap = typeOverrideMap;
objectBuilder = (MyObjectBuilder_Base)serializer.Deserialize(xmlReader);
}
catch (Exception e)
{
MyLog.Default.WriteLine("ERROR: Exception during objectbuilder read! (xml): " + builderType.Name);
MyLog.Default.WriteLine(e);
//if (Debugger.IsAttached)
// Debugger.Break();
return(false);
}
return(true);
}
/// <summary>
/// Register an assembly and it's types metadata.
/// </summary>
/// <param name="assembly">Assembly to register.</param>
public void RegisterAssembly(Assembly assembly)
{
if (assembly == null)
{
return;
}
#if !XB1 // XB1_ALLINONEASSEMBLY
m_assemblies.Add(assembly);
#endif // !XB1
MyObjectBuilderSerializer.RegisterFromAssembly(assembly);
MyObjectBuilderType.RegisterFromAssembly(assembly, true);
MyXmlSerializerManager.RegisterFromAssembly(assembly);
MyDefinitionManagerBase.RegisterTypesFromAssembly(assembly);
}
public static bool SerializeXML(string path, bool compress, MyObjectBuilder_Base objectBuilder, out ulong sizeInBytes, Type serializeAsType = null)
{
try
{
using (var fileStream = MyFileSystem.OpenWrite(path))
using (var writeStream = compress ? fileStream.WrapGZip() : fileStream)
{
long startPos = fileStream.Position;
XmlSerializer serializer = MyXmlSerializerManager.GetSerializer(serializeAsType ?? objectBuilder.GetType());
serializer.Serialize(writeStream, objectBuilder);
sizeInBytes = (ulong)(fileStream.Position - startPos); // Length of compressed stream
}
}
catch (Exception e)
{
MyLog.Default.WriteLine("Error: " + path + " failed to serialize.");
MyLog.Default.WriteLine(e.ToString());
#if !XB1
#if DEBUG
var io = e as IOException;
if (io != null && io.IsFileLocked())
{
MyLog.Default.WriteLine("Files is locked during saving.");
MyLog.Default.WriteLine("Xml file locks:");
try
{
foreach (var p in Win32Processes.GetProcessesLockingFile(path))
{
MyLog.Default.WriteLine(p.ProcessName);
}
}
catch (Exception e2)
{
MyLog.Default.WriteLine(e2);
}
}
#endif
#endif // !XB1
sizeInBytes = 0;
return(false);
}
return(true);
}
/// <summary>
/// Replacement for MyObjectBuilderSerializer that lets you set compression level.
/// </summary>
/// <param name="writeTo"></param>
/// <param name="obj"></param>
/// <param name="level"></param>
/// <param name="bufferSize"></param>
private static void SerializeZipped(Stream writeTo, MyObjectBuilder_Base obj, CompressionLevel level, int bufferSize = 0x8000)
{
var ms = new MemoryStream(bufferSize);
Stopwatch stopwatch = Stopwatch.StartNew();
XmlSerializer serializer = MyXmlSerializerManager.GetSerializer(obj.GetType());
serializer.Serialize(ms, obj);
stopwatch.Stop();
Log.Info($"Serialization took {stopwatch.Elapsed.TotalMilliseconds}ms");
ms.Position = 0;
Log.Info($"Wrote {Utilities.FormatDataSize(ms.Length)}");
_lastSize = Math.Max(_lastSize, (int)ms.Length);
stopwatch.Restart();
using (var gz = new GZipStream(writeTo, level))
{
ms.CopyTo(gz);
}
stopwatch.Stop();
Log.Info($"Compression took {stopwatch.Elapsed.TotalMilliseconds}ms");
ms.Close();
}
/// <returns>True if it sucessfully deserialized the file.</returns>
public static bool DeserializeXml <T>(string filename, out T objectBuilder, out string errorInformation) where T : MyObjectBuilder_Base
{
bool result = false;
objectBuilder = null;
errorInformation = null;
using (var fileStream = MyFileSystem.OpenRead(filename))
{
if (fileStream != null)
{
using (var readStream = fileStream.UnwrapGZip())
{
if (readStream != null)
{
try
{
XmlSerializer serializer = MyXmlSerializerManager.GetSerializer(typeof(T));
XmlReaderSettings settings = new XmlReaderSettings {
CheckCharacters = true
};
MyXmlTextReader xmlReader = new MyXmlTextReader(readStream, settings);
objectBuilder = (T)serializer.Deserialize(xmlReader);
result = true;
}
catch (Exception ex)
{
objectBuilder = null;
errorInformation = $@"Failed to load file: {filename}
Reason: {ex.AllMessages()}";
}
}
}
}
}
return(result);
}
private static void SerializeXMLInternal(Stream writeTo, MyObjectBuilder_Base objectBuilder, Type serializeAsType = null)
{
XmlSerializer serializer = MyXmlSerializerManager.GetSerializer(serializeAsType ?? objectBuilder.GetType());
serializer.Serialize(writeTo, objectBuilder);
}
public void Serialize(BitStream stream)
{
stream.WriteBool(false);
var builder = Grid.GetObjectBuilder();
try
{
VRage.Serialization.MySerializer.Write(stream, ref builder, MyObjectBuilderSerializer.Dynamic);
}
catch (Exception e)
{
XmlSerializer serializer = MyXmlSerializerManager.GetSerializer(builder.GetType());
MyLog.Default.WriteLine("Grid data - START");
try
{
serializer.Serialize(MyLog.Default.GetTextWriter(), builder);
}
catch
{
MyLog.Default.WriteLine("Failed");
}
MyLog.Default.WriteLine("Grid data - END");
throw;
}
var g = MyCubeGridGroups.Static.PhysicalDynamic.GetGroup(Grid);
if (g == null || MyFakes.ENABLE_SENT_GROUP_AT_ONCE == false)
{
stream.WriteByte(0);
}
else
{
m_groups.Clear();
foreach (var node in g.Nodes)
{
var target = MyMultiplayer.Static.ReplicationLayer.GetProxyTarget((IMyEventProxy)node.NodeData);
if (node.NodeData != Grid && !node.NodeData.IsStatic && target != null)
{
m_groups.Add(node.NodeData);
}
}
stream.WriteByte((byte)m_groups.Count); // Ignoring self
foreach (var node in m_groups)
{
builder = node.GetObjectBuilder();
try
{
VRage.Serialization.MySerializer.Write(stream, ref builder, MyObjectBuilderSerializer.Dynamic);
}
catch (Exception e)
{
XmlSerializer serializer = MyXmlSerializerManager.GetSerializer(builder.GetType());
MyLog.Default.WriteLine("Grid data - START");
try
{
serializer.Serialize(MyLog.Default.GetTextWriter(), builder);
}
catch
{
MyLog.Default.WriteLine("Failed");
}
MyLog.Default.WriteLine("Grid data - END");
throw;
}
}
}
}
