Use std::is_arithmetic* instead of std::is_fundamental* for type traits tests, (#1282)

because std::nullptr_t and void should not be included.

Author: leekillough

src/sst/core/from_string.h

@@ -99,14 +99,16 @@ from_string(const std::string& input)
     return static_cast<T>(from_string<std::underlying_type_t<T>>(input));
 }
 
+///////////////////////////////////////////////////////////////////////////////
+
 template <class T>
 std::enable_if_t<!std::is_enum_v<T>, std::string>
 to_string(const T& input)
 {
-    if constexpr ( std::is_fundamental_v<T> )
+    if constexpr ( std::is_arithmetic_v<T> )
         return std::to_string(input);
     else
-        return typeid(T).name(); // For now, return a string if the type isn't fundamental or handled elsewhere
+        return typeid(T).name(); // For now, return a string if the type isn't handled elsewhere
 }
 
 template <class T>
@@ -116,6 +118,7 @@ to_string(const T& input)
     return std::to_string(static_cast<std::underlying_type_t<T>>(input));
 }
 
+// for std::string no-op, or class types which define operator std::string()
 inline std::string
 to_string(std::string s)
 {

src/sst/core/serialization/impl/serialize_array.h

@@ -82,10 +82,10 @@ raw_ptr(TPtr*& ptr)
 
 /**
    Version of serialize that works for statically allocated arrays of
-   fundamental types and enums.
+   arithmetic types and enums.
  */
 template <class T, size_t N>
-class serialize_impl<T[N], std::enable_if_t<std::is_fundamental_v<T> || std::is_enum_v<T>>>
+class serialize_impl<T[N], std::enable_if_t<std::is_arithmetic_v<T> || std::is_enum_v<T>>>
 {
     template <class A>
     friend class serialize;
@@ -102,7 +102,7 @@ class serialize_impl<T[N], std::enable_if_t<std::is_fundamental_v<T> || std::is_
    non base types.
  */
 template <class T, size_t N>
-class serialize_impl<T[N], std::enable_if_t<!std::is_fundamental_v<T> && !std::is_enum_v<T>>>
+class serialize_impl<T[N], std::enable_if_t<!std::is_arithmetic_v<T> && !std::is_enum_v<T>>>
 {
     template <class A>
     friend class serialize;
@@ -120,11 +120,10 @@ class serialize_impl<T[N], std::enable_if_t<!std::is_fundamental_v<T> && !std::i
 
 /**
    Version of serialize that works for dynamically allocated arrays of
-   fundamental types and enums.
+   arithmetic types and enums.
  */
 template <class T, class IntType>
-class serialize_impl<
-    pvt::ser_array_wrapper<T, IntType>, std::enable_if_t<std::is_fundamental_v<T> || std::is_enum_v<T>>>
+class serialize_impl<pvt::ser_array_wrapper<T, IntType>, std::enable_if_t<std::is_arithmetic_v<T> || std::is_enum_v<T>>>
 {
     template <class A>
     friend class serialize;
@@ -142,7 +141,7 @@ class serialize_impl<
  */
 template <class T, class IntType>
 class serialize_impl<
-    pvt::ser_array_wrapper<T, IntType>, std::enable_if_t<!std::is_fundamental_v<T> && !std::is_enum_v<T>>>
+    pvt::ser_array_wrapper<T, IntType>, std::enable_if_t<!std::is_arithmetic_v<T> && !std::is_enum_v<T>>>
 {
     template <class A>
     friend class serialize;

src/sst/core/serialization/serialize.h

@@ -280,11 +280,11 @@ class serialize<T*>
 
 
 /**
-   Version of serialize that works for fundamental types and enums.
+   Version of serialize that works for arithmetic and enum types.
  */
 
 template <class T>
-class serialize_impl<T, std::enable_if_t<std::is_fundamental_v<T> || std::is_enum_v<T>>>
+class serialize_impl<T, std::enable_if_t<std::is_arithmetic_v<T> || std::is_enum_v<T>>>
 {
 public:
     void operator()(T& t, serializer& ser)
@@ -300,15 +300,14 @@ class serialize_impl<T, std::enable_if_t<std::is_fundamental_v<T> || std::is_enu
 };
 
 /**
-   Version of serialize that works for pointers to fundamental types
-   and enums. Note that the pointer tracking happens at a higher
-   level, and only if it is turned on.  If it is not turned on, then
-   this only copies the value pointed to into the buffer.  If multiple
-   objects point to the same location, they will each have an
-   independent copy after deserialization.
+   Version of serialize that works for pointers to arithmetic and enum types.
+   Note that the pointer tracking happens at a higher level, and only if it is
+   turned on. If it is not turned on, then this only copies the value pointed
+   to into the buffer. If multiple objects point to the same location, they
+   will each have an independent copy after deserialization.
  */
 template <class T>
-class serialize_impl<T*, std::enable_if_t<std::is_fundamental_v<T> || std::is_enum_v<T>>>
+class serialize_impl<T*, std::enable_if_t<std::is_arithmetic_v<T> || std::is_enum_v<T>>>
 {
     template <typename>
     friend class serialize;

src/sst/core/statapi/statbase.h

@@ -318,12 +318,11 @@ class StatisticBase
 /**
  \class StatisticCollector
  * Base type that creates the virtual addData(...) interface
- * Used for distinguishing fundamental types (collected by value)
+ * Used for distinguishing arithmetic types (collected by value)
  * and composite struct types (collected by reference)
  */
-template <class T, bool = std::is_fundamental_v<T>>
-struct StatisticCollector
-{};
+template <class T, bool = std::is_arithmetic_v<T>>
+struct StatisticCollector;
 
 template <class T>
 struct StatisticCollector<T, true>

src/sst/core/statapi/statnull.h

@@ -34,9 +34,8 @@ namespace SST::Statistics {
 
     @tparam T A template for holding the main data type of this statistic
 */
-template <class T, bool = std::is_fundamental_v<T>>
-class NullStatisticBase
-{};
+template <class T, bool = std::is_arithmetic_v<T>>
+class NullStatisticBase;
 
 template <class T>
 class NullStatisticBase<T, true> : public Statistic<T>
@@ -137,12 +136,9 @@ class NullStatistic : public NullStatisticBase<T>
     static bool isLoaded() { return loaded_; }
 
 private:
-    static bool loaded_;
+    inline static bool loaded_ = true;
 };
 
-template <class T>
-bool NullStatistic<T>::loaded_ = true;
-
 template <>
 class NullStatistic<void> : public Statistic<void>
 {