check lifetime bound of TString modifier member functions

commit_hash:5e1acbf4a0eaeb2ff1b7648f90af6bc4f41312e2

1 files changed, 69 insertions, 69 deletions

diff --git a/util/generic/string.h b/util/generic/string.h
index 3476f71b68..0a75732eee 100644
--- a/util/generic/string.h
+++ b/util/generic/string.h
@@ -367,7 +367,7 @@ public:
     }
 
     // ~~~ Size and capacity ~~~
-    TBasicString& resize(size_t n, TCharType c = ' ') { // remove or append
+    TBasicString& resize(size_t n, TCharType c = ' ') Y_LIFETIME_BOUND { // remove or append
         MutRef().resize(n, c);
 
         return *this;
@@ -596,31 +596,31 @@ public:
     }
 
     // ~~~ Assignment ~~~ : FAMILY0(TBasicString&, assign);
-    TBasicString& assign(size_t size, TCharType ch) {
+    TBasicString& assign(size_t size, TCharType ch) Y_LIFETIME_BOUND {
         ReserveAndResize(size);
         std::fill(begin(), vend(), ch);
         return *this;
     }
 
-    TBasicString& assign(const TBasicString& s) {
+    TBasicString& assign(const TBasicString& s) Y_LIFETIME_BOUND {
         TBasicString(s).swap(*this);
 
         return *this;
     }
 
-    TBasicString& assign(const TBasicString& s, size_t pos, size_t n) {
+    TBasicString& assign(const TBasicString& s, size_t pos, size_t n) Y_LIFETIME_BOUND {
         return assign(TBasicString(s, pos, n));
     }
 
-    TBasicString& assign(const TCharType* pc) {
+    TBasicString& assign(const TCharType* pc) Y_LIFETIME_BOUND {
         return assign(pc, TBase::StrLen(pc));
     }
 
-    TBasicString& assign(TCharType ch) {
+    TBasicString& assign(TCharType ch) Y_LIFETIME_BOUND {
         return assign(&ch, 1);
     }
 
-    TBasicString& assign(const TCharType* pc, size_t len) {
+    TBasicString& assign(const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
 #if defined(address_sanitizer_enabled) || defined(thread_sanitizer_enabled)
         pc = (const TCharType*)HidePointerOrigin((void*)pc);
 #endif
@@ -633,35 +633,35 @@ public:
         return *this;
     }
 
-    TBasicString& assign(const TCharType* first, const TCharType* last) {
+    TBasicString& assign(const TCharType* first, const TCharType* last) Y_LIFETIME_BOUND {
         return assign(first, last - first);
     }
 
-    TBasicString& assign(const TCharType* pc, size_t pos, size_t n) {
+    TBasicString& assign(const TCharType* pc, size_t pos, size_t n) Y_LIFETIME_BOUND {
         return assign(pc + pos, n);
     }
 
-    TBasicString& assign(const TBasicStringBuf<TCharType, TTraits> s) {
+    TBasicString& assign(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
         return assign(s.data(), s.size());
     }
 
-    TBasicString& assign(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) {
+    TBasicString& assign(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
         return assign(s.SubString(spos, sn));
     }
 
-    inline TBasicString& AssignNoAlias(const TCharType* pc, size_t len) {
+    inline TBasicString& AssignNoAlias(const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
         return assign(pc, len);
     }
 
-    inline TBasicString& AssignNoAlias(const TCharType* b, const TCharType* e) {
+    inline TBasicString& AssignNoAlias(const TCharType* b, const TCharType* e) Y_LIFETIME_BOUND {
         return AssignNoAlias(b, e - b);
     }
 
-    TBasicString& AssignNoAlias(const TBasicStringBuf<TCharType, TTraits> s) {
+    TBasicString& AssignNoAlias(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
         return AssignNoAlias(s.data(), s.size());
     }
 
-    TBasicString& AssignNoAlias(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) {
+    TBasicString& AssignNoAlias(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
         return AssignNoAlias(s.SubString(spos, sn));
     }
 
@@ -685,36 +685,36 @@ public:
         return AppendUtf16(s);
     }
 
-    TBasicString& operator=(const TBasicString& s) {
+    TBasicString& operator=(const TBasicString& s) Y_LIFETIME_BOUND {
         return assign(s);
     }
 
-    TBasicString& operator=(TBasicString&& s) noexcept {
+    TBasicString& operator=(TBasicString&& s) noexcept Y_LIFETIME_BOUND {
         swap(s);
         return *this;
     }
 
     template <typename T, typename A>
-    TBasicString& operator=(std::basic_string<TCharType, T, A>&& s) noexcept {
+    TBasicString& operator=(std::basic_string<TCharType, T, A>&& s) noexcept Y_LIFETIME_BOUND {
         TBasicString(std::move(s)).swap(*this);
 
         return *this;
     }
 
-    TBasicString& operator=(const TBasicStringBuf<TCharType, TTraits> s) {
+    TBasicString& operator=(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
         return assign(s);
     }
 
-    TBasicString& operator=(std::initializer_list<TCharType> il) {
+    TBasicString& operator=(std::initializer_list<TCharType> il) Y_LIFETIME_BOUND {
         return assign(il.begin(), il.end());
     }
 
-    TBasicString& operator=(const TCharType* s) {
+    TBasicString& operator=(const TCharType* s) Y_LIFETIME_BOUND {
         return assign(s);
     }
-    TBasicString& operator=(std::nullptr_t) = delete;
+    TBasicString& operator=(std::nullptr_t) Y_LIFETIME_BOUND = delete;
 
-    TBasicString& operator=(TExplicitType<TCharType> ch) {
+    TBasicString& operator=(TExplicitType<TCharType> ch) Y_LIFETIME_BOUND {
         return assign(ch);
     }
 
@@ -723,43 +723,43 @@ public:
     }
 
     // ~~~ Appending ~~~ : FAMILY0(TBasicString&, append);
-    inline TBasicString& append(size_t count, TCharType ch) {
+    inline TBasicString& append(size_t count, TCharType ch) Y_LIFETIME_BOUND {
         MutRef().append(count, ch);
 
         return *this;
     }
 
-    inline TBasicString& append(const TBasicString& s) {
+    inline TBasicString& append(const TBasicString& s) Y_LIFETIME_BOUND {
         MutRef().append(s.ConstRef());
 
         return *this;
     }
 
-    inline TBasicString& append(const TBasicString& s, size_t pos, size_t n) {
+    inline TBasicString& append(const TBasicString& s, size_t pos, size_t n) Y_LIFETIME_BOUND {
         MutRef().append(s.ConstRef(), pos, n);
 
         return *this;
     }
 
-    inline TBasicString& append(const TCharType* pc) Y_NOEXCEPT {
+    inline TBasicString& append(const TCharType* pc) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().append(pc);
 
         return *this;
     }
 
-    inline TBasicString& append(TCharType c) {
+    inline TBasicString& append(TCharType c) Y_LIFETIME_BOUND {
         MutRef().push_back(c);
 
         return *this;
     }
 
-    inline TBasicString& append(const TCharType* first, const TCharType* last) {
+    inline TBasicString& append(const TCharType* first, const TCharType* last) Y_LIFETIME_BOUND {
         MutRef().append(first, last);
 
         return *this;
     }
 
-    inline TBasicString& append(const TCharType* pc, size_t len) {
+    inline TBasicString& append(const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
         MutRef().append(pc, len);
 
         return *this;
@@ -769,7 +769,7 @@ public:
         ::ResizeUninitialized(MutRef(), len);
     }
 
-    TBasicString& AppendNoAlias(const TCharType* pc, size_t len) {
+    TBasicString& AppendNoAlias(const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
         if (len) {
             auto s = this->size();
 
@@ -780,23 +780,23 @@ public:
         return *this;
     }
 
-    TBasicString& AppendNoAlias(const TBasicStringBuf<TCharType, TTraits> s) {
+    TBasicString& AppendNoAlias(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
         return AppendNoAlias(s.data(), s.size());
     }
 
-    TBasicString& AppendNoAlias(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) {
+    TBasicString& AppendNoAlias(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
         return AppendNoAlias(s.SubString(spos, sn));
     }
 
-    TBasicString& append(const TBasicStringBuf<TCharType, TTraits> s) {
+    TBasicString& append(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
         return append(s.data(), s.size());
     }
 
-    TBasicString& append(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) {
+    TBasicString& append(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
         return append(s.SubString(spos, sn));
     }
 
-    TBasicString& append(const TCharType* pc, size_t pos, size_t n, size_t pc_len = TBase::npos) {
+    TBasicString& append(const TCharType* pc, size_t pos, size_t n, size_t pc_len = TBase::npos) Y_LIFETIME_BOUND {
         return append(pc + pos, Min(n, pc_len - pos));
     }
 
@@ -805,11 +805,11 @@ public:
      *    Certain invocations of this method will result in link-time error.
      *    You are free to implement corresponding methods in string.cpp if you need them.
      */
-    TBasicString& AppendAscii(const ::TStringBuf& s);
+    TBasicString& AppendAscii(const ::TStringBuf& s) Y_LIFETIME_BOUND;
 
-    TBasicString& AppendUtf8(const ::TStringBuf& s);
+    TBasicString& AppendUtf8(const ::TStringBuf& s) Y_LIFETIME_BOUND;
 
-    TBasicString& AppendUtf16(const ::TWtringBuf& s);
+    TBasicString& AppendUtf16(const ::TWtringBuf& s) Y_LIFETIME_BOUND;
 
     inline void push_back(TCharType c) {
         // TODO
@@ -817,7 +817,7 @@ public:
     }
 
     template <class T>
-    TBasicString& operator+=(const T& s) {
+    TBasicString& operator+=(const T& s) Y_LIFETIME_BOUND {
         return append(s);
     }
 
@@ -839,7 +839,7 @@ public:
     }
 
     template <class T>
-    TBasicString& operator*=(T count) {
+    TBasicString& operator*=(T count) Y_LIFETIME_BOUND {
         static_assert(std::is_integral<T>::value, "Integral type required.");
 
         TBasicString temp;
@@ -975,66 +975,66 @@ public:
     }
 
     // ~~~ Prepending ~~~ : FAMILY0(TBasicString&, prepend);
-    TBasicString& prepend(const TBasicString& s) {
+    TBasicString& prepend(const TBasicString& s) Y_LIFETIME_BOUND {
         MutRef().insert(0, s.ConstRef());
 
         return *this;
     }
 
-    TBasicString& prepend(const TBasicString& s, size_t pos, size_t n) {
+    TBasicString& prepend(const TBasicString& s, size_t pos, size_t n) Y_LIFETIME_BOUND {
         MutRef().insert(0, s.ConstRef(), pos, n);
 
         return *this;
     }
 
-    TBasicString& prepend(const TCharType* pc) {
+    TBasicString& prepend(const TCharType* pc) Y_LIFETIME_BOUND {
         MutRef().insert(0, pc);
 
         return *this;
     }
 
-    TBasicString& prepend(size_t n, TCharType c) {
+    TBasicString& prepend(size_t n, TCharType c) Y_LIFETIME_BOUND {
         MutRef().insert(size_t(0), n, c);
 
         return *this;
     }
 
-    TBasicString& prepend(TCharType c) {
+    TBasicString& prepend(TCharType c) Y_LIFETIME_BOUND {
         MutRef().insert(size_t(0), 1, c);
 
         return *this;
     }
 
-    TBasicString& prepend(const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) {
+    TBasicString& prepend(const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
         return insert(0, s, spos, sn);
     }
 
     // ~~~ Insertion ~~~ : FAMILY1(TBasicString&, insert, size_t pos);
-    TBasicString& insert(size_t pos, const TBasicString& s) {
+    TBasicString& insert(size_t pos, const TBasicString& s) Y_LIFETIME_BOUND {
         MutRef().insert(pos, s.ConstRef());
 
         return *this;
     }
 
-    TBasicString& insert(size_t pos, const TBasicString& s, size_t pos1, size_t n1) {
+    TBasicString& insert(size_t pos, const TBasicString& s, size_t pos1, size_t n1) Y_LIFETIME_BOUND {
         MutRef().insert(pos, s.ConstRef(), pos1, n1);
 
         return *this;
     }
 
-    TBasicString& insert(size_t pos, const TCharType* pc) {
+    TBasicString& insert(size_t pos, const TCharType* pc) Y_LIFETIME_BOUND {
         MutRef().insert(pos, pc);
 
         return *this;
     }
 
-    TBasicString& insert(size_t pos, const TCharType* pc, size_t len) {
+    TBasicString& insert(size_t pos, const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
         MutRef().insert(pos, pc, len);
 
         return *this;
     }
 
-    TBasicString& insert(const_iterator pos, const_iterator b, const_iterator e) {
+    TBasicString& insert(const_iterator pos, const_iterator b, const_iterator e) Y_LIFETIME_BOUND {
 #ifdef TSTRING_IS_STD_STRING
         Storage_.insert(Storage_.begin() + this->off(pos), b, e);
 
@@ -1044,28 +1044,28 @@ public:
 #endif
     }
 
-    TBasicString& insert(size_t pos, size_t n, TCharType c) {
+    TBasicString& insert(size_t pos, size_t n, TCharType c) Y_LIFETIME_BOUND {
         MutRef().insert(pos, n, c);
 
         return *this;
     }
 
-    TBasicString& insert(const_iterator pos, size_t len, TCharType ch) {
+    TBasicString& insert(const_iterator pos, size_t len, TCharType ch) Y_LIFETIME_BOUND {
         return this->insert(this->off(pos), len, ch);
     }
 
-    TBasicString& insert(const_iterator pos, TCharType ch) {
+    TBasicString& insert(const_iterator pos, TCharType ch) Y_LIFETIME_BOUND {
         return this->insert(pos, 1, ch);
     }
 
-    TBasicString& insert(size_t pos, const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) {
+    TBasicString& insert(size_t pos, const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
         MutRef().insert(pos, s, spos, sn);
 
         return *this;
     }
 
     // ~~~ Removing ~~~
-    TBasicString& remove(size_t pos, size_t n) Y_NOEXCEPT {
+    TBasicString& remove(size_t pos, size_t n) Y_NOEXCEPT Y_LIFETIME_BOUND {
         if (pos < length()) {
             MutRef().erase(pos, n);
         }
@@ -1073,7 +1073,7 @@ public:
         return *this;
     }
 
-    TBasicString& remove(size_t pos = 0) Y_NOEXCEPT {
+    TBasicString& remove(size_t pos = 0) Y_NOEXCEPT Y_LIFETIME_BOUND {
         if (pos < length()) {
             MutRef().erase(pos);
         }
@@ -1081,21 +1081,21 @@ public:
         return *this;
     }
 
-    TBasicString& erase(size_t pos = 0, size_t n = TBase::npos) Y_NOEXCEPT {
+    TBasicString& erase(size_t pos = 0, size_t n = TBase::npos) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().erase(pos, n);
 
         return *this;
     }
 
-    TBasicString& erase(const_iterator b, const_iterator e) Y_NOEXCEPT {
+    TBasicString& erase(const_iterator b, const_iterator e) Y_NOEXCEPT Y_LIFETIME_BOUND {
         return erase(this->off(b), e - b);
     }
 
-    TBasicString& erase(const_iterator i) Y_NOEXCEPT {
+    TBasicString& erase(const_iterator i) Y_NOEXCEPT Y_LIFETIME_BOUND {
         return erase(i, i + 1);
     }
 
-    TBasicString& pop_back() Y_NOEXCEPT {
+    TBasicString& pop_back() Y_NOEXCEPT Y_LIFETIME_BOUND {
         Y_ASSERT(!this->empty());
 
         MutRef().pop_back();
@@ -1104,43 +1104,43 @@ public:
     }
 
     // ~~~ replacement ~~~ : FAMILY2(TBasicString&, replace, size_t pos, size_t n);
-    TBasicString& replace(size_t pos, size_t n, const TBasicString& s) Y_NOEXCEPT {
+    TBasicString& replace(size_t pos, size_t n, const TBasicString& s) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().replace(pos, n, s.ConstRef());
 
         return *this;
     }
 
-    TBasicString& replace(size_t pos, size_t n, const TBasicString& s, size_t pos1, size_t n1) Y_NOEXCEPT {
+    TBasicString& replace(size_t pos, size_t n, const TBasicString& s, size_t pos1, size_t n1) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().replace(pos, n, s.ConstRef(), pos1, n1);
 
         return *this;
     }
 
-    TBasicString& replace(size_t pos, size_t n, const TCharType* pc) Y_NOEXCEPT {
+    TBasicString& replace(size_t pos, size_t n, const TCharType* pc) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().replace(pos, n, pc);
 
         return *this;
     }
 
-    TBasicString& replace(size_t pos, size_t n, const TCharType* s, size_t len) Y_NOEXCEPT {
+    TBasicString& replace(size_t pos, size_t n, const TCharType* s, size_t len) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().replace(pos, n, s, len);
 
         return *this;
     }
 
-    TBasicString& replace(size_t pos, size_t n, const TCharType* s, size_t spos, size_t sn) Y_NOEXCEPT {
+    TBasicString& replace(size_t pos, size_t n, const TCharType* s, size_t spos, size_t sn) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().replace(pos, n, s + spos, sn - spos);
 
         return *this;
     }
 
-    TBasicString& replace(size_t pos, size_t n1, size_t n2, TCharType c) Y_NOEXCEPT {
+    TBasicString& replace(size_t pos, size_t n1, size_t n2, TCharType c) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().replace(pos, n1, n2, c);
 
         return *this;
     }
 
-    TBasicString& replace(size_t pos, size_t n, const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) Y_NOEXCEPT {
+    TBasicString& replace(size_t pos, size_t n, const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().replace(pos, n, s, spos, sn);
 
         return *this;