Method loadModuleAsyncInner

valdi/src/valdi/runtime/Resources/ResourceManager.cpp:496–549

        }
        const auto* strategy = moduleLoadStrategy.value()->getStrategyForComponentPath(componentPathString);
        if (strategy == nullptr) {
            return;
        }

        // Load each modules
        for (const auto& moduleName : strategy->valdiModules) {
            self->getBundle(moduleName);
        }
    });
}

void ResourceManager::warmUpBundles(const std::vector<StringBox>& modulePaths) {
    FlatSet<StringBox> seen;
    std::vector<StringBox> bundles;
    for (const auto& path : modulePaths) {
        auto sv = path.toStringView();
        auto slash = sv.find('/');
        if (slash != std::string_view::npos) {
            auto bundleName = StringCache::getGlobal().makeString(sv.substr(0, slash));
            if (seen.insert(bundleName).second) {
                bundles.push_back(bundleName);
            }
        }
    }

    _workerQueue->async([self = strongSmallRef(this), bundles = std::move(bundles)]() {
        VALDI_TRACE("Valdi.warmUpBundles");
        for (const auto& bundleName : bundles) {
            self->getBundle(bundleName);
        }
    });
}

void ResourceManager::loadModuleAsync(const StringBox& bundleName,
                                      ResourceManagerLoadModuleType loadType,
                                      Function<void(Result<Void>)> onComplete) {
    loadModuleAsync(_workerQueue, bundleName, loadType, std::move(onComplete));
}

void ResourceManager::loadModuleAsync(const Ref<DispatchQueue>& dispatchQueue,
                                      const StringBox& bundleName,
                                      ResourceManagerLoadModuleType loadType,
                                      Function<void(Result<Void>)> onComplete) {
    dispatchQueue->async([self = strongSmallRef(this), bundleName, loadType, completion = std::move(onComplete)]() {
        FlatSet<StringBox> processedModules;
        self->loadModuleAsyncInner(bundleName, processedModules, loadType, completion);
    });
}

void ResourceManager::loadModuleAsyncInner(const StringBox& bundleName,
                                           FlatSet<StringBox>& processedModules,
                                           ResourceManagerLoadModuleType loadType,
                                           Function<void(Result<Void>)> onComplete) {
    if (processedModules.find(bundleName) != processedModules.end()) {
        onComplete(Void());
        return;
    }