anonymous_namespace{JSONFullDeserialiser.cpp} Namespace Reference

Free helper functions for simdjson customisation points. More...

Functions
auto	get_signals (simdjson::ondemand::object &root, const echomap::Project &project, std::unordered_map< std::string_view, echomap::id_type > &loaded)

Variables
echomap::Worker *	parent_worker = nullptr

Detailed Description

Free helper functions for simdjson customisation points.

Function Documentation

get_signals()

auto anonymous_namespace{JSONFullDeserialiser.cpp}::get_signals	(	simdjson::ondemand::object &	root,
		const echomap::Project &	project,
		std::unordered_map< std::string_view, echomap::id_type > &	loaded )

Definition at line 23 of file JSONFullDeserialiser.cpp.

{
    // Step 1.  Create our factories which detain only the signal metadata (sample rate, etc.) and source information.
    std::vector<std::unique_ptr<echomap::SignalFactory>> factories;
    if (const auto error = root["signals"].get(factories))
        return error;
 
    /*
     * Step 2.  Group the factories by the source filenames of the signals they're constructing.
     *
     * The key of the map is the source filename, and the value is a bijective correspondence between the channel in the
     * wave file and the factory designated to load the channel at the index.
     *
     * That is, the first slot owns the factory for constructing the signal on Channel 1, the second for Channel 2, etc.
     * If there is a gap, the entry is the empty unique_ptr<SignalFactory>, such that it equals nullptr.
     */
    std::unordered_map<std::string, std::vector<std::unique_ptr<echomap::SignalFactory>>> slots;
 
    for (auto factory : factories | std::views::as_rvalue) {
        const auto& signal = factory->observe_signal();
        if (!loaded.emplace(signal.get_name(), signal.get_id()).second)
            throw std::runtime_error(std::format("Project contains duplicate signal {}.", signal.get_name()));
 
        if (signal.observe_source().has_value()) {
            /*
             * If the Signal has a Source, it comes from the filesystem. Register the Signal as a destination for its
             * source file for its channel number.
             */
            auto& slot_vector = slots[signal.observe_source()->path.c_str()];
            const auto channel_num = signal.observe_source()->channel;
 
            // Reminder: channel numbers are 1-based.
            if (channel_num > slot_vector.size())
                slot_vector.resize(channel_num);
            else if (slot_vector[channel_num - 1] != nullptr)
                throw std::runtime_error(
                        std::format(
                                "Both signals {} and {} have requested the same channel {} from {}.",
                                slot_vector[channel_num - 1]->observe_signal().get_name(),
                                signal.get_name(),
                                channel_num,
                                signal.observe_source()->path.c_str()
                        )
                );
 
            slot_vector[channel_num - 1] = std::move(factory);
        }
    }
 
    /*
     * Step 3.  Once we have the factories grouped by source, and put into the bijective correspondence with the channel
     * numbers, submit a task to the thread-safe Worker for each distinct file. The task takes ownership of the
     * factories.
     *
     * The results will own the signal objects produced by the factories, which can be added to the project by the
     * EchoMap controller (or whoever is the nominated consumer).
     */
    if (!slots.empty()) {
        if (parent_worker == nullptr)
            throw std::runtime_error(
                    std::format(
                            "Need to despatch extra work to load {}, but a suitable Worker is unavailable.",
                            project.get_name()
                    )
            );
 
        for (auto&& [file_path, slot_vector] : slots)
            parent_worker->submit(
                    std::make_unique<echomap::LoadSignalFileTask>(project.get_id(), file_path, std::move(slot_vector))
            );
    }
 
    return simdjson::SUCCESS;
}

Variable Documentation

parent_worker

echomap::Worker* anonymous_namespace{JSONFullDeserialiser.cpp}::parent_worker = nullptr

Definition at line 21 of file JSONFullDeserialiser.cpp.