Adds documentation and fixes a couple issues.

src/Memory/BorrowedPtr.hpp

@@ -32,7 +32,7 @@ namespace ArbUt {
             _raw = rhs._raw;
             return *this;
         }
-
+        /// @brief Assign operator with raw pointer.
         inline BorrowedPtr<T>& operator=(T* rhs) {
             if (_raw == &rhs)
                 return *this;
@@ -40,6 +40,7 @@ namespace ArbUt {
             _raw = rhs;
             return *this;
         }
+        /// @brief Don't allow nullptr assignments
         inline BorrowedPtr<T>& operator=(std::nullptr_t) = delete;
 
         /// @brief Operator for access into underlying pointer.

src/Memory/OptionalBorrowedPtr.hpp

@@ -26,12 +26,19 @@ namespace ArbUt {
         ~OptionalBorrowedPtr() noexcept = default;
 
         /// @brief Copy operator.
-        inline OptionalBorrowedPtr<T>& operator=(const BorrowedPtr<T>& rhs) {
+        inline OptionalBorrowedPtr<T>& operator=(const OptionalBorrowedPtr<T>& rhs) {
             if (this == &rhs)
                 return *this;
             _raw = rhs._raw;
             return *this;
         }
+        /// @brief Assign operator with raw pointer.
+        inline OptionalBorrowedPtr<T>& operator=(T* rhs) {
+            if (_raw == &rhs)
+                return *this;
+            _raw = rhs;
+            return *this;
+        }
 
         /// @brief Return whether the pointer is null or not.
         [[nodiscard]] inline bool HasValue() const noexcept { return _raw == nullptr; }

src/Memory/OptionalUniquePtr.hpp

@@ -32,7 +32,8 @@ namespace ArbUt {
             return *this;
         }
 
-        inline OptionalUniquePtr<T>& operator=(__attribute__((nonnull)) T* rhs) {
+        /// @brief Assign operator with raw pointer.
+        inline OptionalUniquePtr<T>& operator=(T* rhs) {
             if (_raw == &rhs)
                 return *this;
             _raw = rhs;

src/Memory/ScopedPtr.hpp

@@ -30,17 +30,20 @@ namespace ArbUt {
             return *this;
         }
 
+        /// @brief Assign operator with raw pointer.
         inline ScopedPtr<T>& operator=(T* rhs) {
             if (_raw == &rhs)
                 return *this;
-            AssertNotNull(rhs);
             _raw = rhs;
             return *this;
         }
 
         /// @brief Operator for access into underlying pointer.
         /// @warning Note that this asserts that the underlying pointer is not null first, to prevent segfaults.
-        inline T* operator->() const noexcept { return _raw; }
+        inline T* operator->() const noexcept {
+            AssertNotNull(_raw);
+            return _raw;
+        }
 
         /// @brief Get the raw underlying pointer.
         inline T* TakeOwnership() const noexcept {

src/Memory/UniquePtr.hpp

@@ -34,6 +34,7 @@ namespace ArbUt {
             return *this;
         }
 
+        /// @brief Assign operator with raw pointer.
         inline UniquePtr<T>& operator=(T* rhs) {
             if (_raw == &rhs) {
                 return *this;
@@ -43,6 +44,8 @@ namespace ArbUt {
             _raw = rhs;
             return *this;
         }
+
+        /// @brief Don't allow nullptr assignments
         inline UniquePtr<T>& operator=(std::nullptr_t) = delete;
 
         /// @brief Operator for access into underlying pointer.