More concept checks

d-frey · d-frey · commit c2686fa51235 · 2024-11-28T10:44:45.000+01:00
diff --git a/include/tao/pq/parameter.hpp b/include/tao/pq/parameter.hpp
@@ -24,7 +24,7 @@ namespace tao::pq
 
    namespace internal
    {
-      template< typename A >
+      template< typename >
       inline constexpr bool is_parameter = false;
 
       template< std::size_t Max >
diff --git a/include/tao/pq/result.hpp b/include/tao/pq/result.hpp
@@ -225,7 +225,7 @@ namespace tao::pq
 
       [[nodiscard]] auto at( const std::size_t row ) const -> pq::row;
 
-      template< typename T >
+      template< result_type T >
       [[nodiscard]] auto as() const -> T
       {
          switch( size() ) {
@@ -240,7 +240,7 @@ namespace tao::pq
          }
       }
 
-      template< typename T >
+      template< result_type T >
       [[nodiscard]] auto optional() const -> std::optional< T >
       {
          switch( size() ) {
@@ -255,19 +255,20 @@ namespace tao::pq
          }
       }
 
-      template< typename T, typename U >
+      template< result_type T, result_type U >
       [[nodiscard]] auto pair() const
       {
          return as< std::pair< T, U > >();
       }
 
-      template< typename... Ts >
+      template< result_type... Ts >
       [[nodiscard]] auto tuple() const
       {
          return as< std::tuple< Ts... > >();
       }
 
       template< typename T >
+         requires result_type< typename T::value_type >
       [[nodiscard]] auto as_container() const -> T
       {
          check_has_result_set();
@@ -282,60 +283,70 @@ namespace tao::pq
       }
 
       template< typename... Ts >
+         requires result_type< typename std::vector< Ts... >::value_type >
       [[nodiscard]] auto vector() const
       {
          return as_container< std::vector< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::list< Ts... >::value_type >
       [[nodiscard]] auto list() const
       {
          return as_container< std::list< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::set< Ts... >::value_type >
       [[nodiscard]] auto set() const
       {
          return as_container< std::set< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::multiset< Ts... >::value_type >
       [[nodiscard]] auto multiset() const
       {
          return as_container< std::multiset< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::unordered_set< Ts... >::value_type >
       [[nodiscard]] auto unordered_set() const
       {
          return as_container< std::unordered_set< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::unordered_multiset< Ts... >::value_type >
       [[nodiscard]] auto unordered_multiset() const
       {
          return as_container< std::unordered_multiset< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::map< Ts... >::value_type >
       [[nodiscard]] auto map() const
       {
          return as_container< std::map< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::multimap< Ts... >::value_type >
       [[nodiscard]] auto multimap() const
       {
          return as_container< std::multimap< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::unordered_map< Ts... >::value_type >
       [[nodiscard]] auto unordered_map() const
       {
          return as_container< std::unordered_map< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::unordered_multimap< Ts... >::value_type >
       [[nodiscard]] auto unordered_multimap() const
       {
          return as_container< std::unordered_multimap< Ts... > >();
diff --git a/include/tao/pq/table_reader.hpp b/include/tao/pq/table_reader.hpp
@@ -38,7 +38,7 @@ namespace tao::pq
       void check_result();
 
    public:
-      template< typename... As >
+      template< parameter_type... As >
       table_reader( const std::shared_ptr< transaction >& transaction, const internal::zsv statement, As&&... as )
          : m_previous( transaction ),
            m_transaction( std::make_shared< internal::transaction_guard >( transaction->connection() ) ),
@@ -154,6 +154,7 @@ namespace tao::pq
       }
 
       template< typename T >
+         requires result_type< typename T::value_type >
       [[nodiscard]] auto as_container() -> T
       {
          T nrv;
@@ -164,60 +165,70 @@ namespace tao::pq
       }
 
       template< typename... Ts >
+         requires result_type< typename std::vector< Ts... >::value_type >
       [[nodiscard]] auto vector()
       {
          return as_container< std::vector< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::list< Ts... >::value_type >
       [[nodiscard]] auto list()
       {
          return as_container< std::list< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::set< Ts... >::value_type >
       [[nodiscard]] auto set()
       {
          return as_container< std::set< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::multiset< Ts... >::value_type >
       [[nodiscard]] auto multiset()
       {
          return as_container< std::multiset< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::unordered_set< Ts... >::value_type >
       [[nodiscard]] auto unordered_set()
       {
          return as_container< std::unordered_set< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::unordered_multiset< Ts... >::value_type >
       [[nodiscard]] auto unordered_multiset()
       {
          return as_container< std::unordered_multiset< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::map< Ts... >::value_type >
       [[nodiscard]] auto map()
       {
          return as_container< std::map< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::multimap< Ts... >::value_type >
       [[nodiscard]] auto multimap()
       {
          return as_container< std::multimap< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::unordered_map< Ts... >::value_type >
       [[nodiscard]] auto unordered_map()
       {
          return as_container< std::unordered_map< Ts... > >();
       }
 
       template< typename... Ts >
+         requires result_type< typename std::unordered_multimap< Ts... >::value_type >
       [[nodiscard]] auto unordered_multimap()
       {
          return as_container< std::unordered_multimap< Ts... > >();

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ namespace tao::pq`
`24`	`24`
`25`	`25`	`namespace internal`
`26`	`26`	`{`
`27`		`- template< typename A >`
	`27`	`+ template< typename >`
`28`	`28`	`inline constexpr bool is_parameter = false;`
`29`	`29`
`30`	`30`	`template< std::size_t Max >`
Original file line number	Diff line number	Diff line change
`@@ -225,7 +225,7 @@ namespace tao::pq`
`225`	`225`
`226`	`226`	`[[nodiscard]] auto at( const std::size_t row ) const -> pq::row;`
`227`	`227`
`228`		`- template< typename T >`
	`228`	`+ template< result_type T >`
`229`	`229`	`[[nodiscard]] auto as() const -> T`
`230`	`230`	`{`
`231`	`231`	`switch( size() ) {`
`@@ -240,7 +240,7 @@ namespace tao::pq`
`240`	`240`	`}`
`241`	`241`	`}`
`242`	`242`
`243`		`- template< typename T >`
	`243`	`+ template< result_type T >`
`244`	`244`	`[[nodiscard]] auto optional() const -> std::optional< T >`
`245`	`245`	`{`
`246`	`246`	`switch( size() ) {`
`@@ -255,19 +255,20 @@ namespace tao::pq`
`255`	`255`	`}`
`256`	`256`	`}`
`257`	`257`
`258`		`- template< typename T, typename U >`
	`258`	`+ template< result_type T, result_type U >`
`259`	`259`	`[[nodiscard]] auto pair() const`
`260`	`260`	`{`
`261`	`261`	`return as< std::pair< T, U > >();`
`262`	`262`	`}`
`263`	`263`
`264`		`- template< typename... Ts >`
	`264`	`+ template< result_type... Ts >`
`265`	`265`	`[[nodiscard]] auto tuple() const`
`266`	`266`	`{`
`267`	`267`	`return as< std::tuple< Ts... > >();`
`268`	`268`	`}`
`269`	`269`
`270`	`270`	`template< typename T >`
	`271`	`+ requires result_type< typename T::value_type >`
`271`	`272`	`[[nodiscard]] auto as_container() const -> T`
`272`	`273`	`{`
`273`	`274`	`check_has_result_set();`
`@@ -282,60 +283,70 @@ namespace tao::pq`
`282`	`283`	`}`
`283`	`284`
`284`	`285`	`template< typename... Ts >`
	`286`	`+ requires result_type< typename std::vector< Ts... >::value_type >`
`285`	`287`	`[[nodiscard]] auto vector() const`
`286`	`288`	`{`
`287`	`289`	`return as_container< std::vector< Ts... > >();`
`288`	`290`	`}`
`289`	`291`
`290`	`292`	`template< typename... Ts >`
	`293`	`+ requires result_type< typename std::list< Ts... >::value_type >`
`291`	`294`	`[[nodiscard]] auto list() const`
`292`	`295`	`{`
`293`	`296`	`return as_container< std::list< Ts... > >();`
`294`	`297`	`}`
`295`	`298`
`296`	`299`	`template< typename... Ts >`
	`300`	`+ requires result_type< typename std::set< Ts... >::value_type >`
`297`	`301`	`[[nodiscard]] auto set() const`
`298`	`302`	`{`
`299`	`303`	`return as_container< std::set< Ts... > >();`
`300`	`304`	`}`
`301`	`305`
`302`	`306`	`template< typename... Ts >`
	`307`	`+ requires result_type< typename std::multiset< Ts... >::value_type >`
`303`	`308`	`[[nodiscard]] auto multiset() const`
`304`	`309`	`{`
`305`	`310`	`return as_container< std::multiset< Ts... > >();`
`306`	`311`	`}`
`307`	`312`
`308`	`313`	`template< typename... Ts >`
	`314`	`+ requires result_type< typename std::unordered_set< Ts... >::value_type >`
`309`	`315`	`[[nodiscard]] auto unordered_set() const`
`310`	`316`	`{`
`311`	`317`	`return as_container< std::unordered_set< Ts... > >();`
`312`	`318`	`}`
`313`	`319`
`314`	`320`	`template< typename... Ts >`
	`321`	`+ requires result_type< typename std::unordered_multiset< Ts... >::value_type >`
`315`	`322`	`[[nodiscard]] auto unordered_multiset() const`
`316`	`323`	`{`
`317`	`324`	`return as_container< std::unordered_multiset< Ts... > >();`
`318`	`325`	`}`
`319`	`326`
`320`	`327`	`template< typename... Ts >`
	`328`	`+ requires result_type< typename std::map< Ts... >::value_type >`
`321`	`329`	`[[nodiscard]] auto map() const`
`322`	`330`	`{`
`323`	`331`	`return as_container< std::map< Ts... > >();`
`324`	`332`	`}`
`325`	`333`
`326`	`334`	`template< typename... Ts >`
	`335`	`+ requires result_type< typename std::multimap< Ts... >::value_type >`
`327`	`336`	`[[nodiscard]] auto multimap() const`
`328`	`337`	`{`
`329`	`338`	`return as_container< std::multimap< Ts... > >();`
`330`	`339`	`}`
`331`	`340`
`332`	`341`	`template< typename... Ts >`
	`342`	`+ requires result_type< typename std::unordered_map< Ts... >::value_type >`
`333`	`343`	`[[nodiscard]] auto unordered_map() const`
`334`	`344`	`{`
`335`	`345`	`return as_container< std::unordered_map< Ts... > >();`
`336`	`346`	`}`
`337`	`347`
`338`	`348`	`template< typename... Ts >`
	`349`	`+ requires result_type< typename std::unordered_multimap< Ts... >::value_type >`
`339`	`350`	`[[nodiscard]] auto unordered_multimap() const`
`340`	`351`	`{`
`341`	`352`	`return as_container< std::unordered_multimap< Ts... > >();`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ namespace tao::pq`
`38`	`38`	`void check_result();`
`39`	`39`
`40`	`40`	`public:`
`41`		`- template< typename... As >`
	`41`	`+ template< parameter_type... As >`
`42`	`42`	`table_reader( const std::shared_ptr< transaction >& transaction, const internal::zsv statement, As&&... as )`
`43`	`43`	`: m_previous( transaction ),`
`44`	`44`	`m_transaction( std::make_shared< internal::transaction_guard >( transaction->connection() ) ),`
`@@ -154,6 +154,7 @@ namespace tao::pq`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`template< typename T >`
	`157`	`+ requires result_type< typename T::value_type >`
`157`	`158`	`[[nodiscard]] auto as_container() -> T`
`158`	`159`	`{`
`159`	`160`	`T nrv;`
`@@ -164,60 +165,70 @@ namespace tao::pq`
`164`	`165`	`}`
`165`	`166`
`166`	`167`	`template< typename... Ts >`
	`168`	`+ requires result_type< typename std::vector< Ts... >::value_type >`
`167`	`169`	`[[nodiscard]] auto vector()`
`168`	`170`	`{`
`169`	`171`	`return as_container< std::vector< Ts... > >();`
`170`	`172`	`}`
`171`	`173`
`172`	`174`	`template< typename... Ts >`
	`175`	`+ requires result_type< typename std::list< Ts... >::value_type >`
`173`	`176`	`[[nodiscard]] auto list()`
`174`	`177`	`{`
`175`	`178`	`return as_container< std::list< Ts... > >();`
`176`	`179`	`}`
`177`	`180`
`178`	`181`	`template< typename... Ts >`
	`182`	`+ requires result_type< typename std::set< Ts... >::value_type >`
`179`	`183`	`[[nodiscard]] auto set()`
`180`	`184`	`{`
`181`	`185`	`return as_container< std::set< Ts... > >();`
`182`	`186`	`}`
`183`	`187`
`184`	`188`	`template< typename... Ts >`
	`189`	`+ requires result_type< typename std::multiset< Ts... >::value_type >`
`185`	`190`	`[[nodiscard]] auto multiset()`
`186`	`191`	`{`
`187`	`192`	`return as_container< std::multiset< Ts... > >();`
`188`	`193`	`}`
`189`	`194`
`190`	`195`	`template< typename... Ts >`
	`196`	`+ requires result_type< typename std::unordered_set< Ts... >::value_type >`
`191`	`197`	`[[nodiscard]] auto unordered_set()`
`192`	`198`	`{`
`193`	`199`	`return as_container< std::unordered_set< Ts... > >();`
`194`	`200`	`}`
`195`	`201`
`196`	`202`	`template< typename... Ts >`
	`203`	`+ requires result_type< typename std::unordered_multiset< Ts... >::value_type >`
`197`	`204`	`[[nodiscard]] auto unordered_multiset()`
`198`	`205`	`{`
`199`	`206`	`return as_container< std::unordered_multiset< Ts... > >();`
`200`	`207`	`}`
`201`	`208`
`202`	`209`	`template< typename... Ts >`
	`210`	`+ requires result_type< typename std::map< Ts... >::value_type >`
`203`	`211`	`[[nodiscard]] auto map()`
`204`	`212`	`{`
`205`	`213`	`return as_container< std::map< Ts... > >();`
`206`	`214`	`}`
`207`	`215`
`208`	`216`	`template< typename... Ts >`
	`217`	`+ requires result_type< typename std::multimap< Ts... >::value_type >`
`209`	`218`	`[[nodiscard]] auto multimap()`
`210`	`219`	`{`
`211`	`220`	`return as_container< std::multimap< Ts... > >();`
`212`	`221`	`}`
`213`	`222`
`214`	`223`	`template< typename... Ts >`
	`224`	`+ requires result_type< typename std::unordered_map< Ts... >::value_type >`
`215`	`225`	`[[nodiscard]] auto unordered_map()`
`216`	`226`	`{`
`217`	`227`	`return as_container< std::unordered_map< Ts... > >();`
`218`	`228`	`}`
`219`	`229`
`220`	`230`	`template< typename... Ts >`
	`231`	`+ requires result_type< typename std::unordered_multimap< Ts... >::value_type >`
`221`	`232`	`[[nodiscard]] auto unordered_multimap()`
`222`	`233`	`{`
`223`	`234`	`return as_container< std::unordered_multimap< Ts... > >();`