Merge pull request #46 from zrax/lifetimebound

zrax · web-flow · commit 42e68a970993 · 2025-01-10T12:58:36.000-08:00
Annotate functions with `[[lifetimebound]]` attribute where applicable.
diff --git a/include/st_charbuffer.h b/include/st_charbuffer.h
@@ -158,13 +158,13 @@ namespace ST
         }
 
         ST_DEPRECATED_IN_3_4("Use clear() instead")
-        buffer<char_T> &operator=(const null_t &) noexcept
+        buffer<char_T> &operator=(const null_t &) noexcept ST_LIFETIME_BOUND
         {
             clear();
             return *this;
         }
 
-        buffer<char_T> &operator=(const buffer<char_T> &copy)
+        buffer<char_T> &operator=(const buffer<char_T> &copy) ST_LIFETIME_BOUND
         {
             if (this == &copy)
                 return *this;
@@ -186,7 +186,7 @@ namespace ST
             return *this;
         }
 
-        buffer<char_T> &operator=(buffer<char_T> &&move) noexcept
+        buffer<char_T> &operator=(buffer<char_T> &&move) noexcept ST_LIFETIME_BOUND
         {
             std::swap(m_chars, move.m_chars);
             std::swap(m_size, move.m_size);
@@ -275,16 +275,17 @@ namespace ST
         }
 
         ST_NODISCARD
-        char_T *data() noexcept { return m_chars; }
+        char_T *data() noexcept ST_LIFETIME_BOUND { return m_chars; }
 
         ST_NODISCARD
-        const char_T *data() const noexcept { return m_chars; }
+        const char_T *data() const noexcept ST_LIFETIME_BOUND { return m_chars; }
 
         ST_NODISCARD
-        const char_T *c_str() const noexcept { return m_chars; }
+        const char_T *c_str() const noexcept ST_LIFETIME_BOUND { return m_chars; }
 
         ST_NODISCARD
-        const char_T *c_str(const char_T *substitute) const noexcept
+        const char_T *c_str(const char_T *substitute ST_LIFETIME_BOUND)
+            const noexcept ST_LIFETIME_BOUND
         {
             return empty() ? substitute : m_chars;
         }
@@ -296,107 +297,113 @@ namespace ST
         bool empty() const noexcept { return m_size == 0; }
 
         ST_NODISCARD
-        char_T &at(size_t index)
+        char_T &at(size_t index) ST_LIFETIME_BOUND
         {
             if (index >= size())
                 throw std::out_of_range("Character index out of range");
             return m_chars[index];
         }
 
         ST_NODISCARD
-        const char_T &at(size_t index) const
+        const char_T &at(size_t index) const ST_LIFETIME_BOUND
         {
             if (index >= size())
                 throw std::out_of_range("Character index out of range");
             return m_chars[index];
         }
 
         ST_NODISCARD
-        char_T &operator[](size_t index) noexcept
+        char_T &operator[](size_t index) noexcept ST_LIFETIME_BOUND
         {
             return m_chars[index];
         }
 
         ST_NODISCARD
-        const char_T &operator[](size_t index) const noexcept
+        const char_T &operator[](size_t index) const noexcept ST_LIFETIME_BOUND
         {
             return m_chars[index];
         }
 
         ST_NODISCARD
-        char_T &front() noexcept
+        char_T &front() noexcept ST_LIFETIME_BOUND
         {
             return m_chars[0];
         }
 
         ST_NODISCARD
-        const char_T &front() const noexcept
+        const char_T &front() const noexcept ST_LIFETIME_BOUND
         {
             return m_chars[0];
         }
 
         ST_NODISCARD
-        char_T &back() noexcept
+        char_T &back() noexcept ST_LIFETIME_BOUND
         {
             return empty() ? m_chars[0] : m_chars[m_size - 1];
         }
 
         ST_NODISCARD
-        const char_T &back() const noexcept
+        const char_T &back() const noexcept ST_LIFETIME_BOUND
         {
             return empty() ? m_chars[0] : m_chars[m_size - 1];
         }
 
         ST_NODISCARD
-        iterator begin() noexcept { return m_chars; }
+        iterator begin() noexcept ST_LIFETIME_BOUND { return m_chars; }
 
         ST_NODISCARD
-        const_iterator begin() const noexcept { return m_chars; }
+        const_iterator begin() const noexcept ST_LIFETIME_BOUND { return m_chars; }
 
         ST_NODISCARD
-        const_iterator cbegin() const noexcept { return m_chars; }
+        const_iterator cbegin() const noexcept ST_LIFETIME_BOUND { return m_chars; }
 
         ST_NODISCARD
-        iterator end() noexcept { return m_chars + m_size; }
+        iterator end() noexcept ST_LIFETIME_BOUND { return m_chars + m_size; }
 
         ST_NODISCARD
-        const_iterator end() const noexcept { return m_chars + m_size; }
+        const_iterator end() const noexcept ST_LIFETIME_BOUND
+        {
+            return m_chars + m_size;
+        }
 
         ST_NODISCARD
-        const_iterator cend() const noexcept { return m_chars + m_size; }
+        const_iterator cend() const noexcept ST_LIFETIME_BOUND
+        {
+            return m_chars + m_size;
+        }
 
         ST_NODISCARD
-        reverse_iterator rbegin() noexcept
+        reverse_iterator rbegin() noexcept ST_LIFETIME_BOUND
         {
             return reverse_iterator(end());
         }
 
         ST_NODISCARD
-        const_reverse_iterator rbegin() const noexcept
+        const_reverse_iterator rbegin() const noexcept ST_LIFETIME_BOUND
         {
             return const_reverse_iterator(end());
         }
 
         ST_NODISCARD
-        const_reverse_iterator crbegin() const noexcept
+        const_reverse_iterator crbegin() const noexcept ST_LIFETIME_BOUND
         {
             return const_reverse_iterator(cend());
         }
 
         ST_NODISCARD
-        reverse_iterator rend() noexcept
+        reverse_iterator rend() noexcept ST_LIFETIME_BOUND
         {
             return reverse_iterator(begin());
         }
 
         ST_NODISCARD
-        const_reverse_iterator rend() const noexcept
+        const_reverse_iterator rend() const noexcept ST_LIFETIME_BOUND
         {
             return const_reverse_iterator(begin());
         }
 
         ST_NODISCARD
-        const_reverse_iterator crend() const noexcept
+        const_reverse_iterator crend() const noexcept ST_LIFETIME_BOUND
         {
             return const_reverse_iterator(cbegin());
         }
@@ -437,6 +444,7 @@ namespace ST
         ST_NODISCARD
         std::basic_string_view<char_T> view(size_t start = 0,
                                             size_t length = ST_AUTO_SIZE) const &
+            ST_LIFETIME_BOUND
         {
             if (length == ST_AUTO_SIZE)
                 length = size() - start;
diff --git a/include/st_config.h.in b/include/st_config.h.in
@@ -104,6 +104,18 @@
 #   define ST_NODISCARD
 #endif
 
+#ifndef __has_cpp_attribute
+#   define ST_LIFETIME_BOUND
+#elif __has_cpp_attribute(msvc::lifetimebound)
+#   define ST_LIFETIME_BOUND [[msvc::lifetimebound]]
+#elif __has_cpp_attribute(clang::lifetimebound)
+#   define ST_LIFETIME_BOUND [[clang::lifetimebound]]
+#elif __has_cpp_attribute(lifetimebound)
+#   define ST_LIFETIME_BOUND [[lifetimebound]]
+#else
+#   define ST_LIFETIME_BOUND
+#endif
+
 #define ST_MAX_SSO_LENGTH       (16)
 #define ST_MAX_SSO_SIZE         (48)
 #define ST_STACK_STRING_SIZE    (256)
diff --git a/include/st_format.h b/include/st_format.h
@@ -32,13 +32,15 @@ namespace _ST_PRIVATE
         explicit string_format_writer(const char *format_str)
             : ST::format_writer(format_str) { }
 
-        string_format_writer &append(const char *data, size_t size) override
+        string_format_writer &append(const char *data, size_t size)
+            ST_LIFETIME_BOUND override
         {
             m_output.append(data, size);
             return *this;
         }
 
-        string_format_writer &append_char(char ch, size_t count = 1) override
+        string_format_writer &append_char(char ch, size_t count = 1)
+            ST_LIFETIME_BOUND override
         {
             m_output.append_char(ch, count);
             return *this;
diff --git a/include/st_format_numeric.h b/include/st_format_numeric.h
@@ -74,7 +74,7 @@ namespace ST
         }
 
         ST_NODISCARD
-        const char *text() const noexcept { return m_start; }
+        const char *text() const noexcept ST_LIFETIME_BOUND { return m_start; }
 
         ST_NODISCARD
         size_t size() const noexcept
@@ -106,7 +106,7 @@ namespace ST
         }
 
         ST_NODISCARD
-        const char *text() const noexcept { return m_buffer; }
+        const char *text() const noexcept ST_LIFETIME_BOUND { return m_buffer; }
 
         ST_NODISCARD
         size_t size() const noexcept { return m_size; }
diff --git a/include/st_formatter.h b/include/st_formatter.h
@@ -107,15 +107,15 @@ namespace ST
         format_writer& operator=(const format_writer&) = delete;
 
         format_writer(format_writer&&) = default;
-        format_writer& operator=(format_writer&&) = default;
+        format_writer& operator=(format_writer&&) ST_LIFETIME_BOUND = default;
 
         virtual ~format_writer() noexcept { }
 
-        virtual format_writer &append(const char *data, size_t size) = 0;
-        virtual format_writer &append_char(char ch, size_t count = 1) = 0;
+        virtual format_writer &append(const char *data, size_t size) ST_LIFETIME_BOUND = 0;
+        virtual format_writer &append_char(char ch, size_t count = 1) ST_LIFETIME_BOUND = 0;
 
         template <size_t size>
-        format_writer &append(const char (&literal)[size])
+        format_writer &append(const char (&literal)[size]) ST_LIFETIME_BOUND
         {
             return append(literal, size - 1);
         }
diff --git a/include/st_iostream.h b/include/st_iostream.h
@@ -68,13 +68,15 @@ namespace _ST_PRIVATE
             m_stream.write(utf32.data(), utf32.size());
         }
 
-        ostream_format_writer &append(const char *data, size_t size) override
+        ostream_format_writer &append(const char *data, size_t size)
+            ST_LIFETIME_BOUND override
         {
             write_data<char_T>(data, size);
             return *this;
         }
 
-        ostream_format_writer &append_char(char ch, size_t count = 1) override
+        ostream_format_writer &append_char(char ch, size_t count = 1)
+            ST_LIFETIME_BOUND override
         {
             while (count) {
                 m_stream.put(char_T(ch));
@@ -101,7 +103,8 @@ namespace ST
 
 template <class char_T, class traits_T>
 std::basic_ostream<char_T, traits_T> &operator<<(
-        std::basic_ostream<char_T, traits_T> &stream, const ST::string &str)
+        std::basic_ostream<char_T, traits_T> &stream ST_LIFETIME_BOUND,
+        const ST::string &str)
 {
     ST::buffer<char_T> buffer;
     str.to_buffer(buffer);
@@ -110,7 +113,8 @@ std::basic_ostream<char_T, traits_T> &operator<<(
 
 template <class char_T, class traits_T>
 std::basic_istream<char_T, traits_T> &operator>>(
-        std::basic_istream<char_T, traits_T> &stream, ST::string &str)
+        std::basic_istream<char_T, traits_T> &stream ST_LIFETIME_BOUND,
+        ST::string &str)
 {
     std::basic_string<char_T, traits_T> stl_string;
     stream >> stl_string;
diff --git a/include/st_stdio.h b/include/st_stdio.h
@@ -31,13 +31,15 @@ namespace _ST_PRIVATE
         stdio_format_writer(const char *format_str, FILE *stream)
             : ST::format_writer(format_str), m_stream(stream) { }
 
-        stdio_format_writer &append(const char *data, size_t size) override
+        stdio_format_writer &append(const char *data, size_t size)
+            ST_LIFETIME_BOUND override
         {
             (void)fwrite(data, sizeof(char), size, m_stream);
             return *this;
         }
 
-        stdio_format_writer &append_char(char ch, size_t count = 1) override
+        stdio_format_writer &append_char(char ch, size_t count = 1)
+            ST_LIFETIME_BOUND override
         {
             while (count) {
                 fputc(ch, m_stream);
diff --git a/include/st_string.h b/include/st_string.h
diff --git a/include/st_string_priv.h b/include/st_string_priv.h
diff --git a/include/st_stringstream.h b/include/st_stringstream.h

Original file line number	Diff line number	Diff line change
`@@ -158,13 +158,13 @@ namespace ST`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`ST_DEPRECATED_IN_3_4("Use clear() instead")`
`161`		`- buffer<char_T> &operator=(const null_t &) noexcept`
	`161`	`+ buffer<char_T> &operator=(const null_t &) noexcept ST_LIFETIME_BOUND`
`162`	`162`	`{`
`163`	`163`	`clear();`
`164`	`164`	`return *this;`
`165`	`165`	`}`
`166`	`166`
`167`		`- buffer<char_T> &operator=(const buffer<char_T> &copy)`
	`167`	`+ buffer<char_T> &operator=(const buffer<char_T> &copy) ST_LIFETIME_BOUND`
`168`	`168`	`{`
`169`	`169`	`if (this == &copy)`
`170`	`170`	`return *this;`
`@@ -186,7 +186,7 @@ namespace ST`
`186`	`186`	`return *this;`
`187`	`187`	`}`
`188`	`188`
`189`		`- buffer<char_T> &operator=(buffer<char_T> &&move) noexcept`
	`189`	`+ buffer<char_T> &operator=(buffer<char_T> &&move) noexcept ST_LIFETIME_BOUND`
`190`	`190`	`{`
`191`	`191`	`std::swap(m_chars, move.m_chars);`
`192`	`192`	`std::swap(m_size, move.m_size);`
`@@ -275,16 +275,17 @@ namespace ST`
`275`	`275`	`}`
`276`	`276`
`277`	`277`	`ST_NODISCARD`
`278`		`- char_T *data() noexcept { return m_chars; }`
	`278`	`+ char_T *data() noexcept ST_LIFETIME_BOUND { return m_chars; }`
`279`	`279`
`280`	`280`	`ST_NODISCARD`
`281`		`- const char_T *data() const noexcept { return m_chars; }`
	`281`	`+ const char_T *data() const noexcept ST_LIFETIME_BOUND { return m_chars; }`
`282`	`282`
`283`	`283`	`ST_NODISCARD`
`284`		`- const char_T *c_str() const noexcept { return m_chars; }`
	`284`	`+ const char_T *c_str() const noexcept ST_LIFETIME_BOUND { return m_chars; }`
`285`	`285`
`286`	`286`	`ST_NODISCARD`
`287`		`- const char_T c_str(const char_T substitute) const noexcept`
	`287`	`+ const char_T c_str(const char_T substitute ST_LIFETIME_BOUND)`
	`288`	`+ const noexcept ST_LIFETIME_BOUND`
`288`	`289`	`{`
`289`	`290`	`return empty() ? substitute : m_chars;`
`290`	`291`	`}`
`@@ -296,107 +297,113 @@ namespace ST`
`296`	`297`	`bool empty() const noexcept { return m_size == 0; }`
`297`	`298`
`298`	`299`	`ST_NODISCARD`
`299`		`- char_T &at(size_t index)`
	`300`	`+ char_T &at(size_t index) ST_LIFETIME_BOUND`
`300`	`301`	`{`
`301`	`302`	`if (index >= size())`
`302`	`303`	`throw std::out_of_range("Character index out of range");`
`303`	`304`	`return m_chars[index];`
`304`	`305`	`}`
`305`	`306`
`306`	`307`	`ST_NODISCARD`
`307`		`- const char_T &at(size_t index) const`
	`308`	`+ const char_T &at(size_t index) const ST_LIFETIME_BOUND`
`308`	`309`	`{`
`309`	`310`	`if (index >= size())`
`310`	`311`	`throw std::out_of_range("Character index out of range");`
`311`	`312`	`return m_chars[index];`
`312`	`313`	`}`
`313`	`314`
`314`	`315`	`ST_NODISCARD`
`315`		`- char_T &operator[](size_t index) noexcept`
	`316`	`+ char_T &operator[](size_t index) noexcept ST_LIFETIME_BOUND`
`316`	`317`	`{`
`317`	`318`	`return m_chars[index];`
`318`	`319`	`}`
`319`	`320`
`320`	`321`	`ST_NODISCARD`
`321`		`- const char_T &operator[](size_t index) const noexcept`
	`322`	`+ const char_T &operator[](size_t index) const noexcept ST_LIFETIME_BOUND`
`322`	`323`	`{`
`323`	`324`	`return m_chars[index];`
`324`	`325`	`}`
`325`	`326`
`326`	`327`	`ST_NODISCARD`
`327`		`- char_T &front() noexcept`
	`328`	`+ char_T &front() noexcept ST_LIFETIME_BOUND`
`328`	`329`	`{`
`329`	`330`	`return m_chars[0];`
`330`	`331`	`}`
`331`	`332`
`332`	`333`	`ST_NODISCARD`
`333`		`- const char_T &front() const noexcept`
	`334`	`+ const char_T &front() const noexcept ST_LIFETIME_BOUND`
`334`	`335`	`{`
`335`	`336`	`return m_chars[0];`
`336`	`337`	`}`
`337`	`338`
`338`	`339`	`ST_NODISCARD`
`339`		`- char_T &back() noexcept`
	`340`	`+ char_T &back() noexcept ST_LIFETIME_BOUND`
`340`	`341`	`{`
`341`	`342`	`return empty() ? m_chars[0] : m_chars[m_size - 1];`
`342`	`343`	`}`
`343`	`344`
`344`	`345`	`ST_NODISCARD`
`345`		`- const char_T &back() const noexcept`
	`346`	`+ const char_T &back() const noexcept ST_LIFETIME_BOUND`
`346`	`347`	`{`
`347`	`348`	`return empty() ? m_chars[0] : m_chars[m_size - 1];`
`348`	`349`	`}`
`349`	`350`
`350`	`351`	`ST_NODISCARD`
`351`		`- iterator begin() noexcept { return m_chars; }`
	`352`	`+ iterator begin() noexcept ST_LIFETIME_BOUND { return m_chars; }`
`352`	`353`
`353`	`354`	`ST_NODISCARD`
`354`		`- const_iterator begin() const noexcept { return m_chars; }`
	`355`	`+ const_iterator begin() const noexcept ST_LIFETIME_BOUND { return m_chars; }`
`355`	`356`
`356`	`357`	`ST_NODISCARD`
`357`		`- const_iterator cbegin() const noexcept { return m_chars; }`
	`358`	`+ const_iterator cbegin() const noexcept ST_LIFETIME_BOUND { return m_chars; }`
`358`	`359`
`359`	`360`	`ST_NODISCARD`
`360`		`- iterator end() noexcept { return m_chars + m_size; }`
	`361`	`+ iterator end() noexcept ST_LIFETIME_BOUND { return m_chars + m_size; }`
`361`	`362`
`362`	`363`	`ST_NODISCARD`
`363`		`- const_iterator end() const noexcept { return m_chars + m_size; }`
	`364`	`+ const_iterator end() const noexcept ST_LIFETIME_BOUND`
	`365`	`+ {`
	`366`	`+ return m_chars + m_size;`
	`367`	`+ }`
`364`	`368`
`365`	`369`	`ST_NODISCARD`
`366`		`- const_iterator cend() const noexcept { return m_chars + m_size; }`
	`370`	`+ const_iterator cend() const noexcept ST_LIFETIME_BOUND`
	`371`	`+ {`
	`372`	`+ return m_chars + m_size;`
	`373`	`+ }`
`367`	`374`
`368`	`375`	`ST_NODISCARD`
`369`		`- reverse_iterator rbegin() noexcept`
	`376`	`+ reverse_iterator rbegin() noexcept ST_LIFETIME_BOUND`
`370`	`377`	`{`
`371`	`378`	`return reverse_iterator(end());`
`372`	`379`	`}`
`373`	`380`
`374`	`381`	`ST_NODISCARD`
`375`		`- const_reverse_iterator rbegin() const noexcept`
	`382`	`+ const_reverse_iterator rbegin() const noexcept ST_LIFETIME_BOUND`
`376`	`383`	`{`
`377`	`384`	`return const_reverse_iterator(end());`
`378`	`385`	`}`
`379`	`386`
`380`	`387`	`ST_NODISCARD`
`381`		`- const_reverse_iterator crbegin() const noexcept`
	`388`	`+ const_reverse_iterator crbegin() const noexcept ST_LIFETIME_BOUND`
`382`	`389`	`{`
`383`	`390`	`return const_reverse_iterator(cend());`
`384`	`391`	`}`
`385`	`392`
`386`	`393`	`ST_NODISCARD`
`387`		`- reverse_iterator rend() noexcept`
	`394`	`+ reverse_iterator rend() noexcept ST_LIFETIME_BOUND`
`388`	`395`	`{`
`389`	`396`	`return reverse_iterator(begin());`
`390`	`397`	`}`
`391`	`398`
`392`	`399`	`ST_NODISCARD`
`393`		`- const_reverse_iterator rend() const noexcept`
	`400`	`+ const_reverse_iterator rend() const noexcept ST_LIFETIME_BOUND`
`394`	`401`	`{`
`395`	`402`	`return const_reverse_iterator(begin());`
`396`	`403`	`}`
`397`	`404`
`398`	`405`	`ST_NODISCARD`
`399`		`- const_reverse_iterator crend() const noexcept`
	`406`	`+ const_reverse_iterator crend() const noexcept ST_LIFETIME_BOUND`
`400`	`407`	`{`
`401`	`408`	`return const_reverse_iterator(cbegin());`
`402`	`409`	`}`
`@@ -437,6 +444,7 @@ namespace ST`
`437`	`444`	`ST_NODISCARD`
`438`	`445`	`std::basic_string_view<char_T> view(size_t start = 0,`
`439`	`446`	`size_t length = ST_AUTO_SIZE) const &`
	`447`	`+ ST_LIFETIME_BOUND`
`440`	`448`	`{`
`441`	`449`	`if (length == ST_AUTO_SIZE)`
`442`	`450`	`length = size() - start;`
Original file line number	Diff line number	Diff line change
`@@ -32,13 +32,15 @@ namespace _ST_PRIVATE`
`32`	`32`	`explicit string_format_writer(const char *format_str)`
`33`	`33`	`: ST::format_writer(format_str) { }`
`34`	`34`
`35`		`- string_format_writer &append(const char *data, size_t size) override`
	`35`	`+ string_format_writer &append(const char *data, size_t size)`
	`36`	`+ ST_LIFETIME_BOUND override`
`36`	`37`	`{`
`37`	`38`	`m_output.append(data, size);`
`38`	`39`	`return *this;`
`39`	`40`	`}`
`40`	`41`
`41`		`- string_format_writer &append_char(char ch, size_t count = 1) override`
	`42`	`+ string_format_writer &append_char(char ch, size_t count = 1)`
	`43`	`+ ST_LIFETIME_BOUND override`
`42`	`44`	`{`
`43`	`45`	`m_output.append_char(ch, count);`
`44`	`46`	`return *this;`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ namespace ST`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`ST_NODISCARD`
`77`		`- const char *text() const noexcept { return m_start; }`
	`77`	`+ const char *text() const noexcept ST_LIFETIME_BOUND { return m_start; }`
`78`	`78`
`79`	`79`	`ST_NODISCARD`
`80`	`80`	`size_t size() const noexcept`
`@@ -106,7 +106,7 @@ namespace ST`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`ST_NODISCARD`
`109`		`- const char *text() const noexcept { return m_buffer; }`
	`109`	`+ const char *text() const noexcept ST_LIFETIME_BOUND { return m_buffer; }`
`110`	`110`
`111`	`111`	`ST_NODISCARD`
`112`	`112`	`size_t size() const noexcept { return m_size; }`
Original file line number	Diff line number	Diff line change
`@@ -68,13 +68,15 @@ namespace _ST_PRIVATE`
`68`	`68`	`m_stream.write(utf32.data(), utf32.size());`
`69`	`69`	`}`
`70`	`70`
`71`		`- ostream_format_writer &append(const char *data, size_t size) override`
	`71`	`+ ostream_format_writer &append(const char *data, size_t size)`
	`72`	`+ ST_LIFETIME_BOUND override`
`72`	`73`	`{`
`73`	`74`	`write_data<char_T>(data, size);`
`74`	`75`	`return *this;`
`75`	`76`	`}`
`76`	`77`
`77`		`- ostream_format_writer &append_char(char ch, size_t count = 1) override`
	`78`	`+ ostream_format_writer &append_char(char ch, size_t count = 1)`
	`79`	`+ ST_LIFETIME_BOUND override`
`78`	`80`	`{`
`79`	`81`	`while (count) {`
`80`	`82`	`m_stream.put(char_T(ch));`
`@@ -101,7 +103,8 @@ namespace ST`
`101`	`103`
`102`	`104`	`template <class char_T, class traits_T>`
`103`	`105`	`std::basic_ostream<char_T, traits_T> &operator<<(`
`104`		`- std::basic_ostream<char_T, traits_T> &stream, const ST::string &str)`
	`106`	`+ std::basic_ostream<char_T, traits_T> &stream ST_LIFETIME_BOUND,`
	`107`	`+ const ST::string &str)`
`105`	`108`	`{`
`106`	`109`	`ST::buffer<char_T> buffer;`
`107`	`110`	`str.to_buffer(buffer);`
`@@ -110,7 +113,8 @@ std::basic_ostream<char_T, traits_T> &operator<<(`
`110`	`113`
`111`	`114`	`template <class char_T, class traits_T>`
`112`	`115`	`std::basic_istream<char_T, traits_T> &operator>>(`
`113`		`- std::basic_istream<char_T, traits_T> &stream, ST::string &str)`
	`116`	`+ std::basic_istream<char_T, traits_T> &stream ST_LIFETIME_BOUND,`
	`117`	`+ ST::string &str)`
`114`	`118`	`{`
`115`	`119`	`std::basic_string<char_T, traits_T> stl_string;`
`116`	`120`	`stream >> stl_string;`
Original file line number	Diff line number	Diff line change
`@@ -31,13 +31,15 @@ namespace _ST_PRIVATE`
`31`	`31`	`stdio_format_writer(const char format_str, FILE stream)`
`32`	`32`	`: ST::format_writer(format_str), m_stream(stream) { }`
`33`	`33`
`34`		`- stdio_format_writer &append(const char *data, size_t size) override`
	`34`	`+ stdio_format_writer &append(const char *data, size_t size)`
	`35`	`+ ST_LIFETIME_BOUND override`
`35`	`36`	`{`
`36`	`37`	`(void)fwrite(data, sizeof(char), size, m_stream);`
`37`	`38`	`return *this;`
`38`	`39`	`}`
`39`	`40`
`40`		`- stdio_format_writer &append_char(char ch, size_t count = 1) override`
	`41`	`+ stdio_format_writer &append_char(char ch, size_t count = 1)`
	`42`	`+ ST_LIFETIME_BOUND override`
`41`	`43`	`{`
`42`	`44`	`while (count) {`
`43`	`45`	`fputc(ch, m_stream);`