use if constexpr to replace template specialization (#2660)

1 files changed, 67 insertions, 106 deletions

diff --git a/Source/Utils/MsgLogger/MsgLoggerSerialization.H b/Source/Utils/MsgLogger/MsgLoggerSerialization.H
index fba8bb0d1..ed642a148 100644
--- a/Source/Utils/MsgLogger/MsgLoggerSerialization.H
+++ b/Source/Utils/MsgLogger/MsgLoggerSerialization.H
@@ -22,7 +22,6 @@ namespace MsgLogger{
     * This function transforms a variable of type T into a vector of chars holding its
     * byte representation and it appends this vector at the end of an
     * existing vector of chars. T must be either a trivially copyable type or an std::string
-    * (see specialization)
     *
     * @tparam T the variable type
     * @param[in] val a variable of type T to be serialized
@@ -31,29 +30,20 @@ namespace MsgLogger{
     template <typename T>
     void put_in(const T& val, std::vector<char>& vec)
     {
-        static_assert(std::is_trivially_copyable<T>(),
-            "Cannot serialize non-trivally copyable types, except std::string.");
-
-        const auto* ptr_val = reinterpret_cast<const char*>(&val);
-        vec.insert(vec.end(), ptr_val, ptr_val+sizeof(T));
-    }
-
-    /**
-    * This function transforms a string into a vector of chars holding its
-    * byte representation and it appends this vector at the end of an
-    * existing vector of chars (specialization of put_in<T>).
-    *
-    * @param[in] val a std::string to be serialized
-    * @param[in, out] vec a reference to the vector to which the byte representation of val is appended
-    */
-    template <>
-    inline void put_in<std::string> (const std::string& val, std::vector<char>& vec)
-    {
-        const char* c_str = val.c_str();
-        const auto length = static_cast<int>(val.size());
-
-        put_in(length, vec);
-        vec.insert(vec.end(), c_str, c_str+length);
+        if constexpr (std::is_same<T, std::string>()){
+            const char* c_str = val.c_str();
+            const auto length = static_cast<int>(val.size());
+
+            put_in(length, vec);
+            vec.insert(vec.end(), c_str, c_str+length);
+        }
+        else{
+            static_assert(std::is_trivially_copyable<T>(),
+                "Cannot serialize non-trivally copyable types, except std::string.");
+
+            const auto* ptr_val = reinterpret_cast<const char*>(&val);
+            vec.insert(vec.end(), ptr_val, ptr_val+sizeof(T));
+        }
     }
 
     /**
@@ -69,36 +59,26 @@ namespace MsgLogger{
     template <typename T>
     inline void put_in_vec (const std::vector<T>& val, std::vector<char>& vec)
     {
-        static_assert(std::is_trivially_copyable<T>() || std::is_same<T,std::string>(),
-            "Cannot serialize vectors of non-trivally copyable types"
-            ", except vectors of std::string.");
-
-        put_in(static_cast<int>(val.size()), vec);
-        for (const auto& el : val)
-            put_in(el, vec);
-    }
-
-    /**
-    * This function transforms an std::vector<char> into a vector of chars holding its
-    * byte representation and it appends this vector at the end of an
-    * existing vector of chars (specialization of put_in_vec<T>).
-    *
-    * @tparam T the variable type
-    * @param[in] val a variable of type T to be serialized
-    * @param[in, out] vec a reference to the vector to which the byte representation of val is appended
-    */
-    template <>
-    inline void put_in_vec <char> (const std::vector<char>& val, std::vector<char>& vec)
-    {
-        put_in(static_cast<int>(val.size()), vec);
-        vec.insert(vec.end(), val.begin(), val.end());
+        if constexpr (std::is_same<T,char>()){
+            put_in(static_cast<int>(val.size()), vec);
+            vec.insert(vec.end(), val.begin(), val.end());
+        }
+        else{
+            static_assert(std::is_trivially_copyable<T>() || std::is_same<T,std::string>(),
+                "Cannot serialize vectors of non-trivally copyable types"
+                ", except vectors of std::string.");
+
+            put_in(static_cast<int>(val.size()), vec);
+            for (const auto& el : val)
+                put_in(el, vec);
+        }
     }
 
     /**
     * This function extracts a variable of type T from a byte vector, at the position
     * given by a std::vector<char> iterator. The iterator is then advanced according to
     * the number of bytes read from the byte vector. T must be either a trivially copyable type
-    * or an std::string (see specialization below).
+    * or an std::string.
     *
     * @tparam T the variable type (must be trivially copyable)
     * @param[in, out] it the iterator to a byte vector
@@ -107,36 +87,26 @@ namespace MsgLogger{
     template<typename T>
     T get_out(std::vector<char>::const_iterator& it)
     {
-        static_assert(std::is_trivially_copyable<T>(),
-            "Cannot extract non-trivally copyable types from char vectors,"
-            " with the exception of std::string.");
-
-        auto temp = std::array<char, sizeof(T)>{};
-        std::copy(it, it + sizeof(T), temp.begin());
-        it += sizeof(T);
-        T res;
-        std::memcpy(&res, temp.data(), sizeof(T));
+        if constexpr (std::is_same<T,std::string>()){
+            const auto length = get_out<int> (it);
+            const auto str = std::string{it, it+length};
+            it += length;
+
+            return str;
+        }
+        else{
+            static_assert(std::is_trivially_copyable<T>(),
+                "Cannot extract non-trivally copyable types from char vectors,"
+                " with the exception of std::string.");
+
+            auto temp = std::array<char, sizeof(T)>{};
+            std::copy(it, it + sizeof(T), temp.begin());
+            it += sizeof(T);
+            T res;
+            std::memcpy(&res, temp.data(), sizeof(T));
 
         return res;
-    }
-
-    /**
-    * This function extracts an std::string from a byte vector, at the position
-    * given by a std::vector<char> iterator. The iterator is then advanced according to
-    * the number of bytes read from the byte vector. This is a specialization of
-    * get_out<T>
-    *
-    * @param[in, out] it the iterator to a byte vector
-    * @return the std::string extracted from the byte array
-    */
-    template<>
-    inline std::string get_out<std::string> (std::vector<char>::const_iterator& it)
-    {
-        const auto length = get_out<int> (it);
-        const auto str = std::string{it, it+length};
-        it += length;
-
-        return str;
+        }
     }
 
     /**
@@ -152,37 +122,28 @@ namespace MsgLogger{
     template<typename T>
     inline std::vector<T> get_out_vec (std::vector<char>::const_iterator& it)
     {
-        static_assert(std::is_trivially_copyable<T>() || std::is_same<T,std::string>(),
-            "Cannot extract non-trivally copyable types from char vectors,"
-            " with the exception of std::string.");
-
-        const auto length = get_out<int> (it);
-        std::vector<T> res(length);
-        for (int i = 0; i < length; ++i)
-            res[i] = get_out<T>(it);
-
-        return res;
+        if constexpr (std::is_same<T,std::string>()){
+            const auto length = get_out<int> (it);
+            std::vector<char> res(length);
+            std::copy(it, it+length, res.begin());
+            it += length;
+
+            return res;
+        }
+        else
+        {
+            static_assert(std::is_trivially_copyable<T>() || std::is_same<T,std::string>(),
+                "Cannot extract non-trivally copyable types from char vectors,"
+                " with the exception of std::string.");
+
+            const auto length = get_out<int> (it);
+            std::vector<T> res(length);
+            for (int i = 0; i < length; ++i)
+                res[i] = get_out<T>(it);
+
+            return res;
+        }
     }
-
-    /**
-    * This function extracts an std::vector<char> from a byte vector, at the position
-    * given by a std::vector<char> iterator. The iterator is then advanced according to
-    * the number of bytes read from the byte vector. This is a specialization of get_out_vec<T>.
-    *
-    * @param[in, out] it the iterator to a byte vector
-    * @return the variable extracted from the byte array
-    */
-    template<>
-    inline std::vector<char> get_out_vec<char> (std::vector<char>::const_iterator& it)
-    {
-        const auto length = get_out<int> (it);
-        std::vector<char> res(length);
-        std::copy(it, it+length, res.begin());
-        it += length;
-
-        return res;
-    }
-
 }
 }