public void Load(string projectPath, string[] assetPaths, Type[] types, StorageEventHandler <PersistentObject[]> callback)
{
QueueUserWorkItem(() =>
{
PersistentObject[] result = new PersistentObject[assetPaths.Length];
for (int i = 0; i < assetPaths.Length; ++i)
{
string assetPath = assetPaths[i];
assetPath = FullPath(projectPath) + assetPath;
ISerializer serializer = IOC.Resolve <ISerializer>();
try
{
if (File.Exists(assetPath))
{
if (types[i] == typeof(PersistentRuntimeTextAsset))
{
PersistentRuntimeTextAsset textAsset = new PersistentRuntimeTextAsset();
textAsset.name = Path.GetFileName(assetPath);
textAsset.Text = File.ReadAllText(assetPath);
textAsset.Ext = Path.GetExtension(assetPath);
result[i] = textAsset;
}
else if (types[i] == typeof(PersistentRuntimeBinaryAsset))
{
PersistentRuntimeBinaryAsset binAsset = new PersistentRuntimeBinaryAsset();
binAsset.name = Path.GetFileName(assetPath);
binAsset.Data = File.ReadAllBytes(assetPath);
binAsset.Ext = Path.GetExtension(assetPath);
result[i] = binAsset;
}
else
{
using (FileStream fs = File.OpenRead(assetPath))
{
result[i] = (PersistentObject)serializer.Deserialize(fs, types[i]);
}
}
}
else
{
Callback(() => callback(new Error(Error.E_NotFound), new PersistentObject[0]));
return;
}
}
catch (Exception e)
{
Debug.LogErrorFormat("Unable to load asset: {0} -> got exception: {1} ", assetPath, e.ToString());
Callback(() => callback(new Error(Error.E_Exception)
{
ErrorText = e.ToString()
}, new PersistentObject[0]));
return;
}
}
Callback(() => callback(new Error(Error.OK), result));
});
}
public void GetValue(string projectPath, string key, Type type, StorageEventHandler <PersistentObject> callback)
{
string fullPath = FullPath(projectPath);
string path = fullPath + "/" + KeyValueStorage;
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
path = path + "/" + key;
if (File.Exists(path))
{
object result = null;
if (type == typeof(PersistentRuntimeTextAsset))
{
PersistentRuntimeTextAsset textAsset = new PersistentRuntimeTextAsset();
textAsset.name = Path.GetFileName(path);
textAsset.Text = File.ReadAllText(path);
textAsset.Ext = Path.GetExtension(path);
result = textAsset;
}
else if (type == typeof(PersistentRuntimeBinaryAsset))
{
PersistentRuntimeBinaryAsset binaryAsset = new PersistentRuntimeBinaryAsset();
binaryAsset.name = Path.GetFileName(path);
binaryAsset.Data = File.ReadAllBytes(path);
binaryAsset.Ext = Path.GetExtension(path);
result = binaryAsset;
}
else
{
ISerializer serializer = IOC.Resolve <ISerializer>();
using (FileStream fs = File.OpenRead(path))
{
result = serializer.Deserialize(fs, type);
}
}
callback(new Error(Error.OK), (PersistentObject)result);
}
else
{
callback(new Error(Error.E_NotFound), null);
return;
}
}
public void GetValues(string projectPath, string searchPattern, Type type, StorageEventHandler <PersistentObject[]> callback)
{
QueueUserWorkItem(() =>
{
string fullPath = FullPath(projectPath);
string path = fullPath + "/" + KeyValueStorage;
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string[] files = Directory.GetFiles(path, searchPattern);
PersistentObject[] result = new PersistentObject[files.Length];
ISerializer serializer = IOC.Resolve <ISerializer>();
for (int i = 0; i < files.Length; ++i)
{
if (type == typeof(PersistentRuntimeTextAsset))
{
PersistentRuntimeTextAsset textAsset = new PersistentRuntimeTextAsset();
textAsset.name = Path.GetFileName(files[i]);
textAsset.Text = File.ReadAllText(files[i]);
textAsset.Ext = Path.GetExtension(files[i]);
result[i] = textAsset;
}
else if (type == typeof(PersistentRuntimeBinaryAsset))
{
PersistentRuntimeBinaryAsset binaryAsset = new PersistentRuntimeBinaryAsset();
binaryAsset.name = Path.GetFileName(files[i]);
binaryAsset.Data = File.ReadAllBytes(files[i]);
binaryAsset.Ext = Path.GetExtension(files[i]);
result[i] = binaryAsset;
}
else
{
using (FileStream fs = File.OpenRead(files[i]))
{
result[i] = (PersistentObject)serializer.Deserialize(fs, type);
}
}
}
Callback(() => callback(Error.NoError, result));
});
}
public void SetValue(string projectPath, string key, PersistentObject persistentObject, StorageEventHandler callback)
{
string fullPath = FullPath(projectPath);
string path = fullPath + "/" + KeyValueStorage;
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
path = path + "/" + key;
if (File.Exists(path))
{
File.Delete(path);
}
if (persistentObject is PersistentRuntimeTextAsset)
{
PersistentRuntimeTextAsset textAsset = (PersistentRuntimeTextAsset)persistentObject;
File.WriteAllText(path, textAsset.Text);
}
else if (persistentObject is PersistentRuntimeBinaryAsset)
{
PersistentRuntimeBinaryAsset binaryAsset = (PersistentRuntimeBinaryAsset)persistentObject;
File.WriteAllBytes(path, binaryAsset.Data);
}
else
{
ISerializer serializer = IOC.Resolve <ISerializer>();
using (FileStream fs = File.Create(path))
{
serializer.Serialize(persistentObject, fs);
}
serializer.Serialize(persistentObject);
}
callback(new Error(Error.OK));
}
public void Save(string projectPath, string[] folderPaths, AssetItem[] assetItems, PersistentObject[] persistentObjects, ProjectInfo projectInfo, bool previewOnly, StorageEventHandler callback)
{
QueueUserWorkItem(() =>
{
if (!previewOnly)
{
if (assetItems.Length != persistentObjects.Length)
{
throw new ArgumentException("assetItems");
}
}
if (assetItems.Length > folderPaths.Length)
{
int l = folderPaths.Length;
Array.Resize(ref folderPaths, assetItems.Length);
for (int i = l; i < folderPaths.Length; ++i)
{
folderPaths[i] = folderPaths[l - 1];
}
}
projectPath = FullPath(projectPath);
if (!Directory.Exists(projectPath))
{
Directory.CreateDirectory(projectPath);
}
string projectInfoPath = projectPath + "/Project.rtmeta";
ISerializer serializer = IOC.Resolve <ISerializer>();
Error error = new Error(Error.OK);
for (int i = 0; i < assetItems.Length; ++i)
{
string folderPath = folderPaths[i];
AssetItem assetItem = assetItems[i];
try
{
string path = projectPath + folderPath;
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string previewPath = path + "/" + assetItem.NameExt + PreviewExt;
if (assetItem.Preview == null)
{
File.Delete(previewPath);
}
else
{
File.Delete(previewPath);
using (FileStream fs = File.Create(previewPath))
{
serializer.Serialize(assetItem.Preview, fs);
}
}
if (!previewOnly)
{
PersistentObject persistentObject = persistentObjects[i];
File.Delete(path + "/" + assetItem.NameExt + MetaExt);
using (FileStream fs = File.Create(path + "/" + assetItem.NameExt + MetaExt))
{
serializer.Serialize(assetItem, fs);
}
File.Delete(path + "/" + assetItem.NameExt);
if (persistentObject is PersistentRuntimeTextAsset)
{
PersistentRuntimeTextAsset textAsset = (PersistentRuntimeTextAsset)persistentObject;
File.WriteAllText(path + "/" + assetItem.NameExt, textAsset.Text);
}
else if (persistentObject is PersistentRuntimeBinaryAsset)
{
PersistentRuntimeBinaryAsset binAsset = (PersistentRuntimeBinaryAsset)persistentObject;
File.WriteAllBytes(path + "/" + assetItem.NameExt, binAsset.Data);
}
else
{
using (FileStream fs = File.Create(path + "/" + assetItem.NameExt))
{
serializer.Serialize(persistentObject, fs);
}
}
}
}
catch (Exception e)
{
Debug.LogErrorFormat("Unable to create asset: {0} -> got exception: {1} ", assetItem.NameExt, e.ToString());
error.ErrorCode = Error.E_Exception;
error.ErrorText = e.ToString();
break;
}
}
File.Delete(projectInfoPath);
using (FileStream fs = File.Create(projectInfoPath))
{
serializer.Serialize(projectInfo, fs);
}
Callback(() => callback(error));
});
}
public void Load(string projectPath, AssetItem[] assetItems, Type[] types, StorageEventHandler <PersistentObject <TID>[]> callback)
{
string[] assetPaths = assetItems.Select(item => item.ToString()).ToArray();
long[] customDataOffsets = assetItems.Select(item => item.CustomDataOffset).ToArray();
QueueUserWorkItem(() =>
{
PersistentObject <TID>[] result = new PersistentObject <TID> [assetPaths.Length];
for (int i = 0; i < assetPaths.Length; ++i)
{
string assetPath = assetPaths[i];
assetPath = FullPath(projectPath) + assetPath;
ISerializer serializer = IOC.Resolve <ISerializer>();
try
{
if (File.Exists(assetPath))
{
if (types[i] == typeof(PersistentRuntimeTextAsset <TID>))
{
PersistentRuntimeTextAsset <TID> textAsset = new PersistentRuntimeTextAsset <TID>();
textAsset.name = Path.GetFileName(assetPath);
textAsset.Text = File.ReadAllText(assetPath);
textAsset.Ext = Path.GetExtension(assetPath);
result[i] = textAsset;
}
else if (types[i] == typeof(PersistentRuntimeBinaryAsset <TID>))
{
PersistentRuntimeBinaryAsset <TID> binAsset = new PersistentRuntimeBinaryAsset <TID>();
binAsset.name = Path.GetFileName(assetPath);
binAsset.Data = File.ReadAllBytes(assetPath);
binAsset.Ext = Path.GetExtension(assetPath);
result[i] = binAsset;
}
else
{
using (FileStream fs = File.OpenRead(assetPath))
{
long customDataOffset = customDataOffsets[i];
if (customDataOffset == -1)
{
result[i] = (PersistentObject <TID>)serializer.Deserialize(fs, types[i]);
}
else
{
if (customDataOffset > 0)
{
result[i] = (PersistentObject <TID>)serializer.Deserialize(fs, types[i], customDataOffset);
}
else
{
result[i] = (PersistentObject <TID>)Activator.CreateInstance(types[i]);
}
if (fs.Position < fs.Length)
{
using (BinaryReader reader = new BinaryReader(fs))
{
CustomSerializationHeader header = reader.ReadHeader();
if (header.IsValid)
{
ICustomSerialization customSerialization = (ICustomSerialization)result[i];
customSerialization.Deserialize(fs, reader);
}
}
}
}
}
}
}
else
{
Callback(() => callback(new Error(Error.E_NotFound), new PersistentObject <TID> [0]));
return;
}
}
catch (Exception e)
{
Debug.LogErrorFormat("Unable to load asset: {0} -> got exception: {1} ", assetPath, e.ToString());
Callback(() => callback(new Error(Error.E_Exception)
{
ErrorText = e.ToString()
}, new PersistentObject <TID> [0]));
return;
}
}
Callback(() => callback(new Error(Error.OK), result));
});
}
