public void SaveTo(SaveEntryFolder parentFolder, IArchiveContext archiveContext)
{
int entryCount = this._containerType == ContainerType.Dictionary ? this._elementCount * 2 : this._elementCount;
SaveEntryFolder folder = archiveContext.CreateFolder(parentFolder, new FolderId(this.ObjectId, SaveFolderExtension.Container), entryCount);
for (int id = 0; id < this._elementCount; ++id)
{
ElementSaveData elementSaveData = this._values[id];
BinaryWriter binaryWriter1 = BinaryWriterFactory.GetBinaryWriter();
BinaryWriter binaryWriter2 = binaryWriter1;
elementSaveData.SaveTo((IWriter)binaryWriter2);
folder.CreateEntry(new EntryId(id, SaveEntryExtension.Value)).FillFrom(binaryWriter1);
BinaryWriterFactory.ReleaseBinaryWriter(binaryWriter1);
if (this._containerType == ContainerType.Dictionary)
{
ElementSaveData key = this._keys[id];
BinaryWriter binaryWriter3 = BinaryWriterFactory.GetBinaryWriter();
BinaryWriter binaryWriter4 = binaryWriter3;
key.SaveTo((IWriter)binaryWriter4);
folder.CreateEntry(new EntryId(id, SaveEntryExtension.Key)).FillFrom(binaryWriter3);
BinaryWriterFactory.ReleaseBinaryWriter(binaryWriter3);
}
}
foreach (ObjectSaveData childStruct in this._childStructs)
{
childStruct.SaveTo(folder, archiveContext);
}
}
private void SaveSingleContainer(
ArchiveConcurrentSerializer headerSerializer,
byte[][] containerData,
int id)
{
object childContainer = this._childContainers[id];
ArchiveSerializer archiveSerializer = new ArchiveSerializer();
SaveEntryFolder rootFolder1 = SaveEntryFolder.CreateRootFolder();
SaveEntryFolder rootFolder2 = SaveEntryFolder.CreateRootFolder();
ContainerType containerType;
childContainer.GetType().IsContainer(out containerType);
ContainerSaveData containerSaveData = new ContainerSaveData((ISaveContext)this, id, childContainer, containerType);
containerSaveData.CollectChildren();
containerSaveData.CollectStructs();
containerSaveData.CollectMembers();
containerSaveData.CollectStrings();
containerSaveData.SaveHeaderTo(rootFolder2, (IArchiveContext)headerSerializer);
containerSaveData.SaveTo(rootFolder1, (IArchiveContext)archiveSerializer);
headerSerializer.SerializeFolderConcurrent(rootFolder2);
archiveSerializer.SerializeFolder(rootFolder1);
byte[] binaryData = archiveSerializer.FinalizeAndGetBinaryData();
containerData[id] = binaryData;
}
private static void SaveStringTo(SaveEntryFolder stringsFolder, int id, string value)
{
BinaryWriter binaryWriter = BinaryWriterFactory.GetBinaryWriter();
binaryWriter.WriteString(value);
stringsFolder.CreateEntry(new EntryId(id, SaveEntryExtension.Txt)).FillFrom(binaryWriter);
BinaryWriterFactory.ReleaseBinaryWriter(binaryWriter);
}
public void InitialieReaders(SaveEntryFolder saveEntryFolder)
{
BinaryReader binaryReader = saveEntryFolder.GetEntry(new EntryId(-1, SaveEntryExtension.Basics)).GetBinaryReader();
this._saveId = SaveId.ReadSaveIdFrom((IReader)binaryReader);
this.PropertyCount = (int)binaryReader.ReadShort();
this.ChildStructCount = (int)binaryReader.ReadShort();
}
public void InitialieReaders(SaveEntryFolder saveEntryFolder)
{
BinaryReader binaryReader = saveEntryFolder.GetEntry(new EntryId(-1, SaveEntryExtension.Object)).GetBinaryReader();
this.SaveId = SaveId.ReadSaveIdFrom((IReader)binaryReader);
this.ContainerType = (ContainerType)binaryReader.ReadByte();
this.ElementCount = binaryReader.ReadInt();
}
public bool Save(object target, MetaData metaData)
{
Debug.Print("SaveContext::Save");
try
{
this.RootObject = target;
using (new PerformanceTestBlock("SaveContext::Save"))
{
BinaryWriterFactory.Initialize();
this.CollectObjects();
ArchiveConcurrentSerializer headerSerializer = new ArchiveConcurrentSerializer();
byte[][] objectData = new byte[this._childObjects.Count][];
using (new PerformanceTestBlock("SaveContext::Saving Objects"))
TWParallel.For(0, this._childObjects.Count, (Action <int>)(i => this.SaveSingleObject(headerSerializer, objectData, i)));
byte[][] containerData = new byte[this._childContainers.Count][];
using (new PerformanceTestBlock("SaveContext::Saving Containers"))
TWParallel.For(0, this._childContainers.Count, (Action <int>)(i => this.SaveSingleContainer(headerSerializer, containerData, i)));
using (new PerformanceTestBlock("SaveContext::SaveObjects config"))
{
SaveEntryFolder rootFolder = SaveEntryFolder.CreateRootFolder();
BinaryWriter binaryWriter = BinaryWriterFactory.GetBinaryWriter();
binaryWriter.WriteInt(this._idsOfChildObjects.Count);
binaryWriter.WriteInt(this._strings.Count);
binaryWriter.WriteInt(this._idsOfChildContainers.Count);
rootFolder.CreateEntry(new EntryId(-1, SaveEntryExtension.Config)).FillFrom(binaryWriter);
headerSerializer.SerializeFolderConcurrent(rootFolder);
BinaryWriterFactory.ReleaseBinaryWriter(binaryWriter);
}
ArchiveSerializer archiveSerializer = new ArchiveSerializer();
using (new PerformanceTestBlock("SaveContext::SaveObjects strings"))
{
SaveEntryFolder rootFolder = SaveEntryFolder.CreateRootFolder();
SaveEntryFolder folder = archiveSerializer.CreateFolder(rootFolder, new FolderId(-1, SaveFolderExtension.Strings), this._strings.Count);
for (int index = 0; index < this._strings.Count; ++index)
{
string str = this._strings[index];
SaveContext.SaveStringTo(folder, index, str);
}
archiveSerializer.SerializeFolder(rootFolder);
}
byte[] header = (byte[])null;
byte[] strings = (byte[])null;
using (new PerformanceTestBlock("SaveContext::FinalizeAndGetBinaryHeaderDataConcurrent"))
header = headerSerializer.FinalizeAndGetBinaryDataConcurrent();
using (new PerformanceTestBlock("SaveContext::FinalizeAndGetBinaryStringDataConcurrent"))
strings = archiveSerializer.FinalizeAndGetBinaryData();
this.SaveData = new GameData(header, strings, objectData, containerData);
BinaryWriterFactory.Release();
}
return(true);
}
catch
{
return(false);
}
}
private FolderId[] GetChildStructNames(SaveEntryFolder saveEntryFolder)
{
List <FolderId> folderIdList = new List <FolderId>();
foreach (SaveEntryFolder childFolder in saveEntryFolder.ChildFolders)
{
if (childFolder.FolderId.Extension == SaveFolderExtension.Struct && !folderIdList.Contains(childFolder.FolderId))
{
folderIdList.Add(childFolder.FolderId);
}
}
return(folderIdList.ToArray());
}
public void SaveHeaderTo(SaveEntryFolder parentFolder, IArchiveContext archiveContext)
{
SaveEntryFolder folder = archiveContext.CreateFolder(parentFolder, new FolderId(this.ObjectId, SaveFolderExtension.Container), 1);
BinaryWriter binaryWriter = BinaryWriterFactory.GetBinaryWriter();
this._typeDefinition.SaveId.WriteTo((IWriter)binaryWriter);
binaryWriter.WriteByte((byte)this._containerType);
binaryWriter.WriteInt(this.GetElementCount());
EntryId entryId = new EntryId(-1, SaveEntryExtension.Object);
folder.CreateEntry(entryId).FillFrom(binaryWriter);
BinaryWriterFactory.ReleaseBinaryWriter(binaryWriter);
}
internal static ObjectLoadData CreateLoadData(
LoadData loadData,
int i,
ObjectHeaderLoadData header)
{
ArchiveDeserializer archiveDeserializer = new ArchiveDeserializer();
archiveDeserializer.LoadFrom(loadData.GameData.ObjectData[i]);
SaveEntryFolder rootFolder = archiveDeserializer.RootFolder;
ObjectLoadData objectLoadData = new ObjectLoadData(header);
FolderId folderId = new FolderId(i, SaveFolderExtension.Object);
SaveEntryFolder childFolder = rootFolder.GetChildFolder(folderId);
objectLoadData.InitializeReaders(childFolder);
objectLoadData.FillCreatedObject();
objectLoadData.Read();
objectLoadData.FillObject();
return(objectLoadData);
}
private void SaveSingleObject(
ArchiveConcurrentSerializer headerSerializer,
byte[][] objectData,
int id)
{
object childObject = this._childObjects[id];
ArchiveSerializer archiveSerializer = new ArchiveSerializer();
SaveEntryFolder rootFolder1 = SaveEntryFolder.CreateRootFolder();
SaveEntryFolder rootFolder2 = SaveEntryFolder.CreateRootFolder();
ObjectSaveData objectSaveData = new ObjectSaveData((ISaveContext)this, id, childObject, true);
objectSaveData.CollectStructs();
objectSaveData.CollectMembers();
objectSaveData.CollectStrings();
objectSaveData.SaveHeaderTo(rootFolder2, (IArchiveContext)headerSerializer);
objectSaveData.SaveTo(rootFolder1, (IArchiveContext)archiveSerializer);
headerSerializer.SerializeFolderConcurrent(rootFolder2);
archiveSerializer.SerializeFolder(rootFolder1);
byte[] binaryData = archiveSerializer.FinalizeAndGetBinaryData();
objectData[id] = binaryData;
}
public void InitializeReaders(SaveEntryFolder saveEntryFolder)
{
BinaryReader binaryReader = saveEntryFolder.GetEntry(new EntryId(-1, SaveEntryExtension.Basics)).GetBinaryReader();
this._saveId = SaveId.ReadSaveIdFrom((IReader)binaryReader);
this._propertyCount = binaryReader.ReadShort();
this._childStructCount = binaryReader.ReadShort();
for (int id = 0; id < (int)this._childStructCount; ++id)
{
this._childStructs.Add(new ObjectLoadData(this.Context, id));
}
foreach (SaveEntry childEntry in saveEntryFolder.ChildEntries)
{
EntryId id = childEntry.Id;
if (id.Extension == SaveEntryExtension.Property)
{
PropertyLoadData propertyLoadData = new PropertyLoadData(this, (IReader)childEntry.GetBinaryReader());
this._propertyValues.Add(propertyLoadData);
this._memberValues.Add((MemberLoadData)propertyLoadData);
}
else
{
id = childEntry.Id;
if (id.Extension == SaveEntryExtension.Field)
{
FieldLoadData fieldLoadData = new FieldLoadData(this, (IReader)childEntry.GetBinaryReader());
this._fieldValues.Add(fieldLoadData);
this._memberValues.Add((MemberLoadData)fieldLoadData);
}
}
}
for (int index = 0; index < (int)this._childStructCount; ++index)
{
this._childStructs[index].InitializeReaders(saveEntryFolder.GetChildFolder(new FolderId(index, SaveFolderExtension.Struct)));
}
}
public void InitializeReaders(SaveEntryFolder saveEntryFolder)
{
foreach (FolderId childStructName in this.GetChildStructNames(saveEntryFolder))
{
int localId = childStructName.LocalId;
ObjectLoadData objectLoadData = new ObjectLoadData(this.Context, localId);
this._childStructs.Add(localId, objectLoadData);
}
for (int id = 0; id < this._elementCount; ++id)
{
ElementLoadData elementLoadData1 = new ElementLoadData(this, (IReader)saveEntryFolder.GetEntry(new EntryId(id, SaveEntryExtension.Value)).GetBinaryReader());
this._values[id] = elementLoadData1;
if (this._containerType == ContainerType.Dictionary)
{
ElementLoadData elementLoadData2 = new ElementLoadData(this, (IReader)saveEntryFolder.GetEntry(new EntryId(id, SaveEntryExtension.Key)).GetBinaryReader());
this._keys[id] = elementLoadData2;
}
}
foreach (KeyValuePair <int, ObjectLoadData> childStruct in this._childStructs)
{
int key = childStruct.Key;
childStruct.Value.InitializeReaders(saveEntryFolder.GetChildFolder(new FolderId(key, SaveFolderExtension.Struct)));
}
}
public bool Load(LoadData loadData, bool loadAsLateInitialize)
{
try
{
using (new PerformanceTestBlock("LoadContext::Load Headers"))
{
using (new PerformanceTestBlock("LoadContext::Load And Create Header"))
{
ArchiveDeserializer archiveDeserializer = new ArchiveDeserializer();
archiveDeserializer.LoadFrom(loadData.GameData.Header);
SaveEntryFolder headerRootFolder = archiveDeserializer.RootFolder;
BinaryReader binaryReader = headerRootFolder.GetEntry(new EntryId(-1, SaveEntryExtension.Config)).GetBinaryReader();
this._objectCount = binaryReader.ReadInt();
this._stringCount = binaryReader.ReadInt();
this._containerCount = binaryReader.ReadInt();
this._objectHeaderLoadDatas = new ObjectHeaderLoadData[this._objectCount];
this._containerHeaderLoadDatas = new ContainerHeaderLoadData[this._containerCount];
this._strings = new string[this._stringCount];
TWParallel.For(0, this._objectCount, (Action <int>)(i =>
{
ObjectHeaderLoadData objectHeaderLoadData = new ObjectHeaderLoadData(this, i);
SaveEntryFolder childFolder = headerRootFolder.GetChildFolder(new FolderId(i, SaveFolderExtension.Object));
objectHeaderLoadData.InitialieReaders(childFolder);
this._objectHeaderLoadDatas[i] = objectHeaderLoadData;
}));
TWParallel.For(0, this._containerCount, (Action <int>)(i =>
{
ContainerHeaderLoadData containerHeaderLoadData = new ContainerHeaderLoadData(this, i);
SaveEntryFolder childFolder = headerRootFolder.GetChildFolder(new FolderId(i, SaveFolderExtension.Container));
containerHeaderLoadData.InitialieReaders(childFolder);
this._containerHeaderLoadDatas[i] = containerHeaderLoadData;
}));
}
using (new PerformanceTestBlock("LoadContext::Create Objects"))
{
foreach (ObjectHeaderLoadData objectHeaderLoadData in this._objectHeaderLoadDatas)
{
objectHeaderLoadData.CreateObject();
if (objectHeaderLoadData.Id == 0)
{
this.RootObject = objectHeaderLoadData.Target;
}
}
foreach (ContainerHeaderLoadData containerHeaderLoadData in this._containerHeaderLoadDatas)
{
if (containerHeaderLoadData.GetObjectTypeDefinition())
{
containerHeaderLoadData.CreateObject();
}
}
}
}
GC.Collect();
GC.WaitForPendingFinalizers();
using (new PerformanceTestBlock("LoadContext::Load Strings"))
{
ArchiveDeserializer saveArchive = new ArchiveDeserializer();
saveArchive.LoadFrom(loadData.GameData.Strings);
for (int id = 0; id < this._stringCount; ++id)
{
string str = LoadContext.LoadString(saveArchive, id);
this._strings[id] = str;
}
}
GC.Collect();
GC.WaitForPendingFinalizers();
using (new PerformanceTestBlock("LoadContext::Resolve Objects"))
{
for (int i = 0; i < this._objectHeaderLoadDatas.Length; ++i)
{
ObjectHeaderLoadData objectHeaderLoadData = this._objectHeaderLoadDatas[i];
TypeDefinition typeDefinition = objectHeaderLoadData.TypeDefinition;
if (typeDefinition != null)
{
object loadedObject = objectHeaderLoadData.LoadedObject;
if (typeDefinition.ObjectResolver.CheckIfRequiresAdvancedResolving(loadedObject))
{
ObjectLoadData loadData1 = LoadContext.CreateLoadData(loadData, i, objectHeaderLoadData);
objectHeaderLoadData.AdvancedResolveObject(loadData.MetaData, loadData1);
}
else
{
objectHeaderLoadData.ResolveObject();
}
}
}
}
GC.Collect();
GC.WaitForPendingFinalizers();
using (new PerformanceTestBlock("LoadContext::Load Object Datas"))
TWParallel.For(0, this._objectCount, (Action <int>)(i =>
{
ObjectHeaderLoadData objectHeaderLoadData = this._objectHeaderLoadDatas[i];
if (objectHeaderLoadData.Target != objectHeaderLoadData.LoadedObject)
{
return;
}
LoadContext.CreateLoadData(loadData, i, objectHeaderLoadData);
}));
using (new PerformanceTestBlock("LoadContext::Load Container Datas"))
TWParallel.For(0, this._containerCount, (Action <int>)(i =>
{
byte[] binaryArchive = loadData.GameData.ContainerData[i];
ArchiveDeserializer archiveDeserializer = new ArchiveDeserializer();
archiveDeserializer.LoadFrom(binaryArchive);
SaveEntryFolder rootFolder = archiveDeserializer.RootFolder;
ContainerLoadData containerLoadData = new ContainerLoadData(this._containerHeaderLoadDatas[i]);
containerLoadData.InitializeReaders(rootFolder.GetChildFolder(new FolderId(i, SaveFolderExtension.Container)));
containerLoadData.FillCreatedObject();
containerLoadData.Read();
containerLoadData.FillObject();
}));
GC.Collect();
GC.WaitForPendingFinalizers();
if (!loadAsLateInitialize)
{
this.CreateLoadCallbackInitializator(loadData).InitializeObjects();
}
return(true);
}
catch
{
return(false);
}
}
