shared_library.hpp

Go to the documentation of this file.

// ===-- include/psystem/framwork/shared_library.hpp ------ -*- C++ -*- --=== //
// Copyright (c) 2015 Matt Bisson.  All rights reserved.

#pragma once
#ifndef PSYSTEM_FRAMEWORK_SHARED_LIBRARY_HPP
#define PSYSTEM_FRAMEWORK_SHARED_LIBRARY_HPP

#include "platform.hpp"

#include <algorithm>
#include <type_traits>
#include <vector>

#include "not_copyable.hpp"
#include "shared_handle.hpp"
#include "type_traits.hpp"

namespace psystem {

class shared_library
    : public psystem::not_copyable
{
public:
    using library_version = uint32_t;

protected:
    explicit shared_library(
        std::string library_name, size_t num_functions) noexcept;
public:
    ~shared_library() noexcept;

public:
    library_version get_version() const;

    bool is_loaded() const noexcept;

    void load();

    void unload() noexcept;

protected:
    FARPROC get_function(char const *export_name) const;

    template <size_t N>
    void load_all_functions(char const *export_names[N])
    {
        ASSERT(is_loaded());
        ASSERT(N == m_functions.size());

        std::transform(
            export_names, export_names + N, // Input = export_names
            m_functions.begin(),            // Output = m_functions
            [this] (char const *export_name) {
                return get_function(export_name);
            });
    }

protected:
    std::vector<FARPROC> m_functions;

    psystem::shared_handle<HMODULE, nullptr> m_library_handle;

    std::string m_library_name;

private:
    template <typename T>
    struct loaded_function_base
    {
        static_assert(
            std::is_function<T>::value,
            "Template argument must be a function pointer.");

        loaded_function_base(FARPROC proc)
            : m_function(reinterpret_cast<T*>(proc))
        {
        }

        void retarget(FARPROC proc) noexcept
        {
            m_function = reinterpret_cast<T*>(proc);
        }

        T *get_ptr() const noexcept
        {
            return m_function;
        }

    protected:
        T *m_function;
    };

protected:
    template <typename T, typename is_void_ref = has_void_return_type<T>>
    struct loaded_function
        : public loaded_function_base<T>
    {
        loaded_function(FARPROC proc) : loaded_function_base<T>(proc) {}

        template <typename... Args>
        auto operator()(Args&&... args)
            // this->m_function is protected, so using it for the return type of
            // a public function will be trouble.  Instead, we can just use T,
            // and make an assumption that this->m_function is ultimately a T
            // type.
            -> decltype(std::declval<T>()(std::forward<Args>(args)...))
        {
            ASSERT(this->m_function);
            return (*this->m_function)(std::forward<Args>(args)...);
        }
    };

    template <typename T>
    struct loaded_function<T, std::true_type>
        : public loaded_function_base<T>
    {
        loaded_function(FARPROC proc) : loaded_function_base<T>(proc) {}

        template <typename... Args>
        void operator()(Args&&... args)
        {
            ASSERT(this->m_function);
            this->m_function(std::forward<Args>(args)...);
        }
    };
};

} // namespace psystem

#endif // PSYSTEM_FRAMEWORK_SHARED_LIBRARY_HPP