Generalize serialize to support more containers in a generalized way, and store mapping name in a stack stored in the serializer (#1271)

Author: leekillough

src/sst/core/Makefile.am

@@ -98,21 +98,18 @@ nobase_dist_sst_HEADERS = \
 	serialization/serialize_impl_fwd.h \
 	serialization/objectMap.h \
 	serialization/objectMapDeferred.h \
+	serialization/impl/serialize_adapter.h \
 	serialization/impl/serialize_array.h \
 	serialization/impl/serialize_atomic.h \
 	serialization/impl/ser_buffer_accessor.h \
-	serialization/impl/serialize_deque.h \
-	serialization/impl/serialize_list.h \
-	serialization/impl/serialize_map.h \
-	serialization/impl/serialize_multiset.h \
+	serialization/impl/serialize_insertable.h \
+	serialization/impl/serialize_tuple.h \
+	serialization/impl/serialize_utility.h \
 	serialization/impl/mapper.h \
 	serialization/impl/packer.h \
-	serialization/impl/serialize_priority_queue.h \
-	serialization/impl/serialize_set.h \
 	serialization/impl/sizer.h \
 	serialization/impl/serialize_string.h \
 	serialization/impl/unpacker.h \
-	serialization/impl/serialize_vector.h \
 	serialization/serializer.h \
 	serialization/serializer_fwd.h \
 	serialization/statics.h \

src/sst/core/baseComponent.cc

@@ -1062,7 +1062,7 @@ SerializeBaseComponentHelper::unpack_basecomponent(serializable_base*& s, serial
 }
 
 void
-SerializeBaseComponentHelper::map_basecomponent(serializable_base*& s, serializer& ser, const char* name)
+SerializeBaseComponentHelper::map_basecomponent(serializable_base*& s, serializer& ser, const std::string& name)
 {
     if ( nullptr == s ) return;
 

src/sst/core/baseComponent.h

@@ -1145,7 +1145,7 @@ class SerializeBaseComponentHelper
 
     static void unpack_basecomponent(serializable_base*& s, serializer& ser);
 
-    static void map_basecomponent(serializable_base*& s, serializer& ser, const char* name);
+    static void map_basecomponent(serializable_base*& s, serializer& ser, const std::string& name);
 };
 
 } // namespace pvt
@@ -1170,17 +1170,11 @@ class serialize_impl<T*, std::enable_if_t<std::is_base_of_v<SST::BaseComponent,
             pvt::SerializeBaseComponentHelper::unpack_basecomponent(sp, ser);
             break;
         case serializer::MAP:
-            // Add your code here
+            pvt::SerializeBaseComponentHelper::map_basecomponent(sp, ser, ser.getMapName());
             break;
         }
         s = static_cast<T*>(sp);
     }
-
-    void operator()(T*& s, serializer& ser, const char* name)
-    {
-        serializable_base* sp = static_cast<serializable_base*>(s);
-        pvt::SerializeBaseComponentHelper::map_basecomponent(sp, ser, name);
-    }
 };
 
 } // namespace Core::Serialization

src/sst/core/from_string.h

@@ -92,6 +92,36 @@ from_string(const std::string& input)
     return T(input);
 }
 
+template <class T>
+std::enable_if_t<std::is_enum_v<T>, T>
+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> )
+        return std::to_string(input);
+    else
+        return typeid(T).name(); // For now, return a string if the type isn't fundamental or handled elsewhere
+}
+
+template <class T>
+std::enable_if_t<std::is_enum_v<T>, std::string>
+to_string(const T& input)
+{
+    return std::to_string(static_cast<std::underlying_type_t<T>>(input));
+}
+
+inline std::string
+to_string(std::string s)
+{
+    return s;
+}
+
 } // end namespace SST::Core
 
 #endif // SST_CORE_FROM_STRING_H

src/sst/core/impl/interactive/simpleDebug.cc

@@ -71,7 +71,7 @@ SimpleDebugger::cmd_pwd(std::vector<std::string>& UNUSED(tokens))
 void
 SimpleDebugger::cmd_ls(std::vector<std::string>& UNUSED(tokens))
 {
-    std::vector<std::pair<std::string, SST::Core::Serialization::ObjectMap*>> vars = obj_->getVariables();
+    auto& vars = obj_->getVariables();
     for ( auto& x : vars ) {
         if ( x.second->isFundamental() ) {
             printf("%s = %s (%s)\n", x.first.c_str(), x.second->get().c_str(), x.second->getType().c_str());
@@ -293,16 +293,8 @@ SimpleDebugger::cmd_watch(std::vector<std::string>& tokens)
         return;
     }
 
-    Core::Serialization::ObjectMap* map = nullptr;
-
     // Look for variable
-    std::vector<std::pair<std::string, SST::Core::Serialization::ObjectMap*>> vars = obj_->getVariables();
-    for ( auto& x : vars ) {
-        if ( x.first == var ) {
-            // Found the variable
-            map = x.second;
-        }
-    }
+    Core::Serialization::ObjectMap* map = obj_->findVariable(var);
 
     // Check for errors
 

src/sst/core/link.cc

@@ -33,7 +33,7 @@
 namespace SST {
 
 void
-SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, SST::Core::Serialization::serializer& ser)
+SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, serializer& ser)
 {
     // Need to treat Links and SelfLinks differently
     bool    self_link;
@@ -559,18 +559,11 @@ SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, SST::Core:
         }
         break;
     case serializer::MAP:
-        // This version of the function is not called in mapping mode.
+        // TODO: Implement Link mapping mode
         break;
     }
 }
 
-void
-SST::Core::Serialization::serialize_impl<Link*>::operator()(
-    Link*& UNUSED(s), SST::Core::Serialization::serializer& UNUSED(ser), const char* UNUSED(name))
-{
-    // TODO: Implement Link mapping mode
-}
-
 /**
  * Null Event.  Used when nullptr is passed into any of the send
  * functions.  On delivery, it will delete itself and return nullptr.

src/sst/core/link.h

@@ -43,7 +43,6 @@ class SST::Core::Serialization::serialize_impl<Link*>
     friend class serialize;
     // Function implemented in link.cc
     void operator()(Link*& s, SST::Core::Serialization::serializer& ser);
-    void operator()(Link*& s, SST::Core::Serialization::serializer& ser, const char* name);
 };
 
 

src/sst/core/serialization/impl/CMakeLists.txt

@@ -18,16 +18,13 @@ set(SSTSerializationImplHeaders
     mapper.h
     packer.h
     ser_buffer_accessor.h
+    serialize_adapter.h
     serialize_array.h
     serialize_atomic.h
-    serialize_deque.h
-    serialize_list.h
-    serialize_map.h
-    serialize_multiset.h
-    serialize_priority_queue.h
-    serialize_set.h
+    serialize_insertable.h
     serialize_string.h
-    serialize_vector.h
+    serialize_tuple.h
+    serialize_utility.h
     sizer.h
     unpacker.h)
 

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

@@ -19,6 +19,7 @@
 
 #include "sst/core/serialization/impl/ser_buffer_accessor.h"
 
+#include <cstddef>
 #include <string>
 
 namespace SST::Core::Serialization::pvt {
@@ -40,7 +41,7 @@ class ser_packer : public ser_buffer_accessor
      * @param buf  Must be non-null
      * @param size Must be non-zero
      */
-    void pack_buffer(void* buf, int size);
+    void pack_buffer(void* buf, size_t size);
 
     void pack_string(std::string& str);
 };

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

@@ -0,0 +1,49 @@
+// Copyright 2009-2025 NTESS. Under the terms
+// of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Copyright (c) 2009-2025, NTESS
+// All rights reserved.
+//
+// This file is part of the SST software package. For license
+// information, see the LICENSE file in the top level directory of the
+// distribution.
+
+#ifndef SST_CORE_SERIALIZATION_IMPL_SERIALIZE_ADAPTER_H
+#define SST_CORE_SERIALIZATION_IMPL_SERIALIZE_ADAPTER_H
+
+#ifndef SST_INCLUDING_SERIALIZE_H
+#warning \
+    "The header file sst/core/serialization/impl/serialize_adapter.h should not be directly included as it is not part of the stable public API.  The file is included in sst/core/serialization/serialize.h"
+#endif
+
+#include "sst/core/serialization/impl/serialize_utility.h"
+#include "sst/core/serialization/serializer.h"
+
+#include <queue>
+#include <stack>
+
+namespace SST::Core::Serialization {
+
+// Serialize adapter classes std::stack, std::queue, std::priority_queue
+template <template <typename...> class T, typename... Ts>
+class serialize_impl<
+    T<Ts...>, std::enable_if_t<
+                  is_same_template_v<T, std::stack> || is_same_template_v<T, std::queue> ||
+                  is_same_template_v<T, std::priority_queue>>>
+{
+    struct S : T<Ts...>
+    {
+        using T<Ts...>::c; // access protected container
+    };
+
+public:
+    void operator()(T<Ts...>& v, serializer& ser)
+    {
+        ser& static_cast<S&>(v).c; // serialize the underlying container
+    }
+};
+
+} // namespace SST::Core::Serialization
+
+#endif // SST_CORE_SERIALIZATION_IMPL_SERIALIZE_ADAPTER_H