new interface for static_string::delayed_build()

Author: jonathanpoelen

src/mod/rdp/rdp_negociation_data.cpp

@@ -30,15 +30,15 @@ RdpLogonInfo::RdpLogonInfo(bounded_chars_view<0, HOST_NAME_MAX> hostname, bool h
                            char const* target_user, bool split_domain) noexcept
 {
     if (hide_client_name) {
-        this->_hostname.delayed_build([](auto& array) {
+        this->_hostname.delayed_build([](auto buffer) {
+            auto array = buffer.chars_with_null_terminated();
             ::gethostname(array.data(), array.size());
             array.back() = '\0';
             char* separator = strchr(array.data(), '.');
             if (!separator) {
-                return strlen(array.data());
+                return buffer.compute_strlen();
             }
-            size_t hostlen = checked_int(separator - array.data());
-            return hostlen;
+            return buffer.set_end_string_ptr(separator);
         });
     }
     else{

src/utils/ascii.hpp

@@ -346,13 +346,12 @@ namespace detail
     };
 
     template<class Transform>
-    constexpr inline std::size_t unsafe_ascii_to(char* dest, chars_view src, Transform&& transform) noexcept
+    constexpr inline char* unsafe_ascii_to(char* dest, chars_view src, Transform&& transform) noexcept
     {
-        auto* start = dest;
         for (char c : src) {
             *dest++ = transform(c);
         }
-        return std::size_t(dest - start);
+        return dest;
     }
 } // namespace detail
 
@@ -365,7 +364,7 @@ chars_to_tagged_string_array(chars_view str, To&& to)
     if (str.size() <= N) {
         auto& array = detail::StringAsArrayAccess::internal(upper.str);
         auto* p = array.buffer.data();
-        array.len = detail::unsafe_ascii_to(p, str, to);
+        array.len = static_cast<std::size_t>(detail::unsafe_ascii_to(p, str, to) - p);
     }
     return upper;
 }
@@ -377,8 +376,9 @@ chars_to_tagged_zstring_array(chars_view str, To&& to)
 {
     TaggedZStringArray<Tag, N> upper;
     if (str.size() <= N) {
-        upper.str.delayed_build([&](auto& array){
-            return detail::unsafe_ascii_to(array.data(), str, to);
+        upper.str.delayed_build([&](auto buffer){
+            auto* end_ptr = detail::unsafe_ascii_to(buffer.data(), str, to);
+            return buffer.set_end_string_ptr(end_ptr);
         });
     }
     return upper;

src/utils/static_string.hpp

@@ -21,6 +21,7 @@ Author(s): Proxies Team
 #pragma once
 
 #include "utils/sugar/bounded_array_view.hpp"
+#include "utils/sugar/cast.hpp"
 #include "utils/traits/is_null_terminated.hpp"
 #include "utils/traits/static_array_desc.hpp"
 #include "cxx/compiler_version.hpp"
@@ -50,6 +51,76 @@ namespace detail
 } // namespace detail
 
 
+struct delayed_build_string_buffer
+{
+    enum class ResultLen : std::size_t;
+
+    delayed_build_string_buffer(writable_chars_view null_terminated_buffer) noexcept
+      : null_terminated_buffer(null_terminated_buffer)
+    {
+        assert(!null_terminated_buffer.empty());
+    }
+
+    writable_chars_view chars_without_null_terminated() noexcept
+    {
+        return null_terminated_buffer.drop_back(1);
+    }
+
+    writable_chars_view chars_with_null_terminated() noexcept
+    {
+        return null_terminated_buffer;
+    }
+
+    char* data() noexcept
+    {
+        return null_terminated_buffer.data();
+    }
+
+    /// Compute len with strlen().
+    /// \pre buffer is initialized with a valid null terminated c-string
+    ResultLen compute_strlen() noexcept
+    {
+        return ResultLen(strlen(null_terminated_buffer.data()));
+    }
+
+    /// Length of the final string.
+    /// Null terminated is automatically added.
+    ResultLen set_string_len(std::size_t len) noexcept
+    {
+        assert(len < null_terminated_buffer.size());
+        null_terminated_buffer[len] = '\0';
+        return ResultLen(len);
+    }
+
+    /// Position of the final string.
+    /// Null terminated is automatically added.
+    ResultLen set_end_string_ptr(char const* end_ptr) noexcept
+    {
+        return set_string_len(checked_int(end_ptr - null_terminated_buffer.data()));
+    }
+
+    /// Length of the final buffer (with null terminated character).
+    /// \param len length with null terminated char
+    ResultLen set_buffer_len(std::size_t len) noexcept
+    {
+        assert(len > 0);
+        assert(len <= null_terminated_buffer.size());
+        assert(null_terminated_buffer[len - 1] == '\0');
+        return ResultLen(len - 1);
+    }
+
+    /// Position of the final buffer (with null terminated character).
+    /// \param end_ptr position after null terminated char
+    ResultLen set_end_buffer_ptr(char const* end_ptr) noexcept
+    {
+        return set_buffer_len(checked_int(end_ptr - null_terminated_buffer.data()));
+    }
+
+private:
+    writable_chars_view null_terminated_buffer;
+};
+
+
 // N = size without null character
 template<std::size_t N>
 struct static_string
@@ -110,9 +181,9 @@ struct static_string
     template<class Builder>
     void delayed_build(Builder&& builder)
     {
-        m_len = builder(m_str);
-        assert(m_len <= max_capacity());
-        m_str[m_len] = '\0';
+        auto res = builder(delayed_build_string_buffer(make_writable_array_view(m_str)));
+        static_assert(std::is_same_v<decltype(res), delayed_build_string_buffer::ResultLen>);
+        m_len = checked_int(res);
     }
 
     static std::size_t max_capacity() noexcept

tests/utils/test_static_string.cpp

@@ -63,17 +63,65 @@ RED_AUTO_TEST_CASE(TestStaticString)
     s3.clear();
     RED_CHECK_EQUAL(s3, ""_av);
 
-    s3.delayed_build([](auto& array){
-        array[0] = 'a';
-        array[1] = 'b';
-        array[2] = 'c';
-        return checked_int(3u);
+    // set_string_len()
+    s3.delayed_build([](auto buffer) {
+        auto array = buffer.chars_without_null_terminated();
+        std::size_t i = 0;
+        array[i++] = 'a';
+        array[i++] = 'b';
+        array[i++] = 'c';
+        return buffer.set_string_len(i);
     });
     RED_CHECK_EQUAL(s3, "abc"_av);
 
+    // set_null_terminated_string_len()
+    s3.delayed_build([](auto buffer) {
+        auto array = buffer.chars_without_null_terminated();
+        std::size_t i = 0;
+        array[i++] = 'x';
+        array[i++] = 'y';
+        array[i++] = 'z';
+        // '\0' is already present
+        return buffer.compute_strlen();
+    });
+    RED_CHECK_EQUAL(s3, "xyz"_av);
+
+    // set_end_string_ptr()
+    s3.delayed_build([](auto buffer) {
+        auto array = buffer.chars_without_null_terminated().data();
+        *array++ = 'd';
+        *array++ = 'e';
+        return buffer.set_end_string_ptr(array);
+    });
+    RED_CHECK_EQUAL(s3, "de"_av);
+
+    // set_buffer_len()
+    s3.delayed_build([](auto buffer) {
+        auto array = buffer.chars_with_null_terminated();
+        std::size_t i = 0;
+        array[i++] = 'f';
+        array[i++] = 'g';
+        array[i++] = 'h';
+        array[i++] = '\0';
+        return buffer.set_buffer_len(i);
+    });
+    RED_CHECK_EQUAL(s3, "fgh"_av);
+
+    // set_end_buffer_ptr()
+    s3.delayed_build([](auto buffer) {
+        auto array = buffer.chars_with_null_terminated().data();
+        *array++ = 'i';
+        *array++ = 'j';
+        *array++ = '\0';
+        return buffer.set_end_buffer_ptr(array);
+    });
+    RED_CHECK_EQUAL(s3, "ij"_av);
+
     // test that there is no assertion
-    s3.delayed_build([&](auto&){
-        return checked_int(s3.max_capacity());
+    s3.delayed_build([&](auto buffer){
+        auto array = buffer.chars_with_null_terminated();
+        memset(array.data(), 0, array.size());
+        return buffer.set_buffer_len(s3.max_capacity());
     });
 }