plugin.h

Go to the documentation of this file.

 
#ifndef _UCOM_PLUGIN_HEADER_
#define _UCOM_PLUGIN_HEADER_
 
extern adtf::ucom::IRuntime*                        _runtime;
extern std::function<tResult(adtf::ucom::iobject_ptr<adtf::ucom::IPlugin>&)> _plugin_initialization;
extern std::function<void()>                        _plugin_deinitialization;
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
class cPlugin : public catwo::object<IPlugin,
                                     IPluginLogging,
                                     level_machine<cPlugin,
                                                   IPlugin::tPluginState,
                                                   IPlugin::tPluginState::Deinitialized>>
{
    public:
        UCOM_RESOLVE(IObject, IPlugin);
        static constexpr const tChar* const DEFAULT_PLUGIN_EXTENSION = ".adtfplugin";
 
    private:
        tHandle             m_hModule;
        adtf::util::cString m_strLabel;
 
    public:
        cPlugin(const char* strLabel);
        ~cPlugin();
 
    protected:
        cPlugin(cPlugin&& oPlugin) = delete;
        cPlugin(const cPlugin& oPlugin) = delete;
        cPlugin& operator=(cPlugin&& oPlugin) = delete;
        cPlugin& operator=(const cPlugin& oPlugin) = delete;
    public: // implements IPlugin
        const char* GetLabel() const override;
        iterator_adapter<const tNamedVersion,
                         pointer_iterator> GetVersions() const override;
        uint32_t GetBuildType() const override;
        tResult SetState(tPluginState eState) override;
        tPluginState GetState() const override;
        tResult GetClassFactory(iobject_ptr<const IClassFactory>& pClassFactory) const override;
        void SetHandle(tHandle hModule) override;
        tHandle GetHandle() const override;
 
    public:
        virtual tResult Initialize();
        virtual tResult Deinitialize();
 
    public: // implements IPluginLogging
        void SetLogger(ILogger* pLogger) override;
};
 
 
struct plugin_version_default
{
     static iterator_adapter<const tNamedVersion,
                             pointer_iterator> GetVersions()
        {
            static const std::array<const tNamedVersion, 1> sVersions{{UCOM_VERSION_ID, adtf::ucom::get_ucom_version_information()}};
            return iterator_adapter<const tNamedVersion, pointer_iterator>::create(&*sVersions.begin(), &*sVersions.begin() + sVersions.size());
        }
};
 
 
template<typename PLUGIN_VERSION_TYPE, typename ...CLASSES>
class plugin_template: public cPlugin
{
    private:
         object_ptr<const IClassFactory> m_pClassFactory;
    public:
         iterator_adapter<const tNamedVersion, 
                          pointer_iterator> GetVersions() const
         {
             return PLUGIN_VERSION_TYPE::GetVersions();
         }
    public:
        plugin_template(const char* strLabel):
            cPlugin(strLabel),
            m_pClassFactory(make_object_ptr<class_factory<CLASSES...>>())
        {
        }
 
        tResult GetClassFactory(iobject_ptr<const IClassFactory>& pClassFactory) const
        {
            pClassFactory.Reset(m_pClassFactory);
            RETURN_NOERROR;
        }
};
 
template<typename PLUGIN_CLASS>
struct plugin_initializer
{
    template <typename ...Args>
    static object_ptr<IPlugin> Get(Args&&... args)
    {
        // make sure the symbols are included
        if (_runtime == reinterpret_cast<IRuntime*>(-1)) // never true, and won't be optimised away
        {
            UCOM_GetVersion3(nullptr, nullptr, nullptr, nullptr);
            UCOM_LoadPlugin3(nullptr, 0, 0, 0, nullptr, 0);
            UCOM_UnloadPlugin3();
        }
        return object_ptr<IPlugin>(make_object_ptr<PLUGIN_CLASS>(std::forward<Args>(args)...));
    }
};
 
}
 
using ant::cPlugin;
using ant::plugin_template;
using ant::plugin_initializer;
using ant::plugin_version_default;
 
}
 
}
#endif