PluginFactory.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_PLUGIN_FACTORY_HPP
#define OPENSWMM_ENGINE_PLUGIN_FACTORY_HPP
 
#include <string>
#include <vector>
#include <functional>
 
// Forward declarations — avoid pulling in full plugin SDK in every TU
namespace openswmm {
    class IPluginComponentInfo;
    class IOutputPlugin;
    class IReportPlugin;
    struct SimulationContext;
    struct SimulationSnapshot;
    struct PluginSpec;
}
 
namespace openswmm {
 
class PluginFactory {
public:
    PluginFactory() = default;
    ~PluginFactory();
 
    // Non-copyable, movable
    PluginFactory(const PluginFactory&) = delete;
    PluginFactory& operator=(const PluginFactory&) = delete;
    PluginFactory(PluginFactory&&) noexcept = default;
    PluginFactory& operator=(PluginFactory&&) noexcept = default;
 
    // -----------------------------------------------------------------------
    // Loading
    // -----------------------------------------------------------------------
 
    int load_plugins(
        const std::vector<PluginSpec>& specs,
        std::function<void(const std::string&)> warn_cb = {}
    );
 
    // -----------------------------------------------------------------------
    // Lifecycle dispatch (main thread — call in order)
    // -----------------------------------------------------------------------
 
    int initialize_all(SimulationContext& ctx);
 
    int validate_all(SimulationContext& ctx);
 
    int prepare_all(SimulationContext& ctx);
 
    int update_all(const SimulationSnapshot& snapshot);
 
    int finalize_all(SimulationContext& ctx);
 
    int write_summary_all(SimulationContext& ctx);
 
    // -----------------------------------------------------------------------
    // Introspection
    // -----------------------------------------------------------------------
 
    const std::vector<IOutputPlugin*>& output_plugins() const noexcept {
        return output_plugins_;
    }
 
    const std::vector<IReportPlugin*>& report_plugins() const noexcept {
        return report_plugins_;
    }
 
    int plugin_count() const noexcept {
        return static_cast<int>(output_plugins_.size() + report_plugins_.size());
    }
 
    bool empty() const noexcept { return plugin_count() == 0; }
 
    void unload_all();
 
    void add_output_plugin(IOutputPlugin* plugin,
                           std::vector<std::string> args = {});
 
    void add_report_plugin(IReportPlugin* plugin);
 
private:
    // -----------------------------------------------------------------------
    // Internal library handle record
    // -----------------------------------------------------------------------
 
    struct LibEntry {
        void*                  handle = nullptr;  
        IPluginComponentInfo*  info   = nullptr;  
        std::string            path;              
    };
 
    std::vector<LibEntry>        libs_;            
    std::vector<IOutputPlugin*>  output_plugins_;  
    std::vector<IReportPlugin*>  report_plugins_;  
    std::vector<std::vector<std::string>> init_args_; 
 
    // -----------------------------------------------------------------------
    // Platform-specific helpers
    // -----------------------------------------------------------------------
 
    static void* platform_load(const std::string& path);
    static void  platform_unload(void* handle) noexcept;
    static void* platform_sym(void* handle, const char* sym) noexcept;
    static std::string platform_error() noexcept;
};
 
} /* namespace openswmm */
 
#endif /* OPENSWMM_ENGINE_PLUGIN_FACTORY_HPP */