From 090af1b8097fecf6b09f3048811a44e11ece3242 Mon Sep 17 00:00:00 2001
From: Dominick Allen <djallen@librehumanitas.org>
Date: Thu, 3 Apr 2025 06:07:34 -0500
Subject: Test hash map extract pair, fix bugs.

---
 include/fud_vector.hpp | 53 +++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 40 insertions(+), 13 deletions(-)

(limited to 'include/fud_vector.hpp')

diff --git a/include/fud_vector.hpp b/include/fud_vector.hpp
index 1ba2abf..b2827b4 100644
--- a/include/fud_vector.hpp
+++ b/include/fud_vector.hpp
@@ -181,9 +181,6 @@ class Vector {
         Builder&& builder,
         Allocator* allocator = &globalFudAllocator)
     {
-        // using BuilderResult = decltype(std::forward<Builder>(builder)(T{}));
-        // static_assert(std::is_same_v<BuilderResult, FudStatus>);
-
         auto status = Vector::initializeWithCapacity(output, count, allocator);
         if (status != FudStatus::Success) {
             return status;
@@ -201,7 +198,7 @@ class Vector {
         return FudStatus::Success;
     }
 
-    static Result<Vector<T>, FudStatus> from(const Vector<T>& rhs, Option<Allocator*> allocatorOption = NullOpt)
+    static Result<Vector<T>, FudStatus> copy(const Vector<T>& rhs, Option<Allocator*> allocatorOption = NullOpt)
     {
         Allocator* allocator = nullptr;
         if (allocatorOption.hasValue()) {
@@ -223,7 +220,7 @@ class Vector {
             return spanResult.takeError();
         }
         Vector<T> output{};
-        auto status = Vector::initializeFromSpan(output, rhs.m_length, allocator);
+        auto status = Vector::initializeFromSpan(output, spanResult.takeOkay(), allocator);
         if (status != FudStatus::Success) {
             return status;
         }
@@ -231,7 +228,7 @@ class Vector {
     }
 
     template <size_t Size>
-    static Result<Vector<T>, FudStatus> from(Span<const T, Size>& rhs, Allocator* allocator)
+    static Result<Vector<T>, FudStatus> from(Span<const T, Size> rhs, Allocator* allocator)
     {
         Vector<T> output{};
         auto status = initializeFromSpan(output, rhs, allocator);
@@ -242,7 +239,7 @@ class Vector {
     }
 
     template <size_t Size>
-    static FudStatus initializeFromSpan(Vector<T>& output, Span<const T, Size>& rhs, Allocator* allocator)
+    static FudStatus initializeFromSpan(Vector<T>& output, Span<const T, Size> rhs, Allocator* allocator)
     {
         auto status = Vector::initializeWithCapacity(output, rhs.size(), allocator);
         if (status != FudStatus::Success) {
@@ -259,7 +256,38 @@ class Vector {
         return Vector<T>{std::move(rhs)};
     }
 
-    FudStatus copy(const Vector<T>& rhs);
+    FudStatus clone(const Vector<T>& rhs)
+    {
+        fudAssert(&rhs != this);
+        auto cleanupStatus = cleanup();
+        if (cleanupStatus != FudStatus::Success) {
+            return cleanupStatus;
+        }
+
+        auto spanResult = rhs.span();
+        if (spanResult.isError()) {
+            return spanResult.takeError();
+        }
+
+        return initializeFromSpan(*this, spanResult.takeOkay(), rhs.m_allocator);
+    }
+
+    FudStatus copy(const Vector<T>& rhs)
+    {
+        fudAssert(&rhs != this);
+        auto* allocator = m_allocator;
+        auto cleanupStatus = cleanup();
+        if (cleanupStatus != FudStatus::Success) {
+            return cleanupStatus;
+        }
+
+        auto spanResult = rhs.span();
+        if (spanResult.isError()) {
+            return spanResult.takeError();
+        }
+
+        return initializeFromSpan(*this, spanResult.takeOkay(), allocator);
+    }
 
     FudStatus take(Vector<T>&& rhs);
 
@@ -280,20 +308,19 @@ class Vector {
 
     Result<Span<const T>, FudStatus> span() const
     {
-        using RetType = Result<Span<const T>, FudStatus>;
         if (m_data == nullptr) {
-            return RetType::error(FudStatus::ObjectInvalid);
+            return Error{FudStatus::ObjectInvalid};
         }
-        return RetType::okay(Span{m_data, m_length});
+        return Okay{Span{m_data, m_length}};
     }
 
     Result<Span<T>, FudStatus> span()
     {
         using RetType = Result<Span<T>, FudStatus>;
         if (m_data == nullptr) {
-            return RetType::error(FudStatus::ObjectInvalid);
+            return Error{FudStatus::ObjectInvalid};
         }
-        return RetType::okay(Span{m_data, m_length});
+        return Okay{Span{m_data, m_length}};
     }
 
     Result<Span<const T>, FudStatus> span(size_t count) const
-- 
cgit v1.2.3