plugin.h

Go to the documentation of this file.

#ifndef PLUGIN_LOADER_H
#define PLUGIN_LOADER_H
 
#include <ArduinoJson.h>
#include <etl/optional.h>
 
 
namespace loader {
    using etl::optional;
    
    struct Function {
        enum class Returns { None, Bool, Int, String, JsonObject };
        typedef void (None_f)(); typedef bool (Bool_f)();  typedef int (Int_f)();
        typedef std::string (String_f)(); typedef JsonObject (JsonObject_f)();
 
        uint32_t addr = 0x0;
        Returns ret_type = Returns::None;
    };
    
    void convertFromJson(JsonVariantConst src, Function& f);
 
    struct Plugin {
        uint8_t *load_addr=0;    
        uint32_t size=0;         
        Function entry;          
        optional<Function> exit; 
       
        bool can_load() const { return !load_addr || size; }
        // bool is_loaded() const { return size; }
    };
    
    struct SinglePluginLoader {
        optional<Plugin> plugin;  
        uint8_t* load_addr=0;     
        uint32_t memsize=0;       
        
        bool can_load() const { return plugin ? plugin->can_load() : (load_addr!=0); }
        //virtual bool load(uint8_t* code, size_t code_len); // convenience function, put code in place, returns true if success
        //virtual bool load(size_t code_len);
        int load(const Plugin& new_plugin); 
        void unload() { plugin.reset(); } 
        
        virtual int load_and_execute(JsonObjectConst msg_in, JsonObject &msg_out); 
        //virtual void show(JsonObjectConst msg_in, JsonObject &msg_out); ///< show what is currently there
        virtual int unload(JsonObjectConst msg_in, JsonObject &msg_out); 
    };
    
    struct GlobalPluginLoader : public SinglePluginLoader {
        GlobalPluginLoader();
    };
 
 
    extern GlobalPluginLoader PluginLoader;
    //using PluginLoader = GlobalPluginLoader;
 
    void convertToJson(const GlobalPluginLoader& src, JsonVariant dst);
 
    
    /*
    
    It is not so hard to come up with other loaders, such as ones reserving space on the
      - Heap (can load multiple plugins, each of differing size)
        Difficulties: Have to disable RAM2 cache for allowing data be executed there
      - unreserved RAM1 just between stack and data segment (can run a heap there
        or just use memory only when neccessary)
        Difficulties: Have to be sure not to mess up with the regular stack
    or other things. The above GlobalPluginLoader is just one example.
    
    */
} // end of namespace loader
 
 
 
 
 
#endif /* PLUGIN_LOADER_H */