Fix gcc-11 compile error at dbus.h

Since concat function make compile error,
Make that function allow only 2-arg.
Now compiler will be happy

Change-Id: Iacfe08a67a88fd13f242385970ab33b1adbcc5d5
Signed-off-by: Eunki Hong <eunkiki.hong@samsung.com>

diff --git a/dali/internal/accessibility/bridge/dbus/dbus.h b/dali/internal/accessibility/bridge/dbus/dbus.h
index c23cd53..9babbfc 100644 (file)
--- a/dali/internal/accessibility/bridge/dbus/dbus.h
+++ b/dali/internal/accessibility/bridge/dbus/dbus.h
@@ -485,7 +485,7 @@ enum class ErrorType
 struct Error
 {
   std::string message;
-  ErrorType errorType{ErrorType::DEFAULT};
+  ErrorType   errorType{ErrorType::DEFAULT};
 
   Error() = default;
   Error(std::string msg, ErrorType errorType = ErrorType::DEFAULT)
@@ -710,34 +710,71 @@ using char_array = std::array<char, N>;
 constexpr char* xcopy_n(const char* src, size_t n, char* dst)
 {
   for(std::size_t i = 0; i < n; ++i)
+  {
     dst[i] = src[i];
+  }
 
   return dst + n;
 }
 
-template<std::size_t N>
-constexpr std::size_t xlen(const char (&)[N])
+template<std::size_t L, std::size_t R>
+constexpr char_array<L + R - 1> concat_internal(const char_array<L> lhs, const char_array<R> rhs)
 {
-  return N - 1;
-}
+  char_array<L + R - 1> arr{};
+  char*                 ptr = arr.data();
 
-template<std::size_t N>
-constexpr std::size_t xlen(const char_array<N>&)
-{
-  return N - 1;
-}
+  if constexpr(!arr.empty())
+  {
+    ptr  = xcopy_n(std::data(lhs), L - 1, ptr);
+    ptr  = xcopy_n(std::data(rhs), R - 1, ptr);
+    *ptr = 0;
+  }
 
-template<typename... Args>
-constexpr auto concat(const Args&... args)
+  return arr;
+}
+template<std::size_t L>
+constexpr char_array<L> convert_internal(const char (&str)[L])
 {
-  char_array<(1U + ... + xlen(args))> arr{};
-  char*                               ptr = arr.data();
+  char_array<L> arr{};
+  char*         ptr = arr.data();
 
   if constexpr(!arr.empty())
-    ((ptr = xcopy_n(std::data(args), xlen(args), ptr)), ...);
+  {
+    ptr = xcopy_n(std::data(str), L, ptr);
+  }
 
   return arr;
 }
+template<std::size_t L, std::size_t R>
+constexpr char_array<L + R - 1> concat(const char_array<L> lhs, const char_array<R> rhs)
+{
+  return concat_internal(lhs, rhs);
+}
+template<std::size_t L, std::size_t R>
+constexpr char_array<L + R - 1> concat(const char (&lhs)[L], const char_array<R> rhs)
+{
+  return concat_internal(convert_internal(lhs), rhs);
+}
+template<std::size_t L, std::size_t R>
+constexpr char_array<L + R - 1> concat(const char_array<L> lhs, const char (&rhs)[R])
+{
+  return concat_internal(lhs, convert_internal(rhs));
+}
+template<std::size_t L, std::size_t R>
+constexpr char_array<L + R - 1> concat(const char (&lhs)[L], const char (&rhs)[R])
+{
+  return concat_internal(convert_internal(lhs), convert_internal(rhs));
+}
+template<std::size_t L>
+constexpr char_array<L> concat(const char (&str)[L])
+{
+  return convert_internal(str);
+}
+template<std::size_t L>
+constexpr char_array<L> concat(const char_array<L> str)
+{
+  return str;
+}
 
 template<std::size_t... Digits>
 struct to_chars
@@ -1022,7 +1059,7 @@ template<>
 struct signature<float> : signature_helper<signature<float>>
 {
   static constexpr auto name_v = concat("float");
-  static constexpr auto sig_v  = concat("d");
+  static constexpr auto sig_v  = concat("f");
 
   /**
        * @brief Marshals value v as marshalled type into message
@@ -1238,7 +1275,7 @@ struct signature_tuple_helper : signature_helper<signature_tuple_helper<INDEX, S
 {
   using current_type = typename signature_tuple_element_type_helper<INDEX, ARGS...>::type;
 
-  static constexpr auto name_v = concat(signature<current_type>::name_v, ", ", signature_tuple_helper<INDEX + 1, SIZE, ARGS...>::name_v);
+  static constexpr auto name_v = concat(signature<current_type>::name_v, concat(", ", signature_tuple_helper<INDEX + 1, SIZE, ARGS...>::name_v));
   static constexpr auto sig_v  = concat(signature<current_type>::sig_v, signature_tuple_helper<INDEX + 1, SIZE, ARGS...>::sig_v);
 
   /**
@@ -1297,8 +1334,8 @@ struct signature_tuple_helper<SIZE, SIZE, ARGS...> : signature_helper<signature_
 template<typename... ARGS>
 struct signature<std::tuple<ARGS...>> : signature_helper<signature<std::tuple<ARGS...>>>
 {
-  static constexpr auto name_v = concat("tuple<", signature_tuple_helper<0, sizeof...(ARGS), ARGS...>::name_v, ">");
-  static constexpr auto sig_v  = concat("(", signature_tuple_helper<0, sizeof...(ARGS), ARGS...>::sig_v, ")");
+  static constexpr auto name_v = concat("tuple<", concat(signature_tuple_helper<0, sizeof...(ARGS), ARGS...>::name_v, ">"));
+  static constexpr auto sig_v  = concat("(", concat(signature_tuple_helper<0, sizeof...(ARGS), ARGS...>::sig_v, ")"));
 
   /**
        * @brief Marshals value v as marshalled type into message
@@ -1334,7 +1371,7 @@ struct signature<std::tuple<ARGS...>> : signature_helper<signature<std::tuple<AR
 template<typename... ARGS>
 struct signature<ValueOrError<ARGS...>> : signature_helper<signature<ValueOrError<ARGS...>>>
 {
-  static constexpr auto name_v = concat("ValueOrError<", signature_tuple_helper<0, sizeof...(ARGS), ARGS...>::name_v, ">");
+  static constexpr auto name_v = concat("ValueOrError<", concat(signature_tuple_helper<0, sizeof...(ARGS), ARGS...>::name_v, ">"));
   static constexpr auto sig_v  = signature_tuple_helper<0, sizeof...(ARGS), ARGS...>::sig_v;
 
   /**
@@ -1410,8 +1447,8 @@ struct signature<ValueOrError<>> : signature_helper<signature<ValueOrError<>>>
 template<typename A, typename B>
 struct signature<std::pair<A, B>> : signature_helper<signature<std::pair<A, B>>>
 {
-  static constexpr auto name_v = concat("pair<", signature_tuple_helper<0, 2, A, B>::name_v, ">");
-  static constexpr auto sig_v  = concat("(", signature_tuple_helper<0, 2, A, B>::sig_v, ")");
+  static constexpr auto name_v = concat("pair<", concat(signature_tuple_helper<0, 2, A, B>::name_v, ">"));
+  static constexpr auto sig_v  = concat("(", concat(signature_tuple_helper<0, 2, A, B>::sig_v, ")"));
 
   /**
        * @brief Marshals value v as marshalled type into message
@@ -1453,7 +1490,7 @@ struct signature<std::pair<A, B>> : signature_helper<signature<std::pair<A, B>>>
 template<typename A>
 struct signature<std::vector<A>> : signature_helper<signature<std::vector<A>>>
 {
-  static constexpr auto name_v = concat("vector<", signature<A>::name_v, ">");
+  static constexpr auto name_v = concat("vector<", concat(signature<A>::name_v, ">"));
   static constexpr auto sig_v  = concat("a", signature<A>::sig_v);
 
   /**
@@ -1493,7 +1530,7 @@ struct signature<std::vector<A>> : signature_helper<signature<std::vector<A>>>
 template<typename A, size_t N>
 struct signature<std::array<A, N>> : signature_helper<signature<std::array<A, N>>>
 {
-  static constexpr auto name_v = concat("array<", signature<A>::name_v, ", ", to_string<N>::value, ">");
+  static constexpr auto name_v = concat("array<", concat(signature<A>::name_v, concat(", ", concat(to_string<N>::value, ">"))));
   static constexpr auto sig_v  = concat("a", signature<A>::sig_v);
 
   /**
@@ -1534,7 +1571,7 @@ struct signature<std::array<A, N>> : signature_helper<signature<std::array<A, N>
 template<typename A>
 struct signature<EldbusVariant<A>> : signature_helper<signature<EldbusVariant<A>>>
 {
-  static constexpr auto name_v = concat("variant<", signature<A>::name_v, ">");
+  static constexpr auto name_v = concat("variant<", concat(signature<A>::name_v, ">"));
   static constexpr auto sig_v  = concat("v");
 
   /**
@@ -1579,8 +1616,8 @@ struct signature<EldbusVariant<A>> : signature_helper<signature<EldbusVariant<A>
 template<typename A, typename B>
 struct signature<std::unordered_map<A, B>> : signature_helper<signature<std::unordered_map<A, B>>>
 {
-  static constexpr auto name_v = concat("unordered_map<", signature<A>::name_v, ", ", signature<B>::name_v, ">");
-  static constexpr auto sig_v  = concat("a{", signature_tuple_helper<0, 2, A, B>::sig_v, "}");
+  static constexpr auto name_v = concat("unordered_map<", concat(signature<A>::name_v, concat(", ", concat(signature<B>::name_v, ">"))));
+  static constexpr auto sig_v  = concat("a{", concat(signature_tuple_helper<0, 2, A, B>::sig_v, "}"));
 
   /**
        * @brief Marshals value v as marshalled type into message
@@ -1625,8 +1662,8 @@ struct signature<std::unordered_map<A, B>> : signature_helper<signature<std::uno
 template<typename A, typename B>
 struct signature<std::map<A, B>> : signature_helper<signature<std::map<A, B>>>
 {
-  static constexpr auto name_v = concat("map<", signature<A>::name_v, ", ", signature<B>::name_v, ">");
-  static constexpr auto sig_v  = concat("a{", signature_tuple_helper<0, 2, A, B>::sig_v, "}");
+  static constexpr auto name_v = concat("map<", concat(signature<A>::name_v, concat(", ", concat(signature<B>::name_v, ">"))));
+  static constexpr auto sig_v  = concat("a{", concat(signature_tuple_helper<0, 2, A, B>::sig_v, "}"));
 
   /**
        * @brief Marshals value v as marshalled type into message
@@ -1663,7 +1700,7 @@ struct signature<std::map<A, B>> : signature_helper<signature<std::map<A, B>>>
 template<typename A>
 struct signature<const A&> : signature_helper<signature<const A&>>
 {
-  static constexpr auto name_v = concat("const ", signature<A>::name_v, "&");
+  static constexpr auto name_v = concat("const ", concat(signature<A>::name_v, "&"));
   static constexpr auto sig_v  = signature<A>::sig_v;
 
   /**