nsmsgs/src/UNsmPlugin.cpp

#include "UNsmPlugin.h"

#include <array>

#include "../../Common/UNsmConsts.h"
#include "../../Common/dummy.h"

#include "DllUtils.h"

namespace Regnessem
{
        namespace System
        {
                // NsmPlugin::FindByModuleName -----------------------------------------------

                NsmPlugin::FindByModuleName::FindByModuleName(const tstring &s)
                        :x(s)
                {}

                bool NsmPlugin::FindByModuleName::operator ()(const NsmPluginListSub &v) const
                {
                        return v->PluginInfo.ModuleName == x;
                }

                // NsmPlugin ------------------------------------------------------------------

                NsmPlugin::NsmPlugin(const tstring &filePath)
                        :DllHandle(LoadLibrary(filePath.c_str()))
                        ,HGetPluginInfo()
                        ,HInitialize()
                        ,HTerminate()
                {
                        if(!DllHandle)
                                return;

#if defined(_WINDOWS)
                        std::array<TCHAR, MAX_PATH> buf;
                        if(GetModuleFileName(DllHandle, buf.data(), std::tuple_size<decltype(buf)>::value))
                                FileName = buf.data();
                        else
                                FileName = filePath;
#else
                        FileName = filePath;
#endif

                        HGetPluginInfo = reinterpret_cast<TGetPluginInfo*>(ProcAddress("GetPluginInfo"));
                        HInitialize    = reinterpret_cast<TInitialize*>(ProcAddress("Initialize"));
                        HTerminate     = reinterpret_cast<TTerminate*>(ProcAddress("Terminate"));

                        PluginInfo.ApiVersion    = GetPluginInfoEx(NMPI_APIVER);
                        PluginInfo.ModuleName    = GetPluginInfoEx(NMPI_MODULENAME);
                        PluginInfo.DisplayName   = GetPluginInfoEx(NMPI_TITLE);
                        PluginInfo.Description   = GetPluginInfoEx(NMPI_DESCRIPTION);
                        PluginInfo.Author        = GetPluginInfoEx(NMPI_AUTHOR);
                        PluginInfo.Copyright     = GetPluginInfoEx(NMPI_COPYRIGHT);
                        PluginInfo.PluginVersion = GetPluginInfoEx(NMPI_PLUGINVER);
                }

                NsmPlugin::~NsmPlugin()
                {
                        if(DllHandle)
                                FreeLibrary(DllHandle);
                }

                FARPROC NsmPlugin::ProcAddress(LPCSTR procName) const
                {
#ifdef WINCE
                        return GetProcAddress(DllHandle, c2w(procName).c_str());
#else
                        return GetProcAddress(DllHandle, procName);
#endif
                }

                bool NsmPlugin::IsLoaded() const
                {
                        return DllHandle != NULL;
                }

                int NsmPlugin::GetPluginInfo(int infoNo, LPSTR lpBuffer, int nSize) const
                {
                        if(HGetPluginInfo)
                                return HGetPluginInfo(infoNo, lpBuffer, nSize);
                        else
                                return 0;
                }

                tstring NsmPlugin::GetPluginInfoEx(int infoNo) const
                {
                        std::array<char, 256> buf;
                        if(0 < GetPluginInfo(infoNo, buf.data(), std::tuple_size<decltype(buf)>::value))
                                return c2t(buf.data());
                        else
                                return tstring();
                }

                int NsmPlugin::Initialize(PNsmPluginInitInfo lpPluginInitInfo) const
                {
                        if(HInitialize)
                                return HInitialize(lpPluginInitInfo);
                        else
                                return NsmPluginState::NotImplementedError;
                }

                int NsmPlugin::Terminate() const
                {
                        if(HTerminate)
                                return HTerminate();
                        else
                                return NsmPluginState::NotImplementedError;
                }
        }
}