Module.hpp

Go to the documentation of this file.

 
#ifndef FOCS_MODULE
#define FOCS_MODULE
 
#include "DataProvider.hpp"
#include "FileReader.hpp"
#include "FileWriter.hpp"
#include "Log.hpp"
 
#include <boost/filesystem.hpp>
 
#include <iostream>
#include <memory>
#include <string>
#include <vector>
 
 
// This is everything needed to create a new module
 
namespace focs {
    static const std::string module_allocator_function = "focs_module_allocator";
    static const std::string module_deleter_function = "focs_module_deleter";
 
    class ModuleManager;
    struct ModuleConfiguration {
        ModuleConfiguration(ModuleManager& module_manager_, Log& log_) : module_manager{module_manager_}, log{log_} {}
        ModuleManager& module_manager;
        Log& log;
    };
 
    // TODO: Should this class get moved into its own header, like FileReader?
    // If helper classes/functions are needed, it will be.  (This will likely
    // happen, as it would behoove me to tie together KvStore and
    // getopt/boost::program_options/etc, or otherwise switch to JSON for
    // configs with extra processing for including other files, etc, like
    // KvStore has.  Must ask someone smarter.)
 
    class Command {
    public:
        virtual ~Command() = default;
        virtual const std::vector<std::string>& respond_to() const = 0;
        virtual int call_command(int argc, const char* argv[]) const = 0;
        virtual const std::string* brief_summary() const {return nullptr;}
        virtual const std::string* group() const {return nullptr;}
    };
 
    class Module {
    public:
        virtual ~Module() = default;
 
        virtual const std::string& name() const = 0;
        virtual const std::vector<std::unique_ptr<Command>>& commands() const {return no_commands_;}
        virtual const std::vector<std::unique_ptr<DataProvider>>& data_providers() const {return no_data_providers_;}
        virtual const std::vector<std::unique_ptr<FileReader>>& file_readers() const {return no_file_readers_;}
        virtual const std::vector<std::unique_ptr<FileWriter>>& file_writers() const {return no_file_writers_;}
    private:
        std::vector<std::unique_ptr<Command>> no_commands_{};
        std::vector<std::unique_ptr<DataProvider>> no_data_providers_{};
        std::vector<std::unique_ptr<FileReader>> no_file_readers_{};
        std::vector<std::unique_ptr<FileWriter>> no_file_writers_{};
    };
}
 
// Nothing below here is for user consumption.
 
namespace focs {
    class ModuleLoader {
    public:
        static bool is_module(const boost::filesystem::path& path);
 
        ModuleLoader(const boost::filesystem::path& path, const ModuleConfiguration& configuration);
        ~ModuleLoader();
 
        void load_module();
        std::shared_ptr<Module> get_module() const;
        void unload_module();
        bool is_loaded() const;
        const boost::filesystem::path& path() const;
 
    private: // these need to accommodate every implementation or this needs to be split out into a base class again
        boost::filesystem::path path_;
        const ModuleConfiguration& configuration_;
        void* handle_ { nullptr };
        std::shared_ptr<Module> module_;
    };
}
 
#endif // FOCS_MODULE