Add lifetime annotations to features of utility/*

Morwenn · Morwenn · commit e8fed8549690 · 2025-10-03T00:36:50.000+02:00
diff --git a/include/cpp-sort/utility/adapter_storage.h b/include/cpp-sort/utility/adapter_storage.h
@@ -10,6 +10,7 @@
 ////////////////////////////////////////////////////////////
 #include <type_traits>
 #include <utility>
+#include "../detail/config.h"
 
 namespace cppsort::utility
 {
@@ -87,24 +88,28 @@ namespace cppsort::utility
         }
 
         constexpr auto get() & noexcept
+            CPPSORT_LIFETIME_BOUND
             -> Sorter&
         {
             return static_cast<Sorter&>(sorter);
         }
 
         constexpr auto get() const& noexcept
+            CPPSORT_LIFETIME_BOUND
             -> const Sorter&
         {
             return static_cast<const Sorter&>(sorter);
         }
 
         constexpr auto get() && noexcept
+            CPPSORT_LIFETIME_BOUND
             -> Sorter&&
         {
             return static_cast<Sorter&&>(sorter);
         }
 
         constexpr auto get() const&& noexcept
+            CPPSORT_LIFETIME_BOUND
             -> const Sorter&&
         {
             return static_cast<const Sorter&&>(sorter);
diff --git a/include/cpp-sort/utility/buffer.h b/include/cpp-sort/utility/buffer.h
@@ -11,6 +11,7 @@
 #include <array>
 #include <cstddef>
 #include <memory>
+#include "../detail/config.h"
 
 namespace cppsort::utility
 {
@@ -39,48 +40,56 @@ namespace cppsort::utility
                 }
 
                 constexpr auto operator[](std::size_t pos)
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory[pos])
                 {
                     return _memory[pos];
                 }
 
                 constexpr auto operator[](std::size_t pos) const
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory[pos])
                 {
                     return _memory[pos];
                 }
 
                 constexpr auto begin()
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory.data())
                 {
                     return _memory.data();
                 }
 
                 constexpr auto begin() const
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory.data())
                 {
                     return _memory.data();
                 }
 
                 constexpr auto cbegin() const
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory.data())
                 {
                     return _memory.data();
                 }
 
                 constexpr auto end()
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory.data() + _memory.size())
                 {
                     return _memory.data() + _memory.size();
                 }
 
                 constexpr auto end() const
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory.data() + _memory.size())
                 {
                     return _memory.data() + _memory.size();
                 }
 
                 constexpr auto cend() const
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory.data() + _memory.size())
                 {
                     return _memory.data() + _memory.size();
@@ -193,48 +202,56 @@ namespace cppsort::utility
                 }
 
                 auto operator[](std::size_t pos)
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory[pos])
                 {
                     return _memory[pos];
                 }
 
                 auto operator[](std::size_t pos) const
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory[pos])
                 {
                     return _memory[pos];
                 }
 
                 auto begin()
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory.get())
                 {
                     return _memory.get();
                 }
 
                 auto begin() const
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory.get())
                 {
                     return _memory.get();
                 }
 
                 auto cbegin() const
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory.get())
                 {
                     return _memory.get();
                 }
 
                 auto end()
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory.get() + size())
                 {
                     return _memory.get() + size();
                 }
 
                 auto end() const
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory.get() + size())
                 {
                     return _memory.get() + size();
                 }
 
                 auto cend() const
+                    CPPSORT_LIFETIME_BOUND
                     -> decltype(_memory.get() + size())
                 {
                     return _memory.get() + size();
diff --git a/include/cpp-sort/utility/metrics_tools.h b/include/cpp-sort/utility/metrics_tools.h
@@ -12,6 +12,7 @@
 #include <tuple>
 #include <type_traits>
 #include <utility>
+#include "../detail/config.h"
 #include "../detail/type_traits.h"
 
 namespace cppsort::utility
@@ -70,6 +71,7 @@ namespace cppsort::utility
 
             constexpr auto operator=(const T& other)
                 noexcept(std::is_nothrow_copy_assignable_v<T>)
+                CPPSORT_LIFETIME_BOUND
                 -> metric&
             {
                 _value = other;
@@ -78,6 +80,7 @@ namespace cppsort::utility
 
             constexpr auto operator=(T&& other)
                 noexcept(std::is_nothrow_move_assignable_v<T>)
+                CPPSORT_LIFETIME_BOUND
                 -> metric&
             {
                 _value = std::move(other);
@@ -87,6 +90,7 @@ namespace cppsort::utility
             template<typename U>
             constexpr auto operator=(const metric<U, Tag>& other)
                 noexcept(std::is_nothrow_assignable_v<T&, const U&>)
+                CPPSORT_LIFETIME_BOUND
                 -> metric&
             {
                 _value = other._value;
@@ -96,6 +100,7 @@ namespace cppsort::utility
             template<typename U>
             constexpr auto operator=(metric<U, Tag>&& other)
                 noexcept(std::is_nothrow_assignable_v<T&, U>)
+                CPPSORT_LIFETIME_BOUND
                 -> metric&
             {
                 _value = std::move(other._value);
@@ -271,28 +276,28 @@ namespace cppsort::utility
             // Index-based get()
 
             template<std::size_t Idx>
-            friend constexpr auto get(metrics& mm)
+            friend constexpr auto get(metrics& mm CPPSORT_LIFETIME_BOUND)
                 -> std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&
             {
                 return std::get<Idx>(mm.metrics_);
             }
 
             template<std::size_t Idx>
-            friend constexpr auto get(const metrics& mm)
+            friend constexpr auto get(const metrics& mm CPPSORT_LIFETIME_BOUND)
                 -> const std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&
             {
                 return std::get<Idx>(mm.metrics_);
             }
 
             template<std::size_t Idx>
-            friend constexpr auto get(metrics&& mm)
+            friend constexpr auto get(metrics&& mm CPPSORT_LIFETIME_BOUND)
                 -> std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&&
             {
                 return std::get<Idx>(std::move(mm).metrics_);
             }
 
             template<std::size_t Idx>
-            friend constexpr auto get(const metrics&& mm)
+            friend constexpr auto get(const metrics&& mm CPPSORT_LIFETIME_BOUND)
                 -> const std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&&
             {
                 return std::get<Idx>(std::move(mm).metrics_);
@@ -302,28 +307,28 @@ namespace cppsort::utility
             // Tag-based get()
 
             template<typename Tag, std::size_t Idx=cppsort::detail::index_of<Tag, Tags...>>
-            friend constexpr auto get(metrics& mm)
+            friend constexpr auto get(metrics& mm CPPSORT_LIFETIME_BOUND)
                 -> std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&
             {
                 return std::get<Idx>(mm.metrics_);
             }
 
             template<typename Tag, std::size_t Idx=cppsort::detail::index_of<Tag, Tags...>>
-            friend constexpr auto get(const metrics& mm)
+            friend constexpr auto get(const metrics& mm CPPSORT_LIFETIME_BOUND)
                 -> const std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&
             {
                 return std::get<Idx>(mm.metrics_);
             }
 
             template<typename Tag, std::size_t Idx=cppsort::detail::index_of<Tag, Tags...>>
-            friend constexpr auto get(metrics&& mm)
+            friend constexpr auto get(metrics&& mm CPPSORT_LIFETIME_BOUND)
                 -> std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&&
             {
                 return std::get<Idx>(std::move(mm).metrics_);
             }
 
             template<typename Tag, std::size_t Idx=cppsort::detail::index_of<Tag, Tags...>>
-            friend constexpr auto get(const metrics&& mm)
+            friend constexpr auto get(const metrics&& mm CPPSORT_LIFETIME_BOUND)
                 -> const std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&&
             {
                 return std::get<Idx>(std::move(mm).metrics_);

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@`
`10`	`10`	`////////////////////////////////////////////////////////////`
`11`	`11`	`#include <type_traits>`
`12`	`12`	`#include <utility>`
	`13`	`+#include "../detail/config.h"`
`13`	`14`
`14`	`15`	`namespace cppsort::utility`
`15`	`16`	`{`
`@@ -87,24 +88,28 @@ namespace cppsort::utility`
`87`	`88`	`}`
`88`	`89`
`89`	`90`	`constexpr auto get() & noexcept`
	`91`	`+ CPPSORT_LIFETIME_BOUND`
`90`	`92`	`-> Sorter&`
`91`	`93`	`{`
`92`	`94`	`return static_cast<Sorter&>(sorter);`
`93`	`95`	`}`
`94`	`96`
`95`	`97`	`constexpr auto get() const& noexcept`
	`98`	`+ CPPSORT_LIFETIME_BOUND`
`96`	`99`	`-> const Sorter&`
`97`	`100`	`{`
`98`	`101`	`return static_cast<const Sorter&>(sorter);`
`99`	`102`	`}`
`100`	`103`
`101`	`104`	`constexpr auto get() && noexcept`
	`105`	`+ CPPSORT_LIFETIME_BOUND`
`102`	`106`	`-> Sorter&&`
`103`	`107`	`{`
`104`	`108`	`return static_cast<Sorter&&>(sorter);`
`105`	`109`	`}`
`106`	`110`
`107`	`111`	`constexpr auto get() const&& noexcept`
	`112`	`+ CPPSORT_LIFETIME_BOUND`
`108`	`113`	`-> const Sorter&&`
`109`	`114`	`{`
`110`	`115`	`return static_cast<const Sorter&&>(sorter);`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@`
`11`	`11`	`#include <array>`
`12`	`12`	`#include <cstddef>`
`13`	`13`	`#include <memory>`
	`14`	`+#include "../detail/config.h"`
`14`	`15`
`15`	`16`	`namespace cppsort::utility`
`16`	`17`	`{`
`@@ -39,48 +40,56 @@ namespace cppsort::utility`
`39`	`40`	`}`
`40`	`41`
`41`	`42`	`constexpr auto operator[](std::size_t pos)`
	`43`	`+ CPPSORT_LIFETIME_BOUND`
`42`	`44`	`-> decltype(_memory[pos])`
`43`	`45`	`{`
`44`	`46`	`return _memory[pos];`
`45`	`47`	`}`
`46`	`48`
`47`	`49`	`constexpr auto operator[](std::size_t pos) const`
	`50`	`+ CPPSORT_LIFETIME_BOUND`
`48`	`51`	`-> decltype(_memory[pos])`
`49`	`52`	`{`
`50`	`53`	`return _memory[pos];`
`51`	`54`	`}`
`52`	`55`
`53`	`56`	`constexpr auto begin()`
	`57`	`+ CPPSORT_LIFETIME_BOUND`
`54`	`58`	`-> decltype(_memory.data())`
`55`	`59`	`{`
`56`	`60`	`return _memory.data();`
`57`	`61`	`}`
`58`	`62`
`59`	`63`	`constexpr auto begin() const`
	`64`	`+ CPPSORT_LIFETIME_BOUND`
`60`	`65`	`-> decltype(_memory.data())`
`61`	`66`	`{`
`62`	`67`	`return _memory.data();`
`63`	`68`	`}`
`64`	`69`
`65`	`70`	`constexpr auto cbegin() const`
	`71`	`+ CPPSORT_LIFETIME_BOUND`
`66`	`72`	`-> decltype(_memory.data())`
`67`	`73`	`{`
`68`	`74`	`return _memory.data();`
`69`	`75`	`}`
`70`	`76`
`71`	`77`	`constexpr auto end()`
	`78`	`+ CPPSORT_LIFETIME_BOUND`
`72`	`79`	`-> decltype(_memory.data() + _memory.size())`
`73`	`80`	`{`
`74`	`81`	`return _memory.data() + _memory.size();`
`75`	`82`	`}`
`76`	`83`
`77`	`84`	`constexpr auto end() const`
	`85`	`+ CPPSORT_LIFETIME_BOUND`
`78`	`86`	`-> decltype(_memory.data() + _memory.size())`
`79`	`87`	`{`
`80`	`88`	`return _memory.data() + _memory.size();`
`81`	`89`	`}`
`82`	`90`
`83`	`91`	`constexpr auto cend() const`
	`92`	`+ CPPSORT_LIFETIME_BOUND`
`84`	`93`	`-> decltype(_memory.data() + _memory.size())`
`85`	`94`	`{`
`86`	`95`	`return _memory.data() + _memory.size();`
`@@ -193,48 +202,56 @@ namespace cppsort::utility`
`193`	`202`	`}`
`194`	`203`
`195`	`204`	`auto operator[](std::size_t pos)`
	`205`	`+ CPPSORT_LIFETIME_BOUND`
`196`	`206`	`-> decltype(_memory[pos])`
`197`	`207`	`{`
`198`	`208`	`return _memory[pos];`
`199`	`209`	`}`
`200`	`210`
`201`	`211`	`auto operator[](std::size_t pos) const`
	`212`	`+ CPPSORT_LIFETIME_BOUND`
`202`	`213`	`-> decltype(_memory[pos])`
`203`	`214`	`{`
`204`	`215`	`return _memory[pos];`
`205`	`216`	`}`
`206`	`217`
`207`	`218`	`auto begin()`
	`219`	`+ CPPSORT_LIFETIME_BOUND`
`208`	`220`	`-> decltype(_memory.get())`
`209`	`221`	`{`
`210`	`222`	`return _memory.get();`
`211`	`223`	`}`
`212`	`224`
`213`	`225`	`auto begin() const`
	`226`	`+ CPPSORT_LIFETIME_BOUND`
`214`	`227`	`-> decltype(_memory.get())`
`215`	`228`	`{`
`216`	`229`	`return _memory.get();`
`217`	`230`	`}`
`218`	`231`
`219`	`232`	`auto cbegin() const`
	`233`	`+ CPPSORT_LIFETIME_BOUND`
`220`	`234`	`-> decltype(_memory.get())`
`221`	`235`	`{`
`222`	`236`	`return _memory.get();`
`223`	`237`	`}`
`224`	`238`
`225`	`239`	`auto end()`
	`240`	`+ CPPSORT_LIFETIME_BOUND`
`226`	`241`	`-> decltype(_memory.get() + size())`
`227`	`242`	`{`
`228`	`243`	`return _memory.get() + size();`
`229`	`244`	`}`
`230`	`245`
`231`	`246`	`auto end() const`
	`247`	`+ CPPSORT_LIFETIME_BOUND`
`232`	`248`	`-> decltype(_memory.get() + size())`
`233`	`249`	`{`
`234`	`250`	`return _memory.get() + size();`
`235`	`251`	`}`
`236`	`252`
`237`	`253`	`auto cend() const`
	`254`	`+ CPPSORT_LIFETIME_BOUND`
`238`	`255`	`-> decltype(_memory.get() + size())`
`239`	`256`	`{`
`240`	`257`	`return _memory.get() + size();`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@`
`12`	`12`	`#include <tuple>`
`13`	`13`	`#include <type_traits>`
`14`	`14`	`#include <utility>`
	`15`	`+#include "../detail/config.h"`
`15`	`16`	`#include "../detail/type_traits.h"`
`16`	`17`
`17`	`18`	`namespace cppsort::utility`
`@@ -70,6 +71,7 @@ namespace cppsort::utility`
`70`	`71`
`71`	`72`	`constexpr auto operator=(const T& other)`
`72`	`73`	`noexcept(std::is_nothrow_copy_assignable_v<T>)`
	`74`	`+ CPPSORT_LIFETIME_BOUND`
`73`	`75`	`-> metric&`
`74`	`76`	`{`
`75`	`77`	`_value = other;`
`@@ -78,6 +80,7 @@ namespace cppsort::utility`
`78`	`80`
`79`	`81`	`constexpr auto operator=(T&& other)`
`80`	`82`	`noexcept(std::is_nothrow_move_assignable_v<T>)`
	`83`	`+ CPPSORT_LIFETIME_BOUND`
`81`	`84`	`-> metric&`
`82`	`85`	`{`
`83`	`86`	`_value = std::move(other);`
`@@ -87,6 +90,7 @@ namespace cppsort::utility`
`87`	`90`	`template<typename U>`
`88`	`91`	`constexpr auto operator=(const metric<U, Tag>& other)`
`89`	`92`	`noexcept(std::is_nothrow_assignable_v<T&, const U&>)`
	`93`	`+ CPPSORT_LIFETIME_BOUND`
`90`	`94`	`-> metric&`
`91`	`95`	`{`
`92`	`96`	`_value = other._value;`
`@@ -96,6 +100,7 @@ namespace cppsort::utility`
`96`	`100`	`template<typename U>`
`97`	`101`	`constexpr auto operator=(metric<U, Tag>&& other)`
`98`	`102`	`noexcept(std::is_nothrow_assignable_v<T&, U>)`
	`103`	`+ CPPSORT_LIFETIME_BOUND`
`99`	`104`	`-> metric&`
`100`	`105`	`{`
`101`	`106`	`_value = std::move(other._value);`
`@@ -271,28 +276,28 @@ namespace cppsort::utility`
`271`	`276`	`// Index-based get()`
`272`	`277`
`273`	`278`	`template<std::size_t Idx>`
`274`		`- friend constexpr auto get(metrics& mm)`
	`279`	`+ friend constexpr auto get(metrics& mm CPPSORT_LIFETIME_BOUND)`
`275`	`280`	`-> std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&`
`276`	`281`	`{`
`277`	`282`	`return std::get<Idx>(mm.metrics_);`
`278`	`283`	`}`
`279`	`284`
`280`	`285`	`template<std::size_t Idx>`
`281`		`- friend constexpr auto get(const metrics& mm)`
	`286`	`+ friend constexpr auto get(const metrics& mm CPPSORT_LIFETIME_BOUND)`
`282`	`287`	`-> const std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&`
`283`	`288`	`{`
`284`	`289`	`return std::get<Idx>(mm.metrics_);`
`285`	`290`	`}`
`286`	`291`
`287`	`292`	`template<std::size_t Idx>`
`288`		`- friend constexpr auto get(metrics&& mm)`
	`293`	`+ friend constexpr auto get(metrics&& mm CPPSORT_LIFETIME_BOUND)`
`289`	`294`	`-> std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&&`
`290`	`295`	`{`
`291`	`296`	`return std::get<Idx>(std::move(mm).metrics_);`
`292`	`297`	`}`
`293`	`298`
`294`	`299`	`template<std::size_t Idx>`
`295`		`- friend constexpr auto get(const metrics&& mm)`
	`300`	`+ friend constexpr auto get(const metrics&& mm CPPSORT_LIFETIME_BOUND)`
`296`	`301`	`-> const std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&&`
`297`	`302`	`{`
`298`	`303`	`return std::get<Idx>(std::move(mm).metrics_);`
`@@ -302,28 +307,28 @@ namespace cppsort::utility`
`302`	`307`	`// Tag-based get()`
`303`	`308`
`304`	`309`	`template<typename Tag, std::size_t Idx=cppsort::detail::index_of<Tag, Tags...>>`
`305`		`- friend constexpr auto get(metrics& mm)`
	`310`	`+ friend constexpr auto get(metrics& mm CPPSORT_LIFETIME_BOUND)`
`306`	`311`	`-> std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&`
`307`	`312`	`{`
`308`	`313`	`return std::get<Idx>(mm.metrics_);`
`309`	`314`	`}`
`310`	`315`
`311`	`316`	`template<typename Tag, std::size_t Idx=cppsort::detail::index_of<Tag, Tags...>>`
`312`		`- friend constexpr auto get(const metrics& mm)`
	`317`	`+ friend constexpr auto get(const metrics& mm CPPSORT_LIFETIME_BOUND)`
`313`	`318`	`-> const std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&`
`314`	`319`	`{`
`315`	`320`	`return std::get<Idx>(mm.metrics_);`
`316`	`321`	`}`
`317`	`322`
`318`	`323`	`template<typename Tag, std::size_t Idx=cppsort::detail::index_of<Tag, Tags...>>`
`319`		`- friend constexpr auto get(metrics&& mm)`
	`324`	`+ friend constexpr auto get(metrics&& mm CPPSORT_LIFETIME_BOUND)`
`320`	`325`	`-> std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&&`
`321`	`326`	`{`
`322`	`327`	`return std::get<Idx>(std::move(mm).metrics_);`
`323`	`328`	`}`
`324`	`329`
`325`	`330`	`template<typename Tag, std::size_t Idx=cppsort::detail::index_of<Tag, Tags...>>`
`326`		`- friend constexpr auto get(const metrics&& mm)`
	`331`	`+ friend constexpr auto get(const metrics&& mm CPPSORT_LIFETIME_BOUND)`
`327`	`332`	`-> const std::tuple_element_t<Idx, std::tuple<metric<TT, Tags>...>>&&`
`328`	`333`	`{`
`329`	`334`	`return std::get<Idx>(std::move(mm).metrics_);`