Writing

DBCD.Benchmark/Benchmarks/ReadingBenchmark.cs

@@ -0,0 +1,45 @@
+using BenchmarkDotNet.Attributes;
+using DBCD.Providers;
+
+namespace DBCD.Benchmark.Benchmarks
+{
+    [MemoryDiagnoser]
+    public class ReadingBenchmark
+    {
+        private static readonly FilesystemDBDProvider localDBDProvider = new FilesystemDBDProvider("D:\\Projects\\WoWDBDefs\\definitions");
+        private static readonly FilesystemDBCProvider localDBCProvider = new FilesystemDBCProvider("D:\\Projects\\DBCDStaging\\DBCD.Tests\\bin\\Debug\\net8.0\\DBCCache\\11.0.2.56044");
+        private readonly string[] allDB2s = Directory.GetFiles("D:\\Projects\\DBCDStaging\\DBCD.Tests\\bin\\Debug\\net8.0\\DBCCache\\11.0.2.56044", "*.db2", SearchOption.AllDirectories).Select(x => Path.GetFileNameWithoutExtension(x)).ToArray();
+        private readonly string build = "11.0.2.56044";
+
+        [Benchmark]
+        public int TestReadingAllDB2s()
+        {
+            var inputDBCD = new DBCD(localDBCProvider, localDBDProvider);
+
+            //var build = "3.3.5.12340"; // WDBC
+            //var build = "6.0.1.18179"; // WDB2
+            //var build = "7.0.1.20740"; // WDB3, only 1 DBD sadly
+            //var build = "7.0.1.20810"; // WDB4, only 2 DBDs sadly
+            //var build = "7.2.0.23436"; // WDB5, only Map.db2
+            //var build = "7.3.5.25928"; // WDB6
+            //var build = "7.3.5.25928"; // WDC1
+            //var build = "8.0.1.26231"; // WDC2
+            //var build = "9.1.0.39653"; // WDC3
+            //var build = "10.1.0.48480"; // WDC4
+            var build = "11.0.2.56044"; // WDC5
+
+            foreach (var tableName in allDB2s)
+            {
+                if (tableName == "UnitTestSparse")
+                    continue;
+
+                if (!localDBDProvider.ContainsBuild(tableName, build))
+                    continue;
+
+                var storage = inputDBCD.Load(tableName, build);
+            }
+
+            return allDB2s.Count();
+        }
+    }
+}

DBCD.Benchmark/Benchmarks/StringTableBench.cs

@@ -0,0 +1,76 @@
+using BenchmarkDotNet.Attributes;
+using System.Text;
+
+namespace DBCD.Benchmark.Benchmarks
+{
+    [MemoryDiagnoser]
+    public class StringTableBench
+    {
+        private static byte[] InputBytes = File.ReadAllBytes("E:\\stringtable.bytes");
+        private static int StringTableSize = (int)InputBytes.Length;
+
+        [Benchmark]
+        public void OldMethod()
+        {
+            using (var stream = new MemoryStream(InputBytes))
+            using (var reader = new BinaryReader(stream))
+            {
+                var StringTable = new Dictionary<long, string>(StringTableSize / 0x20);
+                for (int i = 0; i < StringTableSize;)
+                {
+                    long oldPos = reader.BaseStream.Position;
+                    StringTable[i] = reader.ReadCString();
+                    i += (int)(reader.BaseStream.Position - oldPos);
+                }
+            }
+        }
+
+        [Benchmark]
+        public void NewMethod()
+        {
+            using (var stream = new MemoryStream(InputBytes))
+            using (var reader = new BinaryReader(stream))
+            {
+                var StringTable = reader.ReadStringTable(StringTableSize);
+            }
+        }
+    }
+
+    public static class BinaryReaderExtensions
+    {
+        public static string ReadCString(this BinaryReader reader)
+        {
+            var bytes = new List<byte>();
+            byte b;
+            while ((b = reader.ReadByte()) != 0)
+                bytes.Add(b);
+
+            return Encoding.UTF8.GetString(bytes.ToArray());
+        }
+
+        public static Dictionary<long, string> ReadStringTable(this BinaryReader reader, int stringTableSize, int baseOffset = 0, bool usePos = false)
+        {
+            var StringTable = new Dictionary<long, string>(stringTableSize / 0x20);
+
+            if (stringTableSize == 0)
+                return StringTable;
+
+            var curOfs = 0;
+            var decoded = Encoding.UTF8.GetString(reader.ReadBytes(stringTableSize));
+            foreach (var str in decoded.Split('\0'))
+            {
+                if (curOfs == stringTableSize)
+                    break;
+
+                if (usePos)
+                    StringTable[(reader.BaseStream.Position - stringTableSize) + curOfs] = str;
+                else
+                    StringTable[baseOffset + curOfs] = str;
+
+                curOfs += Encoding.UTF8.GetByteCount(str) + 1;
+            }
+
+            return StringTable;
+        }
+    }
+}

DBCD.Benchmark/Benchmarks/WritingBenchmark.cs

@@ -0,0 +1,40 @@
+using BenchmarkDotNet.Attributes;
+using DBCD.Benchmark.Utilities;
+using DBCD.Providers;
+
+namespace DBCD.Benchmark.Benchmarks
+{
+    [MemoryDiagnoser]
+    public class WritingBenchmark
+    {
+        public static GithubDBDProvider DBDProvider { get; } = new GithubDBDProvider(true);
+        public static string InputPath { get; } = $"{Directory.GetCurrentDirectory()}\\dbc";
+        public static DBCD InputDBCD { get; } = new DBCD(new FilesystemDBCProvider(InputPath), DBDProvider);
+        public static DBCD SavedDBCD { get; } = new DBCD(new FilesystemDBCProvider("tmp"), DBDProvider);
+
+        public static string Build { get; } = "9.1.0.39653";
+
+        [Benchmark]
+        public void TestWritingAllDB2s()
+        {
+            string[] allDB2s = Directory.GetFiles(InputPath, "*.db2", SearchOption.TopDirectoryOnly);
+
+            if (Directory.Exists("tmp"))
+                Directory.Delete("tmp", true);
+            Directory.CreateDirectory("tmp");
+
+            foreach (var db2File in allDB2s)
+            {
+                if (Utilities.IO.TryGetExactPath(db2File, out string exactPath))
+                {
+                    var tableName = Path.GetFileNameWithoutExtension(exactPath);
+
+                    var originalStorage = InputDBCD.Load(tableName, Build);
+                    originalStorage.Save($"tmp/{tableName}.db2");
+                }
+            }
+
+            Directory.Delete("tmp", true);
+        }
+    }
+}

DBCD.Benchmark/DBCD.Benchmark.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <Optimize>true</Optimize>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DBCD\DBCD.csproj" />
+  </ItemGroup>
+
+</Project>

DBCD.Benchmark/Program.cs

@@ -0,0 +1,5 @@
+// See https://aka.ms/new-console-template for more information
+using BenchmarkDotNet.Running;
+using DBCD.Benchmark.Benchmarks;
+
+BenchmarkRunner.Run<StringTableBench>();

DBCD.Benchmark/Utilities/IO.cs

@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace DBCD.Benchmark.Utilities
+{
+    internal class IO
+    {
+        public static bool TryGetExactPath(string path, out string exactPath)
+        {
+            bool result = false;
+            exactPath = null;
+
+            // DirectoryInfo accepts either a file path or a directory path, and most of its properties work for either.
+            // However, its Exists property only works for a directory path.
+            DirectoryInfo directory = new DirectoryInfo(path);
+            if (File.Exists(path) || directory.Exists)
+            {
+                List<string> parts = new List<string>();
+
+                DirectoryInfo parentDirectory = directory.Parent;
+                while (parentDirectory != null)
+                {
+                    FileSystemInfo entry = parentDirectory.EnumerateFileSystemInfos(directory.Name).First();
+                    parts.Add(entry.Name);
+
+                    directory = parentDirectory;
+                    parentDirectory = directory.Parent;
+                }
+
+                // Handle the root part (i.e., drive letter or UNC \\server\share).
+                string root = directory.FullName;
+                if (root.Contains(':'))
+                {
+                    root = root.ToUpper();
+                }
+                else
+                {
+                    string[] rootParts = root.Split('\\');
+                    root = string.Join("\\", rootParts.Select(part => CultureInfo.CurrentCulture.TextInfo.ToTitleCase(part)));
+                }
+
+                parts.Add(root);
+                parts.Reverse();
+                exactPath = Path.Combine(parts.ToArray());
+                result = true;
+            }
+
+            return result;
+        }
+    }
+}

DBFileReaderLib/Attributes/CardinalityAttribute.cs → DBCD.IO/Attributes/CardinalityAttribute.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace DBFileReaderLib.Attributes
+namespace DBCD.IO.Attributes
 {
     public class CardinalityAttribute : Attribute
     {

DBCD.IO/Attributes/ForeignAttribute.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace DBCD.IO.Attributes
+{
+    public class ForeignAttribute : Attribute
+    {
+        public readonly bool IsForeign;
+
+        public ForeignAttribute(bool isForeign) => IsForeign = isForeign;
+    }
+}

DBFileReaderLib/Attributes/IndexAttribute.cs → DBCD.IO/Attributes/IndexAttribute.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace DBFileReaderLib.Attributes
+namespace DBCD.IO.Attributes
 {
     public class IndexAttribute : Attribute
     {

DBFileReaderLib/Attributes/LocaleAttribute.cs → DBCD.IO/Attributes/LocaleAttribute.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace DBFileReaderLib.Attributes
+namespace DBCD.IO.Attributes
 {
     public class LocaleAttribute : Attribute
     {

DBFileReaderLib/Attributes/RelationAttribute.cs → DBCD.IO/Attributes/RelationAttribute.cs

@@ -1,6 +1,6 @@
-using System;
+using System;
 
-namespace DBFileReaderLib.Attributes
+namespace DBCD.IO.Attributes
 {
     public class RelationAttribute : Attribute
     {

DBFileReaderLib/Common/BitReader.cs → DBCD.IO/Common/BitReader.cs

@@ -2,7 +2,7 @@
 using System.Runtime.CompilerServices;
 using System.Text;
 
-namespace DBFileReaderLib.Common
+namespace DBCD.IO.Common
 {
     class BitReader
     {