libtools.h

//===========================================================================
#ifndef comfrm_LibSupportH
#define comfrm_LibSupportH
//===========================================================================
// Заготовка модуля LibSupport была сгенерирована CASE средством разработки SA2-DE.
// Все права защищены. (2010)
//
// В данном файле представлен исходный текст основного заголовочного файла модуля.
//
// ======================================= //
//       Параметры новой разработки.
// ======================================= //
// Имя комплекса:  CommonTools  (com)
// Имя решения:    GCAD_3 (gc3)   (прочерк если модуль относится лишь к комплексу)
// Имя проекта:    System  (sys)   (прочерк если модуль относится лишь к решению)
// Полный SID:     comgc3sys
// Время создания: 20:34:55
// Дата создания:  04.12.2010
// ======================================= //
// ============================================================================================ //
//                             Параметры ревизии(версии):
// ============================================================================================ //
// [prd]Period:                     12/2010
// [aut]Author:                     Александр Соколов
// [did]DeveloperID:                sa
// [pid]ProblemID:                  00001
// [rvs = did.date.pid]Revision:    //#sa.04.12.2010.00001
// [dsc]Description:                Поддержка библиотек
// [ccm]CodeComment:                rvs.{[s]Start | [e]End | []}{[n]New | [o]Old | [d]Develop}
// ============================================================================================ //
// [prd]Period:                     08/2012
// [aut]Author:                     Юрин Юрий
// [did]DeveloperID:                yu
// [pid]ProblemID:                  00002
// [rvs = did.date.pid]Revision:    //#yu.08.04.2012.00002
// [dsc]Description:                Добавил класс-обертку над загрузчиком библиотеки. Он позволит
//                                  решить проблему загрузки нескольких функций региcтрации из одной DLL
// [ccm]CodeComment:                rvs.{[s]Start | [e]End | []}{[n]New | [o]Old | [d]Develop}
// ============================================================================================ //
// [prd]Period:                     04/2012
// [aut]Author:                     Александр Соколов
// [did]DeveloperID:                sa
// [pid]ProblemID:                  00003
// [rvs = did.date.pid]Revision:    //#sa.15.04.2012.00003
// [dsc]Description:                Портирование решателей в Linux. Доработка кода для кроссплатформенной компиляции.
// [ccm]CodeComment:                rvs.{[s]Start | [e]End | []}{[n]New | [o]Old | [d]Develop}
// ============================================================================================ //
// [prd]Period:                     11/2012
// [aut]Author:                     Вячеслав Макаренков
// [did]DeveloperID:                mv
// [pid]ProblemID:                  00004
// [rvs = did.date.pid]Revision:    //#mv.09.11.2012.00004
// [dsc]Description:                Добавил функцию освобождения ресурсов при загрузке функции ( не объекта )
// [ccm]CodeComment:                rvs.{[s]Start | [e]End | []}{[n]New | [o]Old | [d]Develop}
// ============================================================================================ //
// [prd]Period:                     03/2013
// [aut]Author:                     Александр Соколов
// [did]DeveloperID:                sa
// [pid]ProblemID:                  00005
// [rvs = did.date.pid]Revision:    //#sa.10.03.2013.00005
// [dsc]Description:                доработка - обработка случая "экспорта" из LIB
// [ccm]CodeComment:                rvs.{[s]Start | [e]End | []}{[n]New | [o]Old | [d]Develop}
// ============================================================================================ //
//========================================================================
// ДОПОЛНИТЕЛЬНЫЕ ПОДКЛЮЧЕНИЯ (Типы и модули, необходимые для .h - файла)
//------------------------------------------------------------------------
#include "memorytools.h"

#include <string>
#include <iostream>

#if defined _WIN32
    #include <windows.h>
    #if defined(_WINDLL)
        #define MAC_DLLEXPORT __declspec(dllexport)
        #define MAC_DLLEXPORT_FROMEXE __declspec(dllimport)
    #else
        #define MAC_DLLEXPORT __declspec(dllimport)
        #define MAC_DLLEXPORT_FROMEXE __declspec(dllexport)
    #endif
    typedef HMODULE DllHandle;
#elif defined __linux__
    #include <dlfcn.h>
    #define MAC_DLLEXPORT
    #define MAC_DLLEXPORT_FROMEXE
    typedef void* DllHandle;
#endif

//========================================================================
namespace com
{
    namespace lib
    {
        template<class TDllHandle>
        int loadLibrary(const std::string& p_dllname, TDllHandle& o_dll)
        {
            int res = 0;

#if defined _WIN32
            o_dll = LoadLibrary(p_dllname.c_str());
#elif defined __linux__
            // Особенность dlopen -- чтобы загрузить библ., находящуюся
            // в текущей директории, нужно задать имя ./libname.so
            std::string dllName(p_dllname);
            std::string libName;
            std::string path;

            // Проверяем, содержится ли в p_dllname только одно имя без пути
            int lastSlashPos = dllName.find_last_of('/');
            if (lastSlashPos != std::string::npos)
            {
                path = dllName.substr(0, lastSlashPos);
                libName = dllName.substr(lastSlashPos + 1);
            }
            else
            {
                path = ".";
                libName = dllName;
            }

            // Приводим имя к общему стандарту: ./libname.so или path1/path2/path3/libname.so
            // Если при этом задано некоторое расширение, сохраняем его
            if (libName.find_last_of('.') == std::string::npos)
                libName += ".so";

            if (libName.substr(0, 3) != "lib")
                libName = "lib" + libName;

            std::string prettyLibName = path + "/" + libName;
            o_dll = dlopen(prettyLibName.c_str(),RTLD_LAZY);
#endif
            if (o_dll == 0)
            {
                std::cerr << "Не удалось загрузить DLL (-1):" << p_dllname << std::endl;
#if defined __linux__
                std::cerr << dlerror() << std::endl;
#endif
                res = -1;
            }

            return res;
        }

        template<class FunctionType, class TDllHandle>
        FunctionType* loadFunction(TDllHandle p_dll, const std::string& p_regfunc)
        {
            FunctionType* reg = NULL;
#if defined _WIN32
            reg = (FunctionType*) GetProcAddress(p_dll, p_regfunc.c_str());
#elif defined __linux__
            reg = (FunctionType*) dlsym(p_dll, p_regfunc.c_str());
#endif
            if (reg == 0)
            {
                std::cerr << "Не удалось найти функцию:" << p_regfunc << std::endl;
#if defined __linux__
                std::cerr << dlerror() << std::endl;
#endif
                return NULL;
            }

            return reg;
        }

        template< class FunctionType, class TDllHandle >
        FunctionType* loadFunction(const std::string& p_dllname, const std::string& p_regfunc,
                                   TDllHandle& o_dll)
        {
            int res = loadLibrary< TDllHandle >(p_dllname, o_dll);

            return loadFunction< FunctionType >(o_dll, p_regfunc);
        }

        template< class TDllHandle >
        void unloadLibrary(TDllHandle p_dll)
        {
#if defined _WIN32
            FreeLibrary(p_dll);
#elif defined __linux__
            dlclose(p_dll);
#endif
        }

        template< class OutClass >
        OutClass* registerObject(void* p_func, const std::string& p_input_file = "")
        {
            typedef OutClass* ftyp1(const char*);
            typedef OutClass* ftyp2();
            if (p_func != 0)
            {
                if (p_input_file != "")
                    return ((ftyp1*) p_func)(p_input_file.c_str());
                else
                    return ((ftyp2*) p_func)();
            }
            else
                return NULL;
        }

        template< class OutClass, class TDllHandle >
        OutClass* registerObject(const std::string& p_dllname, const std::string& p_regfunc,
                                 TDllHandle& o_dll, const std::string& p_input_file = "")
        {
            void* reg = loadFunction< void, TDllHandle >(p_dllname, p_regfunc, o_dll);

            return registerObject< OutClass >(reg, p_input_file);
        }

        template< class OutClass, class InputParam, class TDllHandle >
        OutClass* registerQualifiedObject(const std::string& p_dllname, const std::string& p_regfunc,
                                          TDllHandle& o_dll, const InputParam& p_input_data)
        {
            typedef OutClass* ftyp1(const InputParam&);
            ftyp1* reg = loadFunction< ftyp1, TDllHandle >(p_dllname, p_regfunc, o_dll);
            if (reg != 0)
                return reg(p_input_data);
            else
                return NULL;
        }

        template< class OutClass, class TDllHandle >
        void unregisterObject(OutClass* p_obj, TDllHandle p_dll)
        {
            MAC_MEMRELEASE(p_obj);
            if (p_dll)
            {
#if defined _WIN32
                FreeLibrary(p_dll);
#elif defined __linux__
                dlclose(p_dll);
#endif
            }
        }

        template< class TDllHandle >
        class DllLoader
        {
            TDllHandle mDLL;
            bool mError;

        public:
            bool isError()
            {
                return mError;
            }

            DllLoader(const std::string& p_dll_name)
            {
                int res = loadLibrary< TDllHandle >(p_dll_name, mDLL);

                mError = !mDLL;
            }

            template< typename OutObjectType >
            int createObject(const char* p_reg_func_name, OutObjectType*& o_obj, const std::string& p_input_file = "")
            {
                void* reg = loadFunction< void >(mDLL, p_reg_func_name);
                o_obj = registerObject< OutObjectType >(reg, p_input_file);
                int res = 0;
                if (o_obj == NULL)
                {
                    res = -1;
                }

                return res;
            }

            ~DllLoader()
            {
                if (!mError)
                    FreeLibrary(mDLL);
            }
        };
    };
};


//===========================================================================
#endif
//===========================================================================