from_json()

template<typename T >

static void MayaFlux::IO::JSONSerializer::from_json ( const nlohmann::json &  j, T &  out  )

inlinestaticprivate

Definition at line 207 of file JSONSerializer.hpp.

    {
        if constexpr (Reflectable<T>) {
            if (!j.is_object()) {
                auto e = nlohmann::json::type_error::create(
                    302, "expected object for Reflectable type", &j);
                error<std::runtime_error>(
                    Journal::Component::IO,
                    Journal::Context::Runtime,
                    std::source_location::current(),
                    "JSON type error: {}", e.what());
            }
            std::apply(
                [&](const auto&... props) {
                    (decode_property(j, out, props), ...);
                },
                T::describe());
        } else if constexpr (is_optional_v<T>) {
            using Inner = typename is_optional<T>::inner;
            if (j.is_null()) {
                out = std::nullopt;
            } else {
                Inner inner {};
                from_json(j, inner);
                out = std::move(inner);
            }
        } else if constexpr (is_vector_v<T>) {
            using V = typename is_vector<T>::element;
            if (!j.is_array()) {
                auto e = nlohmann::json::type_error::create(302, "expected array", &j);
                error<std::runtime_error>(
                    Journal::Component::IO,
                    Journal::Context::Runtime,
                    std::source_location::current(),
                    "JSON type error: {}", e.what());
            }
            out.clear();
            out.reserve(j.size());
            for (const auto& item : j) {
                V element {};
                from_json(item, element);
                out.push_back(std::move(element));
            }
        } else if constexpr (is_string_map_v<T>) {
            using V = typename is_string_map<T>::element;
            if (!j.is_object()) {
                auto e = nlohmann::json::type_error::create(302, "expected object for map", &j);
                error<std::runtime_error>(
                    Journal::Component::IO,
                    Journal::Context::Runtime,
                    std::source_location::current(),
                    "JSON type error: {}", e.what());
            }
            out.clear();
            for (const auto& [k, v] : j.items()) {
                V val {};
                from_json(v, val);
                out.emplace(k, std::move(val));
            }
        } else if constexpr (GlmSerializable<T>) {
            decode_glm(j, out);
        } else if constexpr (std::is_enum_v<T>) {
            out = static_cast<T>(j.get<std::underlying_type_t<T>>());
        } else if constexpr (std::is_same_v<T, nlohmann::json>) {
            out = j;
        } else {
            out = j.get<T>();
        }
    }

References MayaFlux::IO::T, and MayaFlux::IO::V.