serialize_aggregate.h

// Copyright 2009-2026 NTESS. Under the terms
// of Contract DE-NA0003525 with NTESS, the U.S.
// Government retains certain rights in this software.
//
// Copyright (c) 2009-2026, 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_AGGREGATE_H
#define SST_CORE_SERIALIZATION_IMPL_SERIALIZE_AGGREGATE_H
 
#ifndef SST_INCLUDING_SERIALIZE_H
#warning \
    "The header file sst/core/serialization/impl/serialize_aggregate.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 <array>
#include <cstddef>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace SST::Core::Serialization {
 
/////////////////////////////////////////////////////////////////////////////////////////////////////
// Aggregate serialization                                                                         //
//                                                                                                 //
// An aggregate is a C-style array, std::array, or a class/struct/union with all public non-static //
// data members and direct bases, no user-provided, inherited or explicit constructors (C++17), no //
// user-declared or inherited constructors (C++20), and no virtual functions or virtual bases.     //
//                                                                                                 //
// For aggregates which are either not trivially copyable or are not standard layout types, they   //
// can be serialized by using structured bindings to extract their members and serialize each      //
// member separately. The serialization implementation needs to be specialized for each member     //
// count, because until C++26, structured binding packs are not supported.                         //
//                                                                                                 //
// For aggregate serialization,                                                                    //
// - It must be an aggregate class type                                                            //
// - It must not be trivially serializable                                                         //
// - It must not have a serialize_order() method                                                   //
// - It must not contain anonymous union members (not detectable in C++17 except by error)         //
// - The number of fields must be supported by the implementation below                            //
/////////////////////////////////////////////////////////////////////////////////////////////////////
 
namespace pvt {
 
template <typename>
struct serialize_aggregate_map_impl;
 
// For a sequence of indices, serialize each element of an aggregate
// This is only used in mapping mode
template <size_t... INDEX>
struct serialize_aggregate_map_impl<std::index_sequence<INDEX...>>
{
    template <typename T>
    void operator()(T&& t, serializer& ser, ser_opt_t opt)
    {
        // Serialize each element
        (SST_SER_NAME(std::get<INDEX>(t), std::to_string(INDEX).c_str(), opt), ...);
    }
};
 
template <typename T, size_t NFIELDS>
struct serialize_aggregate_impl : std::false_type
{};
 
// Structured binding extracts NFIELDS fields in __VA_ARGS__ and serializes each one separately
#define SERIALIZE_AGGREGATE_IMPL(NFIELDS, ...)                                                                      \
    template <typename T>                                                                                           \
    struct serialize_aggregate_impl<T, NFIELDS> : std::true_type                                                    \
    {                                                                                                               \
        void operator()(T& t, serializer& ser, ser_opt_t opt)                                                       \
        {                                                                                                           \
            auto& [__VA_ARGS__] = t;                                                                                \
            if ( ser.mode() == serializer::MAP ) {                                                                  \
                ser.mapper().map_hierarchy_start(ser.getMapName(), new ObjectMapContainer<T>(&t));                  \
                serialize_aggregate_map_impl<std::make_index_sequence<NFIELDS>>()(std::tie(__VA_ARGS__), ser, opt); \
                ser.mapper().map_hierarchy_end();                                                                   \
            }                                                                                                       \
            else {                                                                                                  \
                [&](auto&... e) { (SST_SER(e), ...); }(__VA_ARGS__);                                                \
            }                                                                                                       \
        }                                                                                                           \
    }
 
SERIALIZE_AGGREGATE_IMPL(1, a0);
SERIALIZE_AGGREGATE_IMPL(2, a0, a1);
SERIALIZE_AGGREGATE_IMPL(3, a0, a1, a2);
SERIALIZE_AGGREGATE_IMPL(4, a0, a1, a2, a3);
SERIALIZE_AGGREGATE_IMPL(5, a0, a1, a2, a3, a4);
SERIALIZE_AGGREGATE_IMPL(6, a0, a1, a2, a3, a4, a5);
SERIALIZE_AGGREGATE_IMPL(7, a0, a1, a2, a3, a4, a5, a6);
SERIALIZE_AGGREGATE_IMPL(8, a0, a1, a2, a3, a4, a5, a6, a7);
SERIALIZE_AGGREGATE_IMPL(9, a0, a1, a2, a3, a4, a5, a6, a7, a8);
SERIALIZE_AGGREGATE_IMPL(10, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
SERIALIZE_AGGREGATE_IMPL(11, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
SERIALIZE_AGGREGATE_IMPL(12, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
SERIALIZE_AGGREGATE_IMPL(13, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
SERIALIZE_AGGREGATE_IMPL(14, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
SERIALIZE_AGGREGATE_IMPL(15, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
SERIALIZE_AGGREGATE_IMPL(16, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
SERIALIZE_AGGREGATE_IMPL(17, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16);
SERIALIZE_AGGREGATE_IMPL(18, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17);
SERIALIZE_AGGREGATE_IMPL(19, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18);
SERIALIZE_AGGREGATE_IMPL(20, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19);
 
// An aggregate class type with no serialize_order() method, an implementation of serialize_aggregate_impl for the
// number of fields, and not trivially serializable
template <typename T>
constexpr bool is_aggregate_serializable_v =
    std::conjunction_v<std::is_class<T>, std::is_aggregate<T>, std::negation<has_serialize_order<T>>,
        serialize_aggregate_impl<T, nfields<T>>, std::negation<is_trivially_serializable<T>>>;
 
// std::array is excluded because it is handled in serialize_array.h
template <typename T, size_t N>
constexpr bool is_aggregate_serializable_v<std::array<T, N>> = false;
 
} // namespace pvt
 
// Serialize aggregate class types which are not trivially serializable
template <typename T>
class serialize_impl<T, std::enable_if_t<pvt::is_aggregate_serializable_v<T>>> :
    pvt::serialize_aggregate_impl<T, nfields<T>>
{
    SST_FRIEND_SERIALIZE();
};
 
} // namespace SST::Core::Serialization
 
#endif // SST_CORE_SERIALIZATION_IMPL_SERIALIZE_AGGREGATE_H