public ParticleInfo(bool initData)
{
id = MelDB.GetRandomId(); if (initData)
{
data = new ParticleInfoData();
}
}
// Caches find request.
private ParticleInfo FindParticleCAS(string cas)
{
Debug.Log("FindParticleCAS " + cas);
if (string.IsNullOrEmpty(cas))
{
return(null);
}
uint casNumber = MelDB.ParseCASNumber(cas);
if (casNumber == 0)
{
return(null);
}
if ((_cachedParticle != null) && (_cachedParticle.CASes.Contains(casNumber)))
{
return(_cachedParticle);
}
_cachedParticle = MelDB.Particles.Find(p => p.CASes.Contains(casNumber));
return(_cachedParticle);
}
//[MenuItem("MELDB/Test", priority = 2000)]
private static void Test()
{
var p = MelDB.FindParticle("1h-phosphirene 1-oxide");
//var p = MelDB.GetParticle("Benzene");
Test(p);
}
private MelDB LoadIndexFromBytes(byte[] bytes)
{
var stream = new MemoryStream(bytes);
BinaryReader br = new BinaryReader(stream, encoding);
var result = new MelDB();
int particlesCount = br.ReadInt32();
var particles = new List <ParticleInfo>(particlesCount);
result.particles = particles;
for (int i = particlesCount - 1; i >= 0; i--)
{
var p = new ParticleInfo();
particles.Add(p);
p.atomsHash = br.ReadUInt32();
p.structureHash = br.ReadUInt32();
p.structureHashExact = br.ReadUInt32();
p.binaryDataLocationInBucket = br.ReadUInt16();
p.id = br.ReadUInt64();
p.name = br.ReadString();
var flags = (ParticleInfo.ParticleFlags)br.ReadUInt16();
p.flags = flags;
if ((flags & ParticleInfo.ParticleFlags.HasChemicalFormula) > 0)
{
p.chemicalFormula = br.ReadString();
}
if ((flags & ParticleInfo.ParticleFlags.HasParticleCharge) > 0)
{
p.charge = br.ReadSByte();
}
int casesCount = br.ReadByte();
p.CASes = new List <uint>(casesCount);
for (int cas = 0; cas < casesCount; cas++)
{
p.CASes.Add(br.ReadUInt32());
}
}
result.__sortedIds = new ushort[particlesCount];
for (int i = 0; i < particlesCount; i++)
{
result.__sortedIds[i] = br.ReadUInt16();
}
//result.__sortedStructureHashes = new ushort[particlesCount];
//for (int i = 0; i < particlesCount; i++)
// result.__sortedStructureHashes[i] = br.ReadUInt16();
//result.__sortedStructureHashesExact = new ushort[particlesCount];
//for (int i = 0; i < particlesCount; i++)
// result.__sortedStructureHashesExact[i] = br.ReadUInt16();
result.__sortedAtomsHashes = new ushort[particlesCount];
for (int i = 0; i < particlesCount; i++)
{
result.__sortedAtomsHashes[i] = br.ReadUInt16();
}
br.Close();
stream.Dispose();
return(result);
}
public override void Serialize(MelDB db, bool indexOnly, bool removeUnusedFiles = true,
Func <string, int, int, bool> progress = null)
{
if (progress != null && progress("XML serialization: 1/3 sorting DB", 0, 1))
{
return;
}
db.Sort();
XmlSerializer melDBSerializer = new XmlSerializer(typeof(MelDB));
if (progress != null && progress("XML serialization: 2/3 serializing index", 0, 1))
{
return;
}
using (FileStream fDB = File.Create(GetIndexPath()))
{
melDBSerializer.Serialize(fDB, db);
}
if (!indexOnly)
{
XmlSerializer particleDataSerializer = new XmlSerializer(typeof(ParticleInfo.ParticleInfoData));
int partsCount = db.particles.Count;
for (int i = 0; i < partsCount; i++)
{
var p = db.particles[i];
if (p.data == null)
{
continue;
}
if (progress != null && progress("XML serialization: 3/3 serializing particles", i, partsCount))
{
return;
}
string fullPath = GetParticlePath(p);
p.data.metaInfo = p;
// create directory
string dirPath = Path.GetDirectoryName(fullPath);
if (!Directory.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
}
using (FileStream f = File.Create(fullPath))
{
particleDataSerializer.Serialize(f, p.data);
}
p.data.metaInfo = null;
}
}
if (removeUnusedFiles)
{
RemoveUnusedFiles();
}
}
public void RemoveUnusedFiles()
{
string path = Directory.GetParent(GetIndexPath()).FullName;
var files = Directory.GetFiles(path, "*.xml", SearchOption.AllDirectories);
MelDB.Instance.Sort();
for (int i = 0; i < files.Length; i++)
{
var name = Path.GetFileNameWithoutExtension(files[i]);
ulong id;
if (ulong.TryParse(name, out id) && MelDB.FindParticleById(id) != null)
{
continue;
}
if (name.Equals(IndexFile, StringComparison.OrdinalIgnoreCase))
{
continue;
}
try
{
File.Delete(files[i]);
}
catch (Exception e)
{
Debug.LogErrorFormat("Failed to remove file: {0}\n{1}", e.Message, files[i]);
}
}
}
// Use this for initialization
void Start()
{
MelDB.Init();
StartCoroutine(CameraFov_Coroutine());
JSImports.LoadComplete_Callback();
}
public static void Init()
{
if (_instance != null)
{
return;
}
_instance = MelDBSerializer.Instance.LoadIndex();
Debug.Log("MelDB index loaded: " + _instance.particles.Count + " particles");
}
public static IEnumerator InitAsync(MonoBehaviour coroutineHolder)
{
if (_instance != null)
{
yield break;
}
MelDBSerializer.coroutineHolder = coroutineHolder;
var request = MelDBSerializer.Instance.LoadIndexAsync();
yield return(request);
if (_instance == null)
{
_instance = request.result;
Debug.Log("MelDB index async-loaded: " + _instance.particles.Count + " particles");
}
}
public CompoundInfo()
{
id = MelDB.GetRandomId();
}
public static void Clear()
{
_instance = null;
}
public abstract void Serialize(MelDB db, bool indexOnly, bool removeUnusedFiles = true,
Func <string, int, int, bool> progress = null);
public override void Serialize(MelDB db, bool indexOnly, bool removeUnusedFiles = true,
Func <string, int, int, bool> progress = null)
{
if (indexOnly)
{
throw new Exception("Trying to binary serialize DB with index only");
}
var bucketPrefix = Application.dataPath + DBPath + BucketFilename;
var dir = Path.GetDirectoryName(bucketPrefix);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
if (progress != null && progress("Binary Serialization: 1/4 preparing buckets", 0, 1))
{
return;
}
var streams = new BinaryWriter[BUCKETS];
for (int i = 0; i < BUCKETS; i++)
{
var s = File.Create(bucketPrefix + i.ToString("000") + ".bytes");
streams[i] = new BinaryWriter(s, encoding);
}
var particles = db.particles;
int particlesCount = particles.Count;
// first serialize all particles into buckets to get buckets location indexes
for (int i = particlesCount - 1; i >= 0; i--)
{
if (progress != null && progress("Binary Serialization: 2/4 cleaning and serializing particles", particlesCount - i, particlesCount))
{
return;
}
var p = particles[i];
p.Init();
if (p.data == null | !IncludeInBuild(p))
{
particles.RemoveAt(i);
continue;
}
var buck = GetParticleBuckedIndex(p);
var writer = streams[buck];
WriteParticleData(writer, p);
}
for (int i = 0; i < BUCKETS; i++)
{
streams[i].Close();
}
particlesCount = particles.Count;
if (progress != null && progress("Binary Serialization: 3/4 sorting DB", 0, 1))
{
return;
}
db.Sort();
dir = Path.GetDirectoryName(GetIndexPath());
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
// now we can serialize index with bucked indexes
using (FileStream fDB = File.Create(GetIndexPath()))
{
var bw = new BinaryWriter(fDB, encoding);
bw.Write(particlesCount);
for (int i = 0; i < particlesCount; i++)
{
if (progress != null && progress("Binary Serialization: 4/4 serializing index", i, particlesCount))
{
return;
}
var p = particles[i];
var flags = p.flags;
bw.Write(p.atomsHash);
bw.Write(p.structureHash);
bw.Write(p.structureHashExact);
bw.Write((ushort)p.binaryDataLocationInBucket);
bw.Write(p.id);
bw.Write(p.name);
bw.Write((ushort)p.flags);
if ((flags & ParticleInfo.ParticleFlags.HasChemicalFormula) > 0)
{
bw.Write(p.chemicalFormula);
}
if ((flags & ParticleInfo.ParticleFlags.HasParticleCharge) > 0)
{
bw.Write((sbyte)p.charge);
}
bw.Write((byte)p.CASes.Count);
for (int cas = 0; cas < p.CASes.Count; cas++)
{
bw.Write(p.CASes[cas]);
}
}
for (int i = 0; i < particlesCount; i++)
{
bw.Write(db.__sortedIds[i]);
}
//for (int i = 0; i < particlesCount; i++)
// bw.Write(db.__sortedStructureHashes[i]);
//for (int i = 0; i < particlesCount; i++)
// bw.Write(db.__sortedStructureHashesExact[i]);
for (int i = 0; i < particlesCount; i++)
{
bw.Write(db.__sortedAtomsHashes[i]);
}
bw.Close();
}
Debug.LogFormat("MelDB serialized with {0} particles into {1} buckets\nFlags: {2}",
particlesCount, BUCKETS, _include);
}
