dll parser

#pragma once
#ifndef _DLL_PARSER_H_
#define  _DLL_PARSER_H_
#include <string>
#include <map>
#include <functional>
#include <Windows.h>

class DLLParser
{
public:
    DLLParser() : m_hMod(nullptr)
    {
    }

    ~DLLParser() 
    {
        UnLoad();
    }

    bool Load(const std::string &dll_path)
    {
        m_hMod = LoadLibraryA(dll_path.data());
        if (nullptr == m_hMod) {
            printf("LoadLibrary fail\n");
            return false;
        }
        return true;
    }

    bool UnLoad()
    {
        if (m_hMod == nullptr) 
        {
            return true;
        }
        auto b = FreeLibrary(m_hMod);
        if (!b)return false;
        m_hMod = nullptr;
        return true;
    }

    template<typename T>
    std::function<T> GetFunction(const std::string &func_name)
    {
        auto it = m_map.find(func_name);
        if (it == m_map.end())
        {
            auto addr = GetProcAddress(m_hMod, func_name.c_str());
            if (!addr) return false;
            m_map.insert(std::make_pair(func_name, addr));
            it = m_map.find(func_name);
        }
        return std::function<T>((T*)(it->second));
    }

    template<typename T, typename... Args>
    typename std::result_of<std::function<T>(Args...)>::type ExceuteFunc
    (const std::string &func_name, Args&&... args)
    {
        auto f = GetFunction<T>(func_name);
        if (f == nullptr)
        {
            std::string exception_str = "can not find this function " + func_name;
            throw std::exception(exception_str.c_str());
        }
        return f(std::forward<Args>(args)...);
    }
private:
    HMODULE m_hMod;
    std::map<std::string, FARPROC> m_map;
};

#endif // _DLL_PARSER_H_