reconstruct() [1/2]

StateDecoder::ReconstructionResult MayaFlux::Nexus::StateDecoder::reconstruct	(	Fabric &	fabric,
		const std::string &	base_path
	)

Patch existing entities and construct missing ones from schema.

Entities whose id exists in the fabric are patched in place. Missing entities are constructed, their callables resolved via the fabric's function registry (left empty with a warning if absent), and wired. Restorable wiring kinds: every (with its scheduler tokens), move_to and commit_driven. Any other kind falls back to commit_driven with a warning. Entity ids are assigned by the Fabric, so a reconstructed entity may get a different id, which is warned. Hard failure (bad schema, unreadable EXR, dimension mismatch) sets last_error() and returns a zeroed result.

Parameters

fabric	Target fabric. May be empty, partial, or full.
base_path	Path stem without extension.

Returns

Counts and per-entity warnings.

Definition at line 754 of file Decoder.cpp.

{
    ReconstructionResult result;
    m_last_error.clear();
 
    const std::string json_path = base_path + ".json";
    const std::string exr_path = base_path + ".exr";
 
    IO::JSONSerializer ser;
    auto schema_opt = ser.read<State::FabricSchema>(json_path);
    if (!schema_opt) {
        m_last_error = "Failed to load schema: " + ser.last_error();
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return result;
    }
    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 result;
    }
 
    if (schema.entities.empty()) {
        m_last_error = "Schema contains no entities: " + json_path;
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return result;
    }
 
    auto pv_opt = load_exr(exr_path, static_cast<uint32_t>(schema.entities.size()), State::k_exr_rows, m_last_error);
    if (!pv_opt) {
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return result;
    }
    const auto* pixels = pv_opt->image.as_float();
    const uint32_t width = pv_opt->width;
 
    note_older_version(schema.version, result.warnings);
 
    const auto existing_ids = fabric.all_ids();
    const std::unordered_set<uint32_t> existing(existing_ids.begin(), existing_ids.end());
 
    for (size_t i = 0; i < schema.entities.size(); ++i) {
        const auto& entry = schema.entities[i];
 
        if (!State::kind_known(entry.kind)) {
            result.warnings.push_back("Unknown kind '" + entry.kind
                + "' for id " + std::to_string(entry.id) + ", skipping");
            ++result.skipped;
            continue;
        }
 
        const Fields fields = read_fields(entry, *pixels, width, i, schema.ranges);
 
        if (existing.contains(entry.id)) {
            if (patch_entity(fabric, entry, fields, result.warnings)) {
                ++result.patched;
            } else {
                ++result.skipped;
            }
        } else {
            construct_entity(fabric, entry, fields, result.warnings);
            ++result.constructed;
        }
    }
 
    for (const auto& xrec : schema.expanses) {
        switch (restore_expanse(fabric, xrec, result.warnings)) {
        case Restored::Constructed:
            ++result.constructed;
            break;
        case Restored::Patched:
            ++result.patched;
            break;
        case Restored::Skipped:
            ++result.skipped;
            break;
        }
    }
 
    MF_INFO(Journal::Component::Nexus, Journal::Context::FileIO,
        "StateDecoder::reconstruct: constructed={} patched={} skipped={} warnings={}",
        result.constructed, result.patched, result.skipped, result.warnings.size());
 
    return result;
}

References MayaFlux::Nexus::Fabric::all_ids(), MayaFlux::Nexus::StateDecoder::ReconstructionResult::constructed, MayaFlux::Journal::FileIO, MayaFlux::Nexus::State::k_exr_rows, MayaFlux::Nexus::State::kind_known(), MayaFlux::IO::JSONSerializer::last_error(), m_last_error, MF_ERROR, MF_INFO, MayaFlux::Journal::Nexus, MayaFlux::Nexus::StateDecoder::ReconstructionResult::patched, pixels, MayaFlux::IO::JSONSerializer::read(), MayaFlux::Nexus::StateDecoder::ReconstructionResult::skipped, MayaFlux::Nexus::StateDecoder::ReconstructionResult::warnings, and width.

Referenced by reconstruct().

Here is the call graph for this function:

Here is the caller graph for this function: