From 44dce3419726474f2d253b364781f5de71e813df Mon Sep 17 00:00:00 2001
From: Jason Volk <jason@zemos.net>
Date: Fri, 3 Apr 2020 12:07:45 -0700
Subject: [PATCH] ircd::json::tuple: Avoids PLT entries for complex templates
 in modules.

---
 include/ircd/json/tuple/at.h       | 28 ++++++++++++++--------------
 include/ircd/json/tuple/for_each.h | 24 ++++++++++++++----------
 include/ircd/json/tuple/get.h      | 18 +++++++++---------
 include/ircd/json/tuple/set.h      | 22 +++++++++++-----------
 include/ircd/json/tuple/tuple.h    | 14 +++++++-------
 include/ircd/json/tuple/until.h    | 25 +++++++++++++++----------
 6 files changed, 70 insertions(+), 61 deletions(-)

diff --git a/include/ircd/json/tuple/at.h b/include/ircd/json/tuple/at.h
index bd7a7c5b3..5d4131087 100644
--- a/include/ircd/json/tuple/at.h
+++ b/include/ircd/json/tuple/at.h
@@ -16,7 +16,7 @@ namespace json {
 
 template<size_t hash,
          class tuple>
-enable_if_tuple<tuple, const tuple_value_type<tuple, indexof<tuple, hash>()> &>
+inline enable_if_tuple<tuple, const tuple_value_type<tuple, indexof<tuple, hash>()> &>
 at(const tuple &t)
 {
 	constexpr size_t idx
@@ -40,7 +40,7 @@ at(const tuple &t)
 
 template<size_t hash,
          class tuple>
-enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, hash>()> &>
+inline enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, hash>()> &>
 at(tuple &t)
 {
 	constexpr size_t idx
@@ -64,7 +64,7 @@ at(tuple &t)
 
 template<const char *const &name,
          class tuple>
-enable_if_tuple<tuple, const tuple_value_type<tuple, indexof<tuple, name>()> &>
+inline enable_if_tuple<tuple, const tuple_value_type<tuple, indexof<tuple, name>()> &>
 at(const tuple &t)
 {
 	return at<name_hash(name), tuple>(t);
@@ -72,7 +72,7 @@ at(const tuple &t)
 
 template<const char *const &name,
          class tuple>
-enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, name>()> &>
+inline enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, name>()> &>
 at(tuple &t)
 {
 	return at<name_hash(name), tuple>(t);
@@ -81,17 +81,17 @@ at(tuple &t)
 template<class tuple,
          class function,
          size_t i>
-typename std::enable_if<i == size<tuple>(), void>::type
+constexpr typename std::enable_if<i == size<tuple>(), void>::type
 at(tuple &t,
    const string_view &name,
    function&& f)
-{
-}
+noexcept
+{}
 
 template<class tuple,
          class function,
          size_t i = 0>
-typename std::enable_if<i < size<tuple>(), void>::type
+inline typename std::enable_if<i < size<tuple>(), void>::type
 at(tuple &t,
    const string_view &name,
    function&& f)
@@ -105,17 +105,17 @@ at(tuple &t,
 template<class tuple,
          class function,
          size_t i>
-typename std::enable_if<i == size<tuple>(), void>::type
+constexpr typename std::enable_if<i == size<tuple>(), void>::type
 at(const tuple &t,
    const string_view &name,
    function&& f)
-{
-}
+noexcept
+{}
 
 template<class tuple,
          class function,
          size_t i = 0>
-typename std::enable_if<i < size<tuple>(), void>::type
+inline typename std::enable_if<i < size<tuple>(), void>::type
 at(const tuple &t,
    const string_view &name,
    function&& f)
@@ -128,7 +128,7 @@ at(const tuple &t,
 
 template<class R,
          class tuple>
-enable_if_tuple<tuple, const R &>
+inline enable_if_tuple<tuple, const R &>
 at(const tuple &t,
    const string_view &name)
 {
@@ -161,7 +161,7 @@ at(const tuple &t,
 
 template<class R,
          class tuple>
-enable_if_tuple<tuple, R &>
+inline enable_if_tuple<tuple, R &>
 at(tuple &t,
    const string_view &name)
 {
diff --git a/include/ircd/json/tuple/for_each.h b/include/ircd/json/tuple/for_each.h
index 03873e32a..f033889a6 100644
--- a/include/ircd/json/tuple/for_each.h
+++ b/include/ircd/json/tuple/for_each.h
@@ -17,23 +17,25 @@ namespace json {
 template<size_t i,
          class tuple,
          class function>
-typename std::enable_if<i == size<tuple>(), void>::type
+constexpr typename std::enable_if<i == size<tuple>(), void>::type
 for_each(const tuple &t,
          function&& f)
+noexcept
 {}
 
 template<size_t i,
          class tuple,
          class function>
-typename std::enable_if<i == size<tuple>(), void>::type
+constexpr typename std::enable_if<i == size<tuple>(), void>::type
 for_each(tuple &t,
          function&& f)
+noexcept
 {}
 
 template<size_t i = 0,
          class tuple,
          class function>
-typename std::enable_if<i < size<tuple>(), void>::type
+inline typename std::enable_if<i < size<tuple>(), void>::type
 for_each(const tuple &t,
          function&& f)
 {
@@ -44,7 +46,7 @@ for_each(const tuple &t,
 template<size_t i = 0,
          class tuple,
          class function>
-typename std::enable_if<i < size<tuple>(), void>::type
+inline typename std::enable_if<i < size<tuple>(), void>::type
 for_each(tuple &t,
          function&& f)
 {
@@ -54,7 +56,7 @@ for_each(tuple &t,
 
 template<class tuple,
          class function>
-void
+inline void
 for_each(const tuple &t,
          const vector_view<const string_view> &mask,
          function&& f)
@@ -72,7 +74,7 @@ for_each(const tuple &t,
 
 template<class tuple,
          class function>
-void
+inline void
 for_each(tuple &t,
          const vector_view<const string_view> &mask,
          function&& f)
@@ -91,23 +93,25 @@ for_each(tuple &t,
 template<class tuple,
          class function,
          ssize_t i>
-typename std::enable_if<(i < 0), void>::type
+constexpr typename std::enable_if<(i < 0), void>::type
 rfor_each(const tuple &t,
           function&& f)
+noexcept
 {}
 
 template<class tuple,
          class function,
          ssize_t i>
-typename std::enable_if<(i < 0), void>::type
+constexpr typename std::enable_if<(i < 0), void>::type
 rfor_each(tuple &t,
           function&& f)
+noexcept
 {}
 
 template<class tuple,
          class function,
          ssize_t i = size<tuple>() - 1>
-typename std::enable_if<i < tuple_size<tuple>(), void>::type
+inline typename std::enable_if<i < tuple_size<tuple>(), void>::type
 rfor_each(const tuple &t,
           function&& f)
 {
@@ -118,7 +122,7 @@ rfor_each(const tuple &t,
 template<class tuple,
          class function,
          ssize_t i = size<tuple>() - 1>
-typename std::enable_if<i < tuple_size<tuple>(), void>::type
+inline typename std::enable_if<i < tuple_size<tuple>(), void>::type
 rfor_each(tuple &t,
           function&& f)
 {
diff --git a/include/ircd/json/tuple/get.h b/include/ircd/json/tuple/get.h
index 269798d07..63ea64760 100644
--- a/include/ircd/json/tuple/get.h
+++ b/include/ircd/json/tuple/get.h
@@ -16,7 +16,7 @@ namespace json {
 
 template<size_t hash,
          class tuple>
-enable_if_tuple<tuple, const tuple_value_type<tuple, indexof<tuple, hash>()> &>
+inline enable_if_tuple<tuple, const tuple_value_type<tuple, indexof<tuple, hash>()> &>
 get(const tuple &t)
 noexcept
 {
@@ -35,7 +35,7 @@ noexcept
 
 template<size_t hash,
          class tuple>
-enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, hash>()>>
+inline enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, hash>()>>
 get(const tuple &t,
     const tuple_value_type<tuple, indexof<tuple, hash>()> &def)
 noexcept
@@ -55,7 +55,7 @@ noexcept
 
 template<size_t hash,
          class tuple>
-enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, hash>()> &>
+inline enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, hash>()> &>
 get(tuple &t)
 noexcept
 {
@@ -74,7 +74,7 @@ noexcept
 
 template<size_t hash,
          class tuple>
-enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, hash>()> &>
+inline enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, hash>()> &>
 get(tuple &t,
     tuple_value_type<tuple, indexof<tuple, hash>()> &def)
 noexcept
@@ -89,7 +89,7 @@ noexcept
 
 template<const char *const &name,
          class tuple>
-enable_if_tuple<tuple, const tuple_value_type<tuple, indexof<tuple, name>()> &>
+inline enable_if_tuple<tuple, const tuple_value_type<tuple, indexof<tuple, name>()> &>
 get(const tuple &t)
 noexcept
 {
@@ -98,7 +98,7 @@ noexcept
 
 template<const char *const &name,
          class tuple>
-enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, name>()>>
+inline enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, name>()>>
 get(const tuple &t,
     const tuple_value_type<tuple, indexof<tuple, name>()> &def)
 noexcept
@@ -108,7 +108,7 @@ noexcept
 
 template<const char *const &name,
          class tuple>
-enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, name>()>>
+inline enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, name>()>>
 get(tuple &t)
 noexcept
 {
@@ -117,7 +117,7 @@ noexcept
 
 template<const char *const &name,
          class tuple>
-enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, name>()>>
+inline enable_if_tuple<tuple, tuple_value_type<tuple, indexof<tuple, name>()>>
 get(tuple &t,
     tuple_value_type<tuple, indexof<tuple, hash>()> &def)
 noexcept
@@ -127,7 +127,7 @@ noexcept
 
 template<class R,
          class tuple>
-enable_if_tuple<tuple, R>
+inline enable_if_tuple<tuple, R>
 get(const tuple &t,
     const string_view &name,
     R ret)
diff --git a/include/ircd/json/tuple/set.h b/include/ircd/json/tuple/set.h
index 020a1bd59..35fe4208c 100644
--- a/include/ircd/json/tuple/set.h
+++ b/include/ircd/json/tuple/set.h
@@ -16,7 +16,7 @@ namespace json {
 
 template<class dst,
          class src>
-typename std::enable_if
+inline typename std::enable_if
 <
 	std::is_base_of<json::string, dst>() &&
 	std::is_convertible<src, ircd::string_view>(),
@@ -29,7 +29,7 @@ _assign(dst &d,
 
 template<class dst,
          class src>
-typename std::enable_if
+inline typename std::enable_if
 <
 	!std::is_base_of<json::string, dst>() &&
 	std::is_convertible<src, dst>() &&
@@ -44,7 +44,7 @@ _assign(dst &d,
 
 template<class dst,
          class src>
-typename std::enable_if
+inline typename std::enable_if
 <
 	!std::is_base_of<json::string, dst>() &&
 	std::is_convertible<src, dst>() &&
@@ -60,7 +60,7 @@ _assign(dst &d,
 
 template<class dst,
          class src>
-typename std::enable_if
+inline typename std::enable_if
 <
 	std::is_arithmetic<dst>() &&
 	std::is_base_of<std::string_view, typename std::remove_reference<src>::type>() &&
@@ -84,7 +84,7 @@ catch(const bad_lex_cast &e)
 
 template<class dst,
          class src>
-typename std::enable_if
+inline typename std::enable_if
 <
 	std::is_arithmetic<dst>() &&
 	std::is_base_of<ircd::byte_view<ircd::string_view>, typename std::remove_reference<src>::type>(),
@@ -98,7 +98,7 @@ _assign(dst &d,
 
 template<class dst,
          class src>
-typename std::enable_if
+inline typename std::enable_if
 <
 	std::is_base_of<std::string_view, dst>() &&
 	std::is_pod<typename std::remove_reference<src>::type>(),
@@ -111,7 +111,7 @@ _assign(dst &d,
 
 template<class dst,
          class src>
-typename std::enable_if
+inline typename std::enable_if
 <
 	ircd::json::is_tuple<dst>() &&
 	std::is_assignable<dst, src>(),
@@ -124,7 +124,7 @@ _assign(dst &d,
 
 template<class dst,
          class src>
-typename std::enable_if
+inline typename std::enable_if
 <
 	ircd::json::is_tuple<dst>() &&
 	!std::is_assignable<dst, src>() &&
@@ -138,7 +138,7 @@ _assign(dst &d,
 
 template<class dst,
          class src>
-typename std::enable_if
+inline typename std::enable_if
 <
 	ircd::json::is_tuple<dst>() &&
 	!std::is_assignable<dst, src>() &&
@@ -156,7 +156,7 @@ _assign(dst &d,
 
 template<class V,
          class... T>
-tuple<T...> &
+inline tuple<T...> &
 set(tuple<T...> &t,
     const string_view &key,
     V&& val)
@@ -182,7 +182,7 @@ catch(const std::exception &e)
 }
 
 template<class... T>
-tuple<T...> &
+inline tuple<T...> &
 set(tuple<T...> &t,
     const string_view &key,
     const json::value &value)
diff --git a/include/ircd/json/tuple/tuple.h b/include/ircd/json/tuple/tuple.h
index 1ae2711c6..dfb722775 100644
--- a/include/ircd/json/tuple/tuple.h
+++ b/include/ircd/json/tuple/tuple.h
@@ -112,14 +112,14 @@ template<class tuple,
 using tuple_value_type = typename tuple_element<tuple, i>::value_type;
 
 template<class tuple>
-auto &
+inline auto &
 stdcast(const tuple &o)
 {
 	return static_cast<const typename tuple::tuple_type &>(o);
 }
 
 template<class tuple>
-auto &
+inline auto &
 stdcast(tuple &o)
 {
 	return static_cast<typename tuple::tuple_type &>(o);
@@ -144,7 +144,7 @@ namespace json {
 
 template<size_t i,
          class tuple>
-enable_if_tuple<tuple, tuple_value_type<tuple, i> &>
+inline enable_if_tuple<tuple, tuple_value_type<tuple, i> &>
 val(tuple &t)
 noexcept
 {
@@ -153,7 +153,7 @@ noexcept
 
 template<size_t i,
          class tuple>
-enable_if_tuple<tuple, const tuple_value_type<tuple, i> &>
+inline enable_if_tuple<tuple, const tuple_value_type<tuple, i> &>
 val(const tuple &t)
 noexcept
 {
@@ -304,7 +304,7 @@ const noexcept
 template<class... T>
 template<class R,
          class name>
-R
+inline R
 tuple<T...>::get(name&& n,
                  R ret)
 const noexcept
@@ -315,7 +315,7 @@ const noexcept
 template<class... T>
 template<class R,
          class name>
-const R &
+inline const R &
 tuple<T...>::at(name&& n)
 const
 {
@@ -325,7 +325,7 @@ const
 template<class... T>
 template<class R,
          class name>
-R &
+inline R &
 tuple<T...>::at(name&& n)
 {
 	return json::at<R>(*this, n);
diff --git a/include/ircd/json/tuple/until.h b/include/ircd/json/tuple/until.h
index 9c5a3eb45..9c97299dc 100644
--- a/include/ircd/json/tuple/until.h
+++ b/include/ircd/json/tuple/until.h
@@ -17,9 +17,10 @@ namespace json {
 template<size_t i,
          class tuple,
          class function>
-typename std::enable_if<i == size<tuple>(), bool>::type
+constexpr typename std::enable_if<i == size<tuple>(), bool>::type
 until(const tuple &t,
       function&& f)
+noexcept
 {
 	return true;
 }
@@ -27,9 +28,10 @@ until(const tuple &t,
 template<size_t i,
          class tuple,
          class function>
-typename std::enable_if<i == size<tuple>(), bool>::type
+constexpr typename std::enable_if<i == size<tuple>(), bool>::type
 until(tuple &t,
       function&& f)
+noexcept
 {
 	return true;
 }
@@ -37,7 +39,7 @@ until(tuple &t,
 template<size_t i = 0,
          class tuple,
          class function>
-typename std::enable_if<i < size<tuple>(), bool>::type
+inline typename std::enable_if<i < size<tuple>(), bool>::type
 until(const tuple &t,
       function&& f)
 {
@@ -49,7 +51,7 @@ until(const tuple &t,
 template<size_t i = 0,
          class tuple,
          class function>
-typename std::enable_if<i < size<tuple>(), bool>::type
+inline typename std::enable_if<i < size<tuple>(), bool>::type
 until(tuple &t,
       function&& f)
 {
@@ -61,10 +63,11 @@ until(tuple &t,
 template<size_t i,
          class tuple,
          class function>
-typename std::enable_if<i == size<tuple>(), bool>::type
+constexpr typename std::enable_if<i == size<tuple>(), bool>::type
 until(const tuple &a,
       const tuple &b,
       function&& f)
+noexcept
 {
 	return true;
 }
@@ -72,7 +75,7 @@ until(const tuple &a,
 template<size_t i = 0,
          class tuple,
          class function>
-typename std::enable_if<i < size<tuple>(), bool>::type
+inline typename std::enable_if<i < size<tuple>(), bool>::type
 until(const tuple &a,
       const tuple &b,
       function&& f)
@@ -85,9 +88,10 @@ until(const tuple &a,
 template<class tuple,
          class function,
          ssize_t i>
-typename std::enable_if<(i < 0), bool>::type
+constexpr typename std::enable_if<(i < 0), bool>::type
 runtil(const tuple &t,
        function&& f)
+noexcept
 {
 	return true;
 }
@@ -95,9 +99,10 @@ runtil(const tuple &t,
 template<class tuple,
          class function,
          ssize_t i>
-typename std::enable_if<(i < 0), bool>::type
+constexpr typename std::enable_if<(i < 0), bool>::type
 runtil(tuple &t,
        function&& f)
+noexcept
 {
 	return true;
 }
@@ -105,7 +110,7 @@ runtil(tuple &t,
 template<class tuple,
          class function,
          ssize_t i = size<tuple>() - 1>
-typename std::enable_if<i < size<tuple>(), bool>::type
+inline typename std::enable_if<i < size<tuple>(), bool>::type
 runtil(const tuple &t,
        function&& f)
 {
@@ -117,7 +122,7 @@ runtil(const tuple &t,
 template<class tuple,
          class function,
          ssize_t i = size<tuple>() - 1>
-typename std::enable_if<i < size<tuple>(), bool>::type
+inline typename std::enable_if<i < size<tuple>(), bool>::type
 runtil(tuple &t,
        function&& f)
 {