Rework of ScriptResolver to binary handling. Now also serialises the type database to the stream, simplifying it's api.

src/ScriptResolving/AngelScript/ByteCodeHandling/IPkmnBinaryStream.hpp

@@ -0,0 +1,111 @@
+#ifndef PKMNLIB_IPKMNBINARYSTREAM_HPP
+#define PKMNLIB_IPKMNBINARYSTREAM_HPP
+
+#include <Arbutils/Collections/Dictionary.hpp>
+#include <Arbutils/ConstString.hpp>
+#include <CreatureLib/Battling/ScriptHandling/ScriptCategory.hpp>
+#include <angelscript.h>
+
+class IPkmnBinaryStream : public asIBinaryStream {
+protected:
+    size_t _angelScriptBound;
+
+    IPkmnBinaryStream(size_t angelScriptBound) : _angelScriptBound(angelScriptBound) {}
+
+public:
+    virtual void WriteTypes(const Dictionary<ScriptCategory, Dictionary<ConstString, AngelScriptTypeInfo*>>& types) {
+        // We serialize our types in the format
+        // "[category(byte)][name(str)]\2[decl(str)]\2[name(str)]\2[decl(str)]\1[category(byte)]...."
+
+        ScriptCategory categoryArr[1];
+        for (const auto& dic : types) {
+            // Write the category
+            categoryArr[0] = dic.first;
+            Write(categoryArr, sizeof(ScriptCategory));
+            for (const auto& inner : dic.second) {
+                // Write the script name
+                Write(inner.first.c_str(), sizeof(char) * inner.first.Length());
+                // Write the divider
+                Write("\2", sizeof(char));
+                // Write the declaration of the script
+                auto decl = inner.second->GetDecl();
+                Write(decl, sizeof(char) * strlen(decl));
+                // Write another divider.
+                Write("\2", sizeof(char));
+            }
+            // Write the divider between categories.
+            Write("\1", sizeof(char));
+        }
+    }
+    virtual Dictionary<ScriptCategory, Dictionary<ConstString, uint32_t>> ReadTypes() {
+        _angelScriptBound = SIZE_MAX;
+        Dictionary<ScriptCategory, Dictionary<ConstString, uint32_t>> types;
+        ScriptCategory categoryArr[1];
+        while (true) {
+            // Every inner database starts with the category, of known size. Read that.
+            auto read = Read(categoryArr, sizeof(ScriptCategory));
+            // If we haven't read anything, we are finished.
+            if (read == 0) {
+                break;
+            }
+            Dictionary<ConstString, uint32_t> innerDb;
+
+            // We don't know the sizes of the name and decl. Allocate 128 characters for them, as that should be enough.
+            char name[128];
+            char decl[128];
+            size_t pos = 0;
+            bool isDecl = false;
+
+            while (true) {
+                // Keep reading characters
+                char cArr[1];
+                Read(cArr, sizeof(char));
+                auto c = cArr[0];
+                // If we find a '\1' separator
+                if (c == '\1') {
+                    // and if we were reading the decl
+                    if (isDecl) {
+                        // Insert the name and decl into the dictionary. Close off the decl with eof as well.
+                        decl[pos] = '\0';
+                        innerDb.Insert(Arbutils::CaseInsensitiveConstString(name),
+                                       Arbutils::CaseInsensitiveConstString::GetHash(decl));
+                    }
+                    // If we have found \1, we are done with the current category, so break.
+                    break;
+                }
+                // If we find a '\2' separator, we need to toggle between writing to name and writing to decl. If we
+                // were writing a decl, also insert the name and decl into the dictionary.
+                if (c == '\2') {
+                    if (isDecl) {
+                        // Insert the name and decl into the dictionary. Close off the decl with eof as well.
+                        decl[pos] = '\0';
+                        innerDb.Insert(Arbutils::CaseInsensitiveConstString(name),
+                                       Arbutils::CaseInsensitiveConstString::GetHash(decl));
+                        // Reset our position and toggle back to name.
+                        pos = 0;
+                        isDecl = false;
+                        continue;
+                    } else {
+                        // Close of the name with eof, reset position and toggle to decl.
+                        name[pos] = '\0';
+                        pos = 0;
+                        isDecl = true;
+                        continue;
+                    }
+                } else {
+                    // If we haven't found any control character, just add the character to the thing we are writing to,
+                    // and increment the position.
+                    if (isDecl) {
+                        decl[pos++] = c;
+                    } else {
+                        name[pos++] = c;
+                    }
+                }
+            }
+            types.Insert(categoryArr[0], innerDb);
+        }
+        return types;
+    }
+};
+
+#endif // PKMNLIB_IPKMNBINARYSTREAM_HPP