ParameterSerializable.h

#pragma once
#include "Engine/Core/Types.h"
#include "Engine/Parameter/Parameter.h"
#include <cereal/types/optional.hpp>
#include <cereal/types/string.hpp>
#include <cereal/types/vector.hpp>
#include <optional>
#include <string>
#include <vector>
 
namespace enzo::nt {
class Node;
}
 
struct ParameterSerializable
{
    std::string name;
    std::vector<enzo::floatT> floatValues;
    std::vector<enzo::intT> intValues;
    std::vector<std::string> stringValues;
    // One optional expression per component, parallel to the value vector. An
    // empty slot means the component uses its literal value.
    std::vector<std::optional<std::string>> expressions;
    // Multiparm parameters such as ramps store nothing flat. Each instance is a
    // list of field models, so the structure nests one level per instance.
    std::vector<std::vector<ParameterSerializable>> instances;
 
    bool operator==(const ParameterSerializable& other) const = default;
 
    template <class Archive> void serialize(Archive& ar)
    {
        ar(CEREAL_NVP(name),
           CEREAL_NVP(floatValues),
           CEREAL_NVP(intValues),
           CEREAL_NVP(stringValues),
           CEREAL_NVP(expressions),
           CEREAL_NVP(instances));
    }
};
 
// Capture a parameter's live state into a serializable model. Multiparms recurse
// one model per instance field, flat parameters store their value vector.
ParameterSerializable toSerializable(enzo::prm::Parameter& parameter);
 
// Snapshots a flat parameter from its name and values without a live Parameter.
ParameterSerializable toSerializable(std::string name, const enzo::prm::PrmValues& values);
 
// Write a serialized model back onto a live parameter. Multiparms reconcile their
// instance count to the model before writing each field by name.
void applySerializable(enzo::prm::Parameter& parameter, const ParameterSerializable& model);
 
// Writes each model onto the node's parameter of the same name. A model naming a
// parameter the node lacks is skipped.
void applySerializable(enzo::nt::Node& node, const std::vector<ParameterSerializable>& models);