Replace most collections with Arbutils collections for more safety.

src/Battling/ScriptHandling/ScriptAggregator.hpp

@@ -1,41 +1,42 @@
 #ifndef CREATURELIB_SCRIPTAGGREGATOR_HPP
 #define CREATURELIB_SCRIPTAGGREGATOR_HPP
 
-#include <any>
-#include <queue>
+#include <Arbutils/Collections/List.hpp>
 #include "../../Library/Exceptions/NotReachableException.hpp"
 #include "Script.hpp"
 #include "ScriptSet.hpp"
 #include "ScriptWrapper.hpp"
 
+using namespace Arbutils::Collections;
+
 namespace CreatureLib::Battling {
     class ScriptAggregator {
-        std::vector<ScriptWrapper> _scripts;
+        List<ScriptWrapper> _scripts;
         size_t _index = 0;
         bool _isSetSet = false;
-        const std::vector<Script*>* _setScripts;
+        const List<Script*>* _setScripts;
         size_t _setIndex;
 
     public:
-        ScriptAggregator(std::vector<ScriptWrapper> scripts) : _scripts(std::move(scripts)){};
+        ScriptAggregator(List<ScriptWrapper> scripts) : _scripts(std::move(scripts)){};
 
-        bool HasNext() { return _index < _scripts.size() || (_isSetSet && _setIndex < _setScripts->size()); }
+        bool HasNext() { return _index < _scripts.Count() || (_isSetSet && _setIndex < _setScripts->Count()); }
 
         Script* GetNext() {
             // We can probably do this in a cleaner version once C++ 20 drops with Coroutine support.
             if (_isSetSet) {
-                if (_setIndex >= _setScripts->size()) {
+                if (_setIndex >= _setScripts->Count()) {
                     _isSetSet = false;
                     return GetNext();
                 }
-                auto s = _setScripts->at(_setIndex);
+                auto s = _setScripts->At(_setIndex);
                 _setIndex++;
-                if (_setIndex >= _setScripts->size()) {
+                if (_setIndex >= _setScripts->Count()) {
                     _isSetSet = false;
                 }
                 return s;
             }
-            if (_index >= _scripts.size())
+            if (_index >= _scripts.Count())
                 return nullptr;
             auto next = _scripts[_index];
             _index++;

src/Battling/ScriptHandling/ScriptSet.hpp

@@ -7,7 +7,7 @@
 
 namespace CreatureLib::Battling {
     class ScriptSet {
-        std::vector<Script*> _scripts;
+        Arbutils::Collections::List<Script*> _scripts;
         std::unordered_map<uint32_t, size_t> _lookup;
 
     public:
@@ -24,8 +24,8 @@ namespace CreatureLib::Battling {
                 delete script;
                 return;
             }
-            _scripts.push_back(script);
-            _lookup.insert({script->GetName(), _scripts.size() - 1});
+            _scripts.Append(script);
+            _lookup.insert({script->GetName(), _scripts.Count() - 1});
         }
 
         Script* Get(const ConstString& key) const { return Get(key.GetHash()); }
@@ -46,7 +46,7 @@ namespace CreatureLib::Battling {
                 auto script = _scripts[find->second];
                 script->OnRemove();
                 delete script;
-                _scripts.erase(_scripts.begin() + find.operator*().second);
+                _scripts.Remove(find.operator*().second);
                 _lookup.erase(keyHash);
             }
         }
@@ -55,7 +55,7 @@ namespace CreatureLib::Battling {
             for (auto s : _scripts) {
                 delete s;
             }
-            _scripts.clear();
+            _scripts.Clear();
             _lookup.clear();
         }
 
@@ -63,9 +63,9 @@ namespace CreatureLib::Battling {
 
         bool Has(uint32_t keyHash) const { return _lookup.find(keyHash) != _lookup.end(); }
 
-        size_t Count() const { return _scripts.size(); }
+        size_t Count() const { return _scripts.Count(); }
 
-        const std::vector<Script*>* GetIterator() const { return &_scripts; }
+        const Arbutils::Collections::List<Script*>* GetIterator() const { return &_scripts; }
     };
 }
 

src/Battling/ScriptHandling/ScriptSource.hpp

@@ -8,13 +8,13 @@
 namespace CreatureLib::Battling {
     class ScriptSource {
         bool _areScriptsInitialized = false;
-        std::vector<ScriptWrapper> _scripts;
+        Arbutils::Collections::List<ScriptWrapper> _scripts;
 
     protected:
-        virtual void GetActiveScripts(std::vector<ScriptWrapper>& scripts) = 0;
+        virtual void GetActiveScripts(Arbutils::Collections::List<ScriptWrapper>& scripts) = 0;
         void ResetActiveScripts() {
             _areScriptsInitialized = false;
-            _scripts.clear();
+            _scripts.Clear();
         }
 
     public: