libstdc++: invoke.h Source File (original) (raw)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30#ifndef _GLIBCXX_INVOKE_H

31#define _GLIBCXX_INVOKE_H 1

32

33#pragma GCC system_header

34

35#if __cplusplus < 201103L

37#else

38

41

42namespace std _GLIBCXX_VISIBILITY(default)

43{

44_GLIBCXX_BEGIN_NAMESPACE_VERSION

45

46

47

48

49

50

51

52

53 template<typename _Tp, typename _Up = typename __inv_unwrap<_Tp>::type>

54 constexpr _Up&&

55 __invfwd(typename remove_reference<_Tp>::type& __t) noexcept

56 { return static_cast<_Up&&>(__t); }

57

58 template<typename _Res, typename _Fn, typename... _Args>

59 constexpr _Res

60 __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)

61 { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }

62

63 template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>

64 constexpr _Res

65 __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t,

66 _Args&&... __args)

67 { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); }

68

69 template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>

70 constexpr _Res

71 __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t,

72 _Args&&... __args)

73 {

74 return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...);

75 }

76

77 template<typename _Res, typename _MemPtr, typename _Tp>

78 constexpr _Res

79 __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t)

80 { return __invfwd<_Tp>(__t).*__f; }

81

82 template<typename _Res, typename _MemPtr, typename _Tp>

83 constexpr _Res

84 __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t)

85 { return (*std::forward<_Tp>(__t)).*__f; }

86

87

88 template<typename _Callable, typename... _Args>

89 constexpr typename __invoke_result<_Callable, _Args...>::type

90 __invoke(_Callable&& __fn, _Args&&... __args)

91 noexcept(__is_nothrow_invocable<_Callable, _Args...>::value)

92 {

93 using __result = __invoke_result<_Callable, _Args...>;

94 using __type = typename __result::type;

95 using __tag = typename __result::__invoke_type;

96 return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),

97 std::forward<_Args>(__args)...);

98 }

99

100#if __cplusplus >= 201703L

101

102 template<typename _Res, typename _Callable, typename... _Args>

103 constexpr enable_if_t<is_invocable_r_v<_Res, _Callable, _Args...>, _Res>

104 __invoke_r(_Callable&& __fn, _Args&&... __args)

105 noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>)

106 {

107 using __result = __invoke_result<_Callable, _Args...>;

108 using __type = typename __result::type;

109 using __tag = typename __result::__invoke_type;

110 if constexpr (is_void_v<_Res>)

111 std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),

112 std::forward<_Args>(__args)...);

113 else

114 return std::__invoke_impl<__type>(__tag{},

115 std::forward<_Callable>(__fn),

116 std::forward<_Args>(__args)...);

117 }

118#else

119

120

121

122

123

124

125

126

127 template<typename _Res, typename _Callable, typename... _Args>

128 constexpr __enable_if_t<!is_void<_Res>::value, _Res>

129 __invoke_r(_Callable&& __fn, _Args&&... __args)

130 {

131 using __result = __invoke_result<_Callable, _Args...>;

132 using __type = typename __result::type;

133#if __has_builtin(__reference_converts_from_temporary)

134 static_assert(!__reference_converts_from_temporary(_Res, __type),

135 "INVOKE must not create a dangling reference");

136#endif

137 using __tag = typename __result::__invoke_type;

138 return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),

139 std::forward<_Args>(__args)...);

140 }

141

142

143 template<typename _Res, typename _Callable, typename... _Args>

144 _GLIBCXX14_CONSTEXPR __enable_if_t<is_void<_Res>::value, _Res>

145 __invoke_r(_Callable&& __fn, _Args&&... __args)

146 {

147 using __result = __invoke_result<_Callable, _Args...>;

148 using __type = typename __result::type;

149 using __tag = typename __result::__invoke_type;

150 std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),

151 std::forward<_Args>(__args)...);

152 }

153#endif

154

155_GLIBCXX_END_NAMESPACE_VERSION

156}

157

158#endif

159

160#endif

typename enable_if< _Cond, _Tp >::type enable_if_t

Alias template for enable_if.

constexpr __invoke_result< _Callable, _Args... >::type __invoke(_Callable &&__fn, _Args &&... __args) noexcept(__is_nothrow_invocable< _Callable, _Args... >::value)

Invoke a callable object.

ISO C++ entities toplevel namespace is std.