private void LoadCaches(string[] entities)
{
for (int i = 0; i < entities.Length; ++i)
{
string name = entities[i];
if (!m_cacheEntities.ContainsKey(name))
{
EB.Debug.LogError("DataCacheManager.LoadCaches: entity not found for {0}", name);
continue;
}
DataCacheEntity entity = m_cacheEntities[name];
if (entity.Cache != null)
{
continue;
}
IVersionedDataCache cache = LoadCache(name, entity.Type);
if (cache != null)
{
entity.Cache = cache;
entity.Version = cache.Version;
}
}
}
private void SaveCache(string name, IVersionedDataCache cache)
{
//var begin = System.DateTime.Now;
//double cost = 0.0;
string path = System.IO.Path.Combine(UnityEngine.Application.persistentDataPath, System.IO.Path.Combine(m_cacheDirectory, name));
string directory = System.IO.Path.GetDirectoryName(path);
if (!System.IO.Directory.Exists(directory))
{
if (System.IO.Directory.CreateDirectory(directory) == null)
{
EB.Debug.LogError("DataCacheManager.SaveCache: create directory {0} failed when save {1}", directory, path);
return;
}
//EB.Debug.Log("DataCacheManager.SaveCache: create directory {0}", directory);
}
using (System.IO.FileStream fs = System.IO.File.Create(path))
{
IVersionedDataCacheSerializer serializer = DataCacheUtil.GetSerializer(cache.GetType());
UnityEngine.Debug.Assert(serializer != null, "DataCacheManager.SaveCache: GetSerializer failed");
serializer.Serialize(fs, cache);
fs.Close();
fs.Dispose();
//cost = (System.DateTime.Now - begin).TotalSeconds;
//EB.Debug.LogIf(cost > 0.1, "DataCacheManager.SaveCache: {0} saved, cost = {1}", path, cost);
#if UNITY_IPHONE
UnityEngine.iOS.Device.SetNoBackupFlag(path);
#endif
}
}
private IVersionedDataCache LoadCache(string name, System.Type type)
{
EB.Debug.Log("Start LoadCache: name ={0} time = {1}", name, UnityEngine.Time.time);
string path = System.IO.Path.Combine(UnityEngine.Application.persistentDataPath, System.IO.Path.Combine(m_cacheDirectory, name));
if (!System.IO.File.Exists(path))
{
EB.Debug.Log("DataCacheManager.LoadCache: cache file does't exists {0}", path);
return(null);
}
IVersionedDataCache cache = null;
using (System.IO.FileStream fs = System.IO.File.OpenRead(path))
{
IVersionedDataCacheSerializer serializer = DataCacheUtil.GetSerializer(type);
UnityEngine.Debug.Assert(serializer != null, "DataCacheManager.LoadCache: GetSerializer failed");
cache = serializer.Deserialize(fs);
if (cache == null)
{
EB.Debug.LogWarning("DataCacheManager.LoadCache: Deserialize {0} failed, will remove it", path);
System.IO.File.Delete(path);
}
}
EB.Debug.Log("End LoadCache: name ={0} time = {1}", name, UnityEngine.Time.time);
return(cache);
}
public void Serialize(Stream stream, IVersionedDataCache data_cache_obj)
{
UnityEngine.Debug.Assert(data_cache_obj != null && data_cache_obj is DefaultDataCache,
"data_cache_obj is null or is not DefaultDataCache");
UnityEngine.Debug.Assert(stream != null && stream.CanWrite,
"stream is null or can not write");
DefaultDataCache data = data_cache_obj as DefaultDataCache;
using (TextWriter writer = new StreamWriter(stream))
{
writer.WriteLine(data.Version);
writer.Write(data.Content);
}
}
public void Cache(string name, IVersionedDataCache cache)
{
UnityEngine.Debug.Assert(cache != null, "DataCacheManager.Cache: cache is null");
SaveCache(name, cache);
if (m_cacheEntities.TryGetValue(name, out var entity))
{
if (entity.Cache != null)
{
entity.Cache.Dispose();
entity.Cache = null;
}
entity.Cache = cache;
entity.Version = cache.Version;
}
}
public void Serialize(Stream stream, IVersionedDataCache data_cache_obj)
{
FlatBuffersDataCache data = data_cache_obj as FlatBuffersDataCache;
using (BinaryWriter bw = new BinaryWriter(stream))
{
byte[] version = EB.Encoding.GetBytes(data.Version);
if (version.Length != VERSION_OFFSET)
{
EB.Debug.LogWarning("FlatBufferTableDataCacheSerializer.Serialize: resize invalid version {0}", data.Version);
byte[] buffer = new byte[VERSION_OFFSET];
System.Buffer.BlockCopy(version, 0, buffer, 0, System.Math.Min(version.Length, VERSION_OFFSET));
version = buffer;
}
bw.Write(version);
bw.Write(data.Buffer.Array, data.Buffer.Offset, data.Buffer.Count);
}
}
public void Serialize(Stream stream, IVersionedDataCache data_cache_obj)
{
UnityEngine.Debug.Assert(data_cache_obj != null && data_cache_obj is JsonDataCache,
"data_cache_obj is null or data_cache_obj is not JsonDataCache");
UnityEngine.Debug.Assert(stream != null && stream.CanWrite,
"stream is null or can not write");
JsonDataCache data = data_cache_obj as JsonDataCache;
Hashtable ht = Johny.HashtablePool.Claim();
ht["version"] = data.Version;
ht["payload"] = data.Payload;
string content = EB.JSON.Stringify(ht);
using (TextWriter writer = new StreamWriter(stream))
{
writer.Write(content);
}
}
