JsonSerializable.hpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//
 
#pragma once

 
#include "shambase/SourceLocation.hpp"
#include "sham/format/format.hpp"
#include <nlohmann/json.hpp>
#include <source_location>
#include <unordered_map>
#include <concepts>
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
 
namespace shamrock::solvergraph {

    struct JsonSerializable {
        virtual ~JsonSerializable() = default;

        void to_json(nlohmann::json &j) const {
            _impl_to_json(j);
            j["type"] = type_name();
        }

        virtual std::string type_name() const = 0;

        static std::unique_ptr<JsonSerializable> from_json(const nlohmann::json &j);
 
        protected:
        virtual void _impl_to_json(nlohmann::json &j) const = 0;
    };

    template<typename T>
    concept JsonDeserializable
        = std::derived_from<T, JsonSerializable> && requires(const nlohmann::json &j) {
              { T::from_json(j) } -> std::same_as<T>;
          };

    class JsonSerializable_registry {
 
        using Factory = std::function<std::unique_ptr<JsonSerializable>(const nlohmann::json &)>;
        std::unordered_map<std::string, Factory> factories;
 
        public:
        static JsonSerializable_registry &instance() {
            static JsonSerializable_registry registry;
            return registry;
        }

        template<JsonDeserializable T>
        void register_type(
            const std::string &name, std::source_location loc = std::source_location::current()) {
 
            const auto [it, inserted] = factories.try_emplace(name, [](const nlohmann::json &j) {
                return std::make_unique<T>(T::from_json(j));
            });
 
            // if the type is already registered, throw an error
            if (!inserted) {
                throw std::runtime_error(
                    shambase::format(
                        "Type {} already registered (called from {})",
                        name,
                        shambase::format_one_line_func(loc)));
            }
        }

        bool is_type_registered(const std::string &name) const { return factories.contains(name); }

        std::unique_ptr<JsonSerializable> create(
            const std::string &type, const nlohmann::json &data) const {
            auto it = factories.find(type);
 
            if (it == factories.end())
                throw std::runtime_error("Unknown type: " + type);
 
            return it->second(data);
        }
    };
 
    inline std::unique_ptr<JsonSerializable> JsonSerializable::from_json(const nlohmann::json &j) {
        if (!j.is_object() || !j.contains("type") || !j["type"].is_string()) {
            throw std::runtime_error(
                "Invalid JSON for deserialization: expected an object with a string 'type' field.");
        }
        const std::string type = j.at("type").get<std::string>();
        return JsonSerializable_registry::instance().create(type, j);
    }
 
} // namespace shamrock::solvergraph