Refactor SSOVector memory management and update usage

Author: Atari2

Playground/main.cpp

@@ -1,15 +1,13 @@
 #include "Tuple.hpp"
 #include "Printer.hpp"
 #include "CharConv.hpp"
+#include "SSOVector.hpp"
+#include "BigInt.hpp"
 
 using namespace ARLib;
 int main([[maybe_unused]] int argc, [[maybe_unused]] char** argv) {
-    auto tup = Tuple("This is a beatiful string"_s);
-    auto tup2 = Tuple("This is another beatiful string"_s);
-    const auto v1 = move(tup).flatten().get<0>();
-    const auto v2   = Tuple("This is a beatiful string"_s).flatten().get<0>();
-    const auto& v3 = tup2.get<0>();
-    Printer::print(R"("{}" "{}" "{}")", v1, v2, tup.get<0>());
-    Printer::print(R"("{}" "{}" "{}")", v3, tup2.get<0>(), &v3 == &tup2.get<0>());
+    auto f2 = BigInt{ "123456781234567891234879169467981276392189732178937891237928173981239812219873218973"_s };
+    auto g2 = BigInt{ "12837127389712389123891738127317892312987389217"_s };
+    auto d = f2 / g2;
     return 0;
 }

include/SSOVector.hpp

@@ -14,13 +14,13 @@ class SSOVector {
         // if grow internal has been called, it means that we need to grow out of situ
         HARD_ASSERT(new_capacity > m_capacity, "New capacity should be bigger than existing capacity")
         if (m_capacity == SSO) {
-            m_storage = allocate_uninitialized<T>(new_capacity);
+            m_storage  = allocate_uninitialized<T>(new_capacity);
             m_capacity = new_capacity;
             if constexpr (SSO != 0) UninitializedMoveConstruct(m_storage, addressof(m_situ_storage[0]), m_size);
         } else {
             T* new_storage = allocate_uninitialized<T>(new_capacity);
             UninitializedMoveConstruct(new_storage, m_storage, m_size);
-            deallocate<T, DeallocType::Multiple>(m_storage);
+            destroy_if_not_sso();
             m_storage  = new_storage;
             m_capacity = new_capacity;
         }
@@ -30,6 +30,12 @@ class SSOVector {
         if (m_size == m_capacity) { grow_to_capacity(m_capacity + 1); }
         new (&m_storage[m_size++]) T{ move(item) };
     }
+    void destroy_if_not_sso() {
+        if (m_capacity > SSO && m_storage != nullptr) {
+            for (size_t i = 0; i < m_size; ++i) { m_storage[i].~T(); }
+            deallocate<T, DeallocType::Multiple>(m_storage);
+        }
+    }
 
     public:
     constexpr SSOVector() = default;
@@ -46,7 +52,7 @@ class SSOVector {
     requires(OTHER_SSO != SSO)
         : m_size(other.size()) {
         if (other.size() > SSO) {
-            m_storage = allocate_uninitialized<T>(other.capacity());
+            m_storage  = allocate_uninitialized<T>(other.capacity());
             m_capacity = other.capacity();
         }
         UninitializedCopyConstruct(m_storage, other.storage(), other.size());
@@ -87,7 +93,7 @@ class SSOVector {
     {
         m_size = other.size();
         if (m_size > m_capacity) {
-            if (m_capacity != SSO) deallocate<T, DeallocType::Multiple>(m_storage);
+            destroy_if_not_sso();
             m_storage  = allocate_initialized<T>(other.capacity());
             m_capacity = other.capacity();
         }
@@ -117,11 +123,11 @@ class SSOVector {
         if (m_capacity > SSO && other.m_size > m_capacity) {
             // if we're already not in situ and we can't fit the other vector, let's resize
             // if we're already not in situ *but* we can fit the other vector, we don't do anything
-            deallocate<T, DeallocType::Multiple>(m_storage);
+            destroy_if_not_sso();
             allocate_initialized<T>(other.m_size);
         } else if (other.m_capacity == SSO && m_capacity > SSO) {
             // if the other one is in situ but we're not, then we delete our storage, since we don't really need it
-            deallocate<T, DeallocType::Multiple>(m_storage);
+            destroy_if_not_sso();
             m_storage = SSO != 0 ? addressof(m_situ_storage[0]) : m_situ_storage;
         }
         m_size     = other.m_size;
@@ -131,7 +137,7 @@ class SSOVector {
     }
     SSOVector& operator=(SSOVector&& other) noexcept {
         if (this == &other) return *this;
-        if (m_capacity > SSO) { deallocate<T, DeallocType::Multiple>(m_storage); }
+        destroy_if_not_sso();
         m_size     = other.m_size;
         m_capacity = other.m_capacity;
         if (other.m_capacity == SSO) {
@@ -178,7 +184,7 @@ class SSOVector {
     }
     void release_strong() {
         if (m_capacity != SSO) {
-            deallocate<T, DeallocType::Multiple>(m_storage);
+            destroy_if_not_sso();
             m_storage  = SSO != 0 ? addressof(m_situ_storage[0]) : m_situ_storage;
             m_capacity = SSO;
         }
@@ -208,6 +214,7 @@ class SSOVector {
                 m_capacity = basic_growth(m_capacity + 1);
                 m_storage  = allocate_uninitialized<T>(m_capacity);
                 UninitializedCopyConstruct(m_storage + sizeof(T), storage, m_size);
+                for (size_t i = 0; i < m_size; i++) { storage[i].~T(); }
                 deallocate<T, DeallocType::Multiple>(storage);
             }
         } else {
@@ -228,9 +235,7 @@ class SSOVector {
     {
         if (new_size < m_size) return;
         if (new_size > m_capacity) { grow_to_capacity(new_size); }
-        for (size_t i = m_size; i < new_size; i++) {   
-            new (&m_storage[i]) T{}; 
-        }
+        for (size_t i = m_size; i < new_size; i++) { new (&m_storage[i]) T{}; }
         m_size = new_size;
     }
     void reserve(size_t new_capacity) {
@@ -243,9 +248,7 @@ class SSOVector {
     }
     const T& last() const { return m_storage[m_size - 1]; }
     T& last() { return m_storage[m_size - 1]; }
-    ~SSOVector() {
-        if (m_capacity > SSO) deallocate<T, DeallocType::Multiple>(m_storage);
-    }
+    ~SSOVector() { destroy_if_not_sso(); }
 };
 template <Printable T, size_t S>
 struct PrintInfo<SSOVector<T, S>> {

include/Stream.hpp

@@ -56,6 +56,7 @@ struct CharacterStream : public BaseStream {
     virtual Result<String> read_line(bool& eof_reached)    = 0;
     virtual bool is_open() const                           = 0;
     virtual bool operator==(const CharacterStream& other) const { return this == &other; }
+    virtual bool is_filestream() const { return false; }
     virtual ~CharacterStream() = default;
 };
 class FileStream : public CharacterStream {
@@ -77,10 +78,11 @@ class FileStream : public CharacterStream {
     size_t seek(size_t) override;
     bool operator==(const FileStream& other) const;
     bool operator==(const CharacterStream& other) const override {
-        if (const auto* fs = dynamic_cast<const FileStream*>(&other); fs != nullptr) { return *this == *fs; }
+        if (other.is_filestream()) { return *this == static_cast<const FileStream&>(other); }
         return false;
     }
     bool is_open() const override { return m_file.is_open(); }
+    bool is_filestream() const override { return true;  }
     virtual ~FileStream() = default;
 };
 class BufferedFileStream : public FileStream {