from_json()

template<typename T >

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

inlinestaticprivate

Definition at line 221 of file JSONSerializer.hpp.

    {
        if constexpr (Reflect::Reflectable<T>) {
            if (!j.is_object()) {
                throw nlohmann::json::type_error::create(302, "expected object for Reflectable type", &j);
            }
            std::apply(
                [&](const auto&... props) {
                    (decode_property(j, out, props), ...);
                },
                T::describe());
        } else if constexpr (Reflect::is_optional_v<T>) {
            using Inner = typename Reflect::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 (Reflect::is_vector_v<T>) {
            using V = typename Reflect::is_vector<T>::element;
            if (!j.is_array())
                throw nlohmann::json::type_error::create(302, "expected array", &j);
            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 (Reflect::is_string_map_v<T>) {
            using V = typename Reflect::is_string_map<T>::element;
            if (!j.is_object())
                throw nlohmann::json::type_error::create(302, "expected object for map", &j);
            out.clear();
            for (const auto& [k, v] : j.items()) {
                V val {};
                from_json(v, val);
                out.emplace(k, std::move(val));
            }
        } 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 {
            Serializer<T>::from_json(j, out);
        }
    }

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