function_ptr.h

Go to the documentation of this file.

#pragma once
#include <a_utils.h>
#include "interfaces/object_intf.h"
#include "object_ptr/object_ptr_pkg.h"
#include "object.h"
#include <functional>
 
#define ADTF_UCOM_PROVIDES_IFUNCTION 1
 
namespace adtf
{
namespace ucom
{
namespace nitro
{

template <typename Signature>
class ifunction;

template <typename ResultType, typename ...Arguments>
class ifunction<ResultType(Arguments...)>: public ant::IObject
{
    public:
        virtual ResultType operator()(Arguments... args) const = 0;
};

template <typename Signature>
using ifunction_ptr = ant::iobject_ptr<ifunction<Signature>>;

template <typename Signature>
class function_wrapper;

template <typename ResultType, typename ...Arguments>
class function_wrapper<ResultType(Arguments...)>: public catwo::object<ifunction<ResultType(Arguments...)>>
{
    public:
        function_wrapper(std::function<ResultType(Arguments...)> fnFunction):
            m_fnFunction(fnFunction)
        {
        }
 
        function_wrapper() = default;
        function_wrapper(const function_wrapper&) = default;
        function_wrapper(function_wrapper&&) = default;
        function_wrapper& operator=(const function_wrapper&) = default;
        function_wrapper& operator=(function_wrapper&&) = default;
        ~function_wrapper() = default;
 
        ResultType operator()(Arguments... args) const override
        {
            return m_fnFunction(std::forward<Arguments>(args)...);
        }
 
    private:
        std::function<ResultType(Arguments...)> m_fnFunction;
};

 
namespace detail
{
 
template <typename Function>
struct function_traits : public function_traits<decltype(&Function::operator())>
{
};
 
template <typename ClassType, typename ReturnType, typename... Arguments>
struct function_traits<ReturnType(ClassType::*)(Arguments...) const>
{
    using return_type = ReturnType;
 
    template <std::size_t Index>
    using argument = typename std::tuple_element<Index, std::tuple<Arguments...>>::type;
 
    static constexpr std::size_t argument_count = sizeof...(Arguments);
};
 
template <typename ClassType, typename ReturnType, typename... Arguments>
struct function_traits<ReturnType(ClassType::*)(Arguments...)>
{
    using return_type = ReturnType;
 
    template <std::size_t Index>
    using argument = typename std::tuple_element<Index, std::tuple<Arguments...>>::type;
 
    static constexpr std::size_t argument_count = sizeof...(Arguments);
};
 
template<typename FunctionTraits, typename Unused>
struct signature;
 
template<typename FunctionTraits, std::size_t... Indices>
struct signature<FunctionTraits, std::index_sequence<Indices...>>
{
    using type = typename FunctionTraits::return_type(typename FunctionTraits::template argument<Indices>...);
};
 
template<typename Callable, typename FunctionTraits = function_traits<std::remove_reference_t<Callable>>>
using signature_t = typename signature<FunctionTraits, std::make_index_sequence<FunctionTraits::argument_count>>::type;
 
template <typename Signature>
class function_ptr;
 
template <typename ResultType, typename ...Arguments>
class function_ptr<ResultType(Arguments...)>: public object_ptr<ifunction<ResultType(Arguments...)>>
{
public:
    using base_type = object_ptr<ifunction<ResultType(Arguments...)>>;
 
    using base_type::base_type;
 
    ResultType operator()(Arguments... args) const
    {
        return (*this->Get())(std::forward<Arguments>(args)...);
    }
};
 
}


template <typename Callable, typename Signature = detail::signature_t<Callable>>
inline function_wrapper<Signature> make_function(Callable&& fnCallback)
{
    return function_wrapper<Signature>(std::forward<Callable>(fnCallback));
}

template <typename Callable, typename Signature = detail::signature_t<Callable>>
inline ant::object_ptr<ifunction<Signature>> make_function_ptr(Callable&& fnCallback)
{
    return ant::make_object_ptr<function_wrapper<Signature>>(std::forward<Callable>(fnCallback));
}

template <typename Signature>
inline std::function<Signature> to_std_function(const ifunction<Signature>& fnFunction)
{
    return std::function<Signature>(std::ref(fnFunction));
}

template <typename Signature>
inline std::function<Signature> to_std_function(const ifunction_ptr<Signature>& pFunction)
{
    return std::function<Signature>(detail::function_ptr<Signature>(pFunction));
}
 
}
 
using nitro::ifunction;
using nitro::ifunction_ptr;
using nitro::function_wrapper;
using nitro::make_function;
using nitro::make_function_ptr;
using nitro::to_std_function;
 
}
}