reconstruct() [2/2]

StateDecoder::ReconstructionResult MayaFlux::Nexus::StateDecoder::reconstruct	(	Tapestry &	tapestry,
		const std::string &	base_dir
	)

Reconstruct all Fabrics in tapestry from base_dir.

Reads tapestry.json, creates or finds Fabrics by name (a created Fabric gets the cell size its file recorded), calls reconstruct(fabric, base_path) for each, then restores Tapestry-level named Expanses and registers them on the listed Fabrics. A name the Tapestry already holds is reused, not recreated.

Parameters

tapestry	Target Tapestry. May be empty or partially populated.
base_dir	Directory path matching the one passed to encode().

Returns

ReconstructionResult aggregated across all Fabrics.

Definition at line 841 of file Decoder.cpp.

{
    ReconstructionResult total;
    m_last_error.clear();
 
    const std::string tapestry_path = base_dir + "/tapestry.json";
    IO::JSONSerializer ser;
    auto schema_opt = ser.read<State::TapestrySchema>(tapestry_path);
    if (!schema_opt) {
        m_last_error = "Failed to load tapestry schema: " + ser.last_error();
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return total;
    }
    const auto& schema = *schema_opt;
 
    if (!version_supported(schema.version)) {
        m_last_error = version_error(schema.version);
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return total;
    }
 
    for (const auto& ref : schema.fabrics) {
        auto fabric = tapestry.get_fabric(ref.name);
        if (!fabric) {
            fabric = tapestry.create_fabric(ref.name,
                read_cell_size(ref.base_path + ".json").value_or(1.0F));
        }
        auto result = reconstruct(*fabric, ref.base_path);
        total.constructed += result.constructed;
        total.patched += result.patched;
        total.skipped += result.skipped;
        for (auto& w : result.warnings) {
            total.warnings.push_back(ref.name + ": " + std::move(w));
        }
    }
 
    for (const auto& xrec : schema.expanses) {
        const std::string label = "TapestryExpanse '" + xrec.name + "'";
        if (!expanse_restorable(xrec, label, total.warnings)) {
            ++total.skipped;
            continue;
        }
 
        std::vector<Fabric*> fabrics;
        for (const auto& fname : xrec.fabric_names) {
            if (auto fabric = tapestry.get_fabric(fname)) {
                fabrics.push_back(fabric.get());
            } else {
                total.warnings.push_back(label + ": fabric '" + fname + "' not found");
            }
        }
 
        std::shared_ptr<Expanse> expanse = tapestry.get_expanse(xrec.name);
        const bool existed = expanse != nullptr;
 
        if (existed) {
            apply_bounds(*expanse, xrec);
        } else {
            ExpanseParts parts;
            if (!resolve_expanse_parts(xrec, fabrics, label, parts, total.warnings)) {
                ++total.skipped;
                continue;
            }
 
            if (xrec.fn_name.empty()) {
                expanse = tapestry.create_expanse<Expanse>(
                    xrec.name,
                    Kinesis::AABB3D { .min = *xrec.bounds_min, .max = *xrec.bounds_max },
                    std::move(parts.on_enter),
                    std::move(parts.on_exit));
            } else {
                expanse = tapestry.create_expanse(
                    xrec.name,
                    std::move(parts.contains),
                    std::move(parts.on_enter),
                    std::move(parts.on_exit));
                apply_bounds(*expanse, xrec);
            }
 
            if (!expanse) {
                ++total.skipped;
                continue;
            }
            expanse->set_fn_name(xrec.fn_name);
            expanse->set_on_enter_fn_name(xrec.on_enter_fn_name);
            expanse->set_on_exit_fn_name(xrec.on_exit_fn_name);
        }
 
        for (Fabric* fabric : fabrics) {
            fabric->add_expanse(expanse);
        }
        if (existed) {
            ++total.patched;
        } else {
            ++total.constructed;
        }
    }
 
    total.user_state = schema.user_state;
 
    MF_INFO(Journal::Component::Nexus, Journal::Context::FileIO,
        "StateDecoder::reconstruct(Tapestry): constructed={} patched={} skipped={} warnings={}",
        total.constructed, total.patched, total.skipped, total.warnings.size());
    return total;
}

References MayaFlux::Nexus::Tapestry::create_expanse(), MayaFlux::Nexus::Tapestry::create_fabric(), MayaFlux::Journal::FileIO, MayaFlux::Nexus::Tapestry::get_expanse(), MayaFlux::Nexus::Tapestry::get_fabric(), label, MayaFlux::IO::JSONSerializer::last_error(), m_last_error, MF_ERROR, MF_INFO, MayaFlux::Kinesis::AABB3D::min, MayaFlux::Journal::Nexus, MayaFlux::IO::JSONSerializer::read(), reconstruct(), and total.

Here is the call graph for this function: