pythonmodule.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
#ifdef NAP_ENABLE_PYTHON
 
#include <functional>
#include <vector>
#include <utility/dllexport.h>
 
#include <pybind11/pybind11.h>
#include <pybind11/embed.h>
#include <pybind11/stl.h>
 
// Note: including rttr headers directly here instead of going through typeinfo.h to avoid circular dependencies between the two headers
#include <rttr/detail/misc/misc_type_traits.h>
#include <rttr/type>
 
namespace nap
{
    namespace rtti
    {
        namespace detail
        {
            template<typename T>
            inline void GetTypeNamesImpl(std::vector<std::string>& result)
            {
                result.push_back(rttr::type::get<T>().get_name().data());
            }
 
            template<typename... Targs>
            inline void GetTypeNames(std::vector<std::string>& result);
 
            template<typename T, typename... V>
            inline void GetTypeNamesHelper(std::vector<std::string>& result)
            {
                GetTypeNamesImpl<T>(result);
                GetTypeNames<V...>(result);
            }
 
            template<typename... Targs>
            inline void GetTypeNames(std::vector<std::string>& result)
            {
                GetTypeNamesHelper<Targs...>(result);
            }
 
            template<>
            inline void GetTypeNames<>(std::vector<std::string>& result)
            {
            }
        }
 
        template<class T, class BaseClasses>
        class PythonClass;
 
        template<class T, typename... BaseClasses>
        class PythonClass<T, rttr::detail::type_list<BaseClasses...>>
        {
        public:
            using PybindClass = pybind11::class_<T, BaseClasses...>;
            using RegistrationFunction = std::function<void(pybind11::module&, PybindClass&)>;
 
            PythonClass(const std::string& name)
            {
                // Strip namespace out of type name
                int namespace_separator_pos = name.find_last_of(':');
                if (namespace_separator_pos != std::string::npos)
                    mName = name.substr(namespace_separator_pos+1);
                else
                    mName = name;
            }
 
            void registerFunction(const RegistrationFunction& function)
            {
                mRegistrationFunctions.push_back(function);
            }
 
            void invoke(pybind11::module& module) const
            {
                auto cls = PybindClass(module, mName.c_str());
                for (auto& func : mRegistrationFunctions)
                    func(module, cls);
            }
 
            static void GetBaseTypes(std::vector<std::string>& baseClasses)
            {
                detail::GetTypeNames<BaseClasses...>(baseClasses);
            }
 
        private:
            std::string mName;                                              
            std::vector<std::string> mBaseTypes;                            
            std::vector<RegistrationFunction> mRegistrationFunctions;       
        };
 
        class NAPAPI PythonModule
        {
        public:
            using RegistrationFunction = std::function<void(pybind11::module&)>;
            using GetBaseTypesFunction = std::function<void(std::vector<std::string>&)>;
 
            static PythonModule& get(const char* moduleName);
 
            void registerImportCallback(RegistrationFunction function);
 
            void registerTypeImportCallback(const std::string& name, GetBaseTypesFunction getBaseTypesFunction, RegistrationFunction registrationFunction);
            
            void invoke(pybind11::module& module);
 
        private:
            struct RegistrationItem
            {
                GetBaseTypesFunction        mGetBaseTypesFunction;
                RegistrationFunction        mRegistrationFunction;
            };
            using RegistrationMap = std::unordered_map<std::string, RegistrationItem>;
 
            void registerTypeRecursive(pybind11::module& module, RegistrationMap::iterator itemToRegister);
            
            RegistrationMap mRegistrationMap;                       
            std::vector<RegistrationFunction> mImportCallbacks;     
        };
    }
}
 
#endif