1 /* 2 * Copyright (c) 2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef FOUNDATION_ACE_FRAMEWORKS_BRIDGE_COMMON_UTILS_FUNCTION_TRAITS_H 17 #define FOUNDATION_ACE_FRAMEWORKS_BRIDGE_COMMON_UTILS_FUNCTION_TRAITS_H 18 19 #include <tuple> 20 21 template<typename T> 22 struct function_traits; 23 24 template<typename Class, typename ReturnType, typename... Args> 25 struct function_traits<ReturnType (Class::*)(Args...)> { 26 static constexpr const size_t argc = sizeof...(Args); 27 typedef ReturnType returnType; 28 using ArgumentPack = std::tuple<Args...>; 29 template<size_t i> 30 struct argv { 31 typedef typename std::tuple_element<i, ArgumentPack>::type type; 32 }; 33 }; 34 35 namespace FunctionUtils { 36 37 template<typename C, typename F, typename T, size_t... I> 38 auto CallMemberFunction(C* instance, F func, T&& tuple, std::index_sequence<I...>) 39 { 40 return (instance->*func)(std::get<I>(std::forward<T>(tuple))...); 41 } 42 43 template<typename C, typename R, typename Tuple, typename... Types> 44 auto CallMemberFunction(C* instance, R (C::*func)(Types...), Tuple&& tup) 45 { 46 return CallMemberFunction(instance, func, std::forward<Tuple>(tup), std::make_index_sequence<sizeof...(Types)> {}); 47 } 48 49 template<typename F, typename T, size_t... I> 50 auto CallStaticMemberFunction(F func, T&& tuple, std::index_sequence<I...>) 51 { 52 return func(std::get<I>(std::forward<T>(tuple))...); 53 } 54 55 template<typename R, typename Tuple, typename... Types> 56 auto CallStaticMemberFunction(R (*func)(Types...), Tuple&& tup) 57 { 58 return CallStaticMemberFunction(func, std::forward<Tuple>(tup), std::make_index_sequence<sizeof...(Types)> {}); 59 } 60 61 template<class T, class Tuple, size_t... Is> 62 T* ConstructFromTuple(Tuple&& tuple, std::index_sequence<Is...>) 63 { 64 return new T { std::get<Is>(std::forward<Tuple>(tuple))... }; 65 } 66 67 template<class T, class Tuple> 68 T* ConstructFromTuple(Tuple&& tuple) 69 { 70 return ConstructFromTuple<T>( 71 std::forward<Tuple>(tuple), std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value> {}); 72 } 73 74 }; // namespace FunctionUtils 75 76 #endif // FOUNDATION_ACE_FRAMEWORKS_BRIDGE_COMMON_UTILS_FUNCTION_TRAITS_H