component.h

/*
    Lightmetrica : A research-oriented renderer

    Copyright (c) 2014 Hisanari Otsu

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#pragma once
#ifndef LIB_LIGHTMETRICA_COMPONENT_H
#define LIB_LIGHTMETRICA_COMPONENT_H

#include "common.h"
#include "logger.h"
#include "align.h"
#include <string>
#include <functional>
#include <type_traits>

LM_NAMESPACE_BEGIN

class Component : public SIMDAlignedType
{
public:

    Component() {}
    virtual ~Component() {}

public:

    virtual std::string ComponentInterfaceTypeName() const = 0;

    virtual std::string ComponentImplTypeName() const = 0;

};

// --------------------------------------------------------------------------------

class LM_PUBLIC_API ComponentFactory
{
public:

    typedef std::function<Component* ()> CreateComponentFunc;

private:

    ComponentFactory() {}

private:

    LM_DISABLE_COPY_AND_MOVE(ComponentFactory);

public:
    
    static bool CheckRegistered(const std::string& interfaceType, const std::string& implType);

    static bool Register(const std::string& interfaceType, const std::string& implType, const CreateComponentFunc& func);

    static Component* Create(const std::string& interfaceType, const std::string& implType);

    static void LoadPlugins(const std::string& pluginDir);

    static void UnloadPlugins();


public:

    template <typename InterfaceType>
    static bool CheckRegistered(const std::string& implType)
    {
        std::string interfaceType = InterfaceType::InterfaceTypeName();
        return CheckRegistered(interfaceType, implType);
    }

    template <typename InterfaceType>
    static InterfaceType* Create(const std::string& implType)
    {
        std::string interfaceType = InterfaceType::InterfaceTypeName();

        auto* p1 = Create(interfaceType, implType);
        if (p1 == nullptr)
        {
            LM_LOG_ERROR("Invalid instance type '" + implType + "' (interface type : '" + interfaceType + "')");
            return nullptr;
        }

        auto* p2 = dynamic_cast<InterfaceType*>(p1);
        if (p2 == nullptr)
        {
            LM_LOG_ERROR("An instance of type '" + implType + "' is not inherited from '" + interfaceType + "'");
            LM_SAFE_DELETE(p1);
            return nullptr;
        }

        return p2;
    }

    template <typename InterfaceType>
    static InterfaceType* Create()
    {
        return Create<InterfaceType>("default");
    }

};

// --------------------------------------------------------------------------------

template <typename ImplType, typename InterfaceType>
class ComponentFactoryEntry
{
public:

    static ComponentFactoryEntry<ImplType, InterfaceType>& Instance()
    {
        static ComponentFactoryEntry<ImplType, InterfaceType> instance;
        return instance;
    }

private:

    ComponentFactoryEntry()
    {
        // Register entry here
        if (!ComponentFactory::Register(InterfaceType::InterfaceTypeName(), ImplType::ImplTypeName(), [](){ return new ImplType; }))
        {
            LM_LOG_ERROR("Failed to register component '" + std::string(ImplType::ImplTypeName()) + "'");
        }
    }

private:

    ComponentFactoryEntry(const ComponentFactoryEntry<ImplType, InterfaceType>&);
    ComponentFactoryEntry(ComponentFactoryEntry<ImplType, InterfaceType>&&);
    void operator=(const ComponentFactoryEntry<ImplType, InterfaceType>&);
    void operator=(ComponentFactoryEntry<ImplType, InterfaceType>&&);

};

LM_NAMESPACE_END

// --------------------------------------------------------------------------------

#define LM_COMPONENT_INTERFACE_DEF(Name)                        \
    static const char* InterfaceTypeName() { return Name; }     \
    virtual std::string ComponentInterfaceTypeName() const { return InterfaceTypeName(); }

#define LM_COMPONENT_IMPL_DEF(Name)                             \
    static const char* ImplTypeName() { return Name; }          \
    virtual std::string ComponentImplTypeName() const { return ImplTypeName(); }
    
// --------------------------------------------------------------------------------

#define LM_COMPONENT_CREATE_HAS_MEMBER_FUNCTION(FuncName, Signature)        \
    template <typename T, typename = std::true_type>                        \
    struct has_member_function_##FuncName : std::false_type {};             \
                                                                            \
    template <typename T>                                                   \
    struct has_member_function_##FuncName<                                  \
        T,                                                                  \
        std::integral_constant<                                             \
            bool,                                                           \
            check_func_signature<Signature, &T::FuncName>::value            \
        >                                                                   \
    > : std::true_type {}

#define LM_COMPONENT_CHECK_HAS_MEMBER_FUNCTION(Type, FuncName)              \
    static_assert(                                                          \
        has_member_function_##FuncName<Type>::value,                        \
        "Component class of type '" #Type "' must have the member function '" #FuncName "'")

#define LM_COMPONENT_CHECK_IS_DERIVED_CLASS(ImplType, InterfaceType)        \
    static_assert(                                                          \
        std::is_base_of<InterfaceType, ImplType>::value,                    \
        "Component class of type '" #ImplType "' must be inherited from the class of type '" #InterfaceType "'")

// --------------------------------------------------------------------------------

LM_NAMESPACE_BEGIN

template <typename T, T>
struct check_func_signature : std::true_type {};

LM_COMPONENT_CREATE_HAS_MEMBER_FUNCTION(ImplTypeName, const char* (*)());
LM_COMPONENT_CREATE_HAS_MEMBER_FUNCTION(InterfaceTypeName, const char* (*)());

LM_NAMESPACE_END

// --------------------------------------------------------------------------------

#define LM_COMPONENT_REGISTER_IMPL(ImplType, InterfaceType)                                     \
    namespace {                                                                                 \
                                                                                                \
        template <typename T1, typename T2>                                                     \
        class ComponentFactoryEntryInstance;                                                    \
                                                                                                \
        template <>                                                                             \
        class ComponentFactoryEntryInstance<ImplType, InterfaceType>                            \
        {                                                                                       \
            static const ::lightmetrica::ComponentFactoryEntry<ImplType, InterfaceType>& reg;   \
        };                                                                                      \
                                                                                                \
        const ::lightmetrica::ComponentFactoryEntry<ImplType, InterfaceType>&                   \
            ComponentFactoryEntryInstance<ImplType, InterfaceType>::reg =                       \
                ::lightmetrica::ComponentFactoryEntry<ImplType, InterfaceType>::Instance();     \
                                                                                                \
        LM_COMPONENT_CHECK_IS_DERIVED_CLASS(ImplType, InterfaceType);                           \
        LM_COMPONENT_CHECK_IS_DERIVED_CLASS(InterfaceType, Component);                          \
        LM_COMPONENT_CHECK_HAS_MEMBER_FUNCTION(ImplType, ImplTypeName);                         \
        LM_COMPONENT_CHECK_HAS_MEMBER_FUNCTION(InterfaceType, InterfaceTypeName);               \
                                                                                                \
    }

#endif // LIB_LIGHTMETRICA_COMPONENT_H