fix(dev): Make sure C++ knows ustring & ustringhash are trivially copyable (#4110)

*  Use default implementations of copy ctr, destructor, and assignment
    from ustring. This allows ustring & ustringhash to be recognized as
    being a variety of flavors of trivially constructible, copyable, and
    destructible.

*   It seems that the assignment operators were returning const &
    whereas it's more typical to return &, so now we do.

Signed-off-by: Larry Gritz <lg@larrygritz.com>

Author: lgritz

src/include/OpenImageIO/ustring.h

@@ -184,10 +184,7 @@ class OIIO_UTIL_API ustring {
     }
 
     /// Copy construct a ustring from another ustring.
-    ustring(const ustring& str) noexcept
-        : m_chars(str.m_chars)
-    {
-    }
+    ustring(const ustring& str) noexcept = default;
 
     /// Construct a ustring from an indexed substring of a ustring.
     ustring(const ustring& str, size_type pos, size_type n = npos)
@@ -203,7 +200,7 @@ class OIIO_UTIL_API ustring {
 #endif
 
     /// ustring destructor.
-    ~ustring() noexcept {}
+    ~ustring() noexcept = default;
 
     /// Conversion to an OIIO::string_view.
     operator string_view() const noexcept { return { c_str(), length() }; }
@@ -212,79 +209,75 @@ class OIIO_UTIL_API ustring {
     explicit operator std::string() const noexcept { return string(); }
 
     /// Assign a ustring to *this.
-    const ustring& assign(const ustring& str)
+    ustring& assign(const ustring& str)
     {
         m_chars = str.m_chars;
         return *this;
     }
 
     /// Assign a substring of a ustring to *this.
-    const ustring& assign(const ustring& str, size_type pos, size_type n = npos)
+    ustring& assign(const ustring& str, size_type pos, size_type n = npos)
     {
         *this = ustring(str, pos, n);
         return *this;
     }
 
     /// Assign a std::string to *this.
-    const ustring& assign(const std::string& str)
+    ustring& assign(const std::string& str)
     {
         assign(str.c_str());
         return *this;
     }
 
     /// Assign a substring of a std::string to *this.
-    const ustring& assign(const std::string& str, size_type pos,
-                          size_type n = npos)
+    ustring& assign(const std::string& str, size_type pos, size_type n = npos)
     {
         *this = ustring(str, pos, n);
         return *this;
     }
 
     /// Assign a null-terminated C string (char*) to *this.
-    const ustring& assign(const char* str)
+    ustring& assign(const char* str)
     {
         m_chars = str ? make_unique(str) : nullptr;
         return *this;
     }
 
     /// Assign the first n characters of str to *this.
-    const ustring& assign(const char* str, size_type n)
+    ustring& assign(const char* str, size_type n)
     {
         *this = ustring(str, n);
         return *this;
     }
 
     /// Assign n copies of c to *this.
-    const ustring& assign(size_type n, char c)
+    ustring& assign(size_type n, char c)
     {
         *this = ustring(n, c);
         return *this;
     }
 
     /// Assign a string_view to *this.
-    const ustring& assign(string_view str)
+    ustring& assign(string_view str)
     {
         m_chars = str.length() ? make_unique(str) : nullptr;
         return *this;
     }
 
     /// Assign a ustring to another ustring.
-    const ustring& operator=(const ustring& str) { return assign(str); }
+    ustring& operator=(const ustring& str) noexcept = default;
 
     /// Assign a null-terminated C string (char *) to a ustring.
-    const ustring& operator=(const char* str) { return assign(str); }
+    ustring& operator=(const char* str) { return assign(str); }
 
     /// Assign a C++ std::string to a ustring.
-    const ustring& operator=(const std::string& str) { return assign(str); }
+    ustring& operator=(const std::string& str) { return assign(str); }
 
     /// Assign a string_view to a ustring.
-    const ustring& operator=(string_view str) { return assign(str); }
+    ustring& operator=(string_view str) { return assign(str); }
 
     /// Assign a single char to a ustring.
-    const ustring& operator=(char c)
-    {
-        return *this = ustring(string_view(&c, 1));
-    }
+    ustring& operator=(char c) { return *this = ustring(string_view(&c, 1)); }
 
     /// Return a C string representation of a ustring.
     const char* c_str() const noexcept { return m_chars; }
@@ -804,9 +797,10 @@ class OIIO_UTIL_API ustringhash {
 
     /// Copy construct a ustringhash from another ustringhash.
     OIIO_HOSTDEVICE constexpr ustringhash(const ustringhash& str) noexcept
-        : m_hash(str.m_hash)
-    {
-    }
+        = default;
+
+    /// Move construct a ustringhash from another ustringhash.
+    OIIO_HOSTDEVICE ustringhash(ustringhash&& str) noexcept = default;
 
     /// Construct from a ustring
     ustringhash(const ustring& str) noexcept
@@ -870,15 +864,12 @@ class OIIO_UTIL_API ustringhash {
     }
 
     /// Assign from a ustringhash
-    OIIO_HOSTDEVICE constexpr const ustringhash&
-    operator=(const ustringhash& str)
-    {
-        m_hash = str.m_hash;
-        return *this;
-    }
+    OIIO_HOSTDEVICE constexpr ustringhash& operator=(const ustringhash& str)
+        = default;
+    OIIO_HOSTDEVICE ustringhash& operator=(ustringhash&& str) = default;
 
     /// Assign from a ustring
-    const ustringhash& operator=(const ustring& str)
+    ustringhash& operator=(const ustring& str)
     {
         m_hash = str.hash();
         return *this;

src/libutil/ustring_test.cpp

@@ -76,6 +76,13 @@ test_ustring()
     ustring foo("foo"), bar("bar"), empty(""), uninit;
     ustring foobarbaz("foobarbaz");
 
+    OIIO_CHECK_ASSERT(std::is_default_constructible<OIIO::ustring>());
+    OIIO_CHECK_ASSERT(std::is_trivially_copyable<OIIO::ustring>());
+    OIIO_CHECK_ASSERT(std::is_trivially_destructible<OIIO::ustring>());
+    OIIO_CHECK_ASSERT(std::is_trivially_move_constructible<OIIO::ustring>());
+    OIIO_CHECK_ASSERT(std::is_trivially_copy_constructible<OIIO::ustring>());
+    OIIO_CHECK_ASSERT(std::is_trivially_move_assignable<OIIO::ustring>());
+
     // Size of a ustring is just a pointer
     OIIO_CHECK_EQUAL(sizeof(ustring), sizeof(const char*));
 
@@ -171,6 +178,16 @@ test_ustringhash()
 {
     // Two ustrings
     ustring foo("foo"), bar("bar");
+
+    OIIO_CHECK_ASSERT(std::is_default_constructible<OIIO::ustringhash>());
+    OIIO_CHECK_ASSERT(std::is_trivially_copyable<OIIO::ustringhash>());
+    OIIO_CHECK_ASSERT(std::is_trivially_destructible<OIIO::ustringhash>());
+    OIIO_CHECK_ASSERT(
+        std::is_trivially_move_constructible<OIIO::ustringhash>());
+    OIIO_CHECK_ASSERT(
+        std::is_trivially_copy_constructible<OIIO::ustringhash>());
+    OIIO_CHECK_ASSERT(std::is_trivially_move_assignable<OIIO::ustringhash>());
+
     OIIO_CHECK_EQUAL(sizeof(ustringhash), sizeof(size_t));
 
     // Make two ustringhash's from strings
@@ -288,7 +305,7 @@ verify_no_collisions()
 {
     // Try to force a hash collision
     parallel_for(int64_t(0), int64_t(1000000LL * int64_t(collide)),
-                 [](int64_t i) { ustring u = ustring::fmtformat("{:x}", i); });
+                 [](int64_t i) { (void)ustring::fmtformat("{:x}", i); });
     std::vector<ustring> collisions;
     size_t ncollisions = ustring::hash_collisions(&collisions);
     OIIO_CHECK_ASSERT(ncollisions == 0);