functional/internal/function_ref.h

0001 // Copyright 2019 The Abseil Authors.
0002 //
0003 // Licensed under the Apache License, Version 2.0 (the "License");
0004 // you may not use this file except in compliance with the License.
0005 // You may obtain a copy of the License at
0006 //
0007 //      https://www.apache.org/licenses/LICENSE-2.0
0008 //
0009 // Unless required by applicable law or agreed to in writing, software
0010 // distributed under the License is distributed on an "AS IS" BASIS,
0011 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0012 // See the License for the specific language governing permissions and
0013 // limitations under the License.
0014
0015 #ifndef ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
0016 #define ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
0017
0018 #include <cassert>
0019 #include <functional>
0020 #include <type_traits>
0021
0022 #include "absl/base/internal/invoke.h"
0023 #include "absl/functional/any_invocable.h"
0024 #include "absl/meta/type_traits.h"
0025
0026 namespace absl {
0027 ABSL_NAMESPACE_BEGIN
0028 namespace functional_internal {
0029
0030 // Like a void* that can handle function pointers as well. The standard does not
0031 // allow function pointers to round-trip through void*, but void(*)() is fine.
0032 //
0033 // Note: It's important that this class remains trivial and is the same size as
0034 // a pointer, since this allows the compiler to perform tail-call optimizations
0035 // when the underlying function is a callable object with a matching signature.
0036 union VoidPtr {
0037   const void* obj;
0038   void (*fun)();
0039 };
0040
0041 // Chooses the best type for passing T as an argument.
0042 // Attempt to be close to SystemV AMD64 ABI. Objects with trivial copy ctor are
0043 // passed by value.
0044 template <typename T,
0045           bool IsLValueReference = std::is_lvalue_reference<T>::value>
0046 struct PassByValue : std::false_type {};
0047
0048 template <typename T>
0049 struct PassByValue<T, /*IsLValueReference=*/false>
0050     : std::integral_constant<bool,
0051                              absl::is_trivially_copy_constructible<T>::value &&
0052                                  absl::is_trivially_copy_assignable<
0053                                      typename std::remove_cv<T>::type>::value &&
0054                                  std::is_trivially_destructible<T>::value &&
0055                                  sizeof(T) <= 2 * sizeof(void*)> {};
0056
0057 template <typename T>
0058 struct ForwardT : std::conditional<PassByValue<T>::value, T, T&&> {};
0059
0060 // An Invoker takes a pointer to the type-erased invokable object, followed by
0061 // the arguments that the invokable object expects.
0062 //
0063 // Note: The order of arguments here is an optimization, since member functions
0064 // have an implicit "this" pointer as their first argument, putting VoidPtr
0065 // first allows the compiler to perform tail-call optimization in many cases.
0066 template <typename R, typename... Args>
0067 using Invoker = R (*)(VoidPtr, typename ForwardT<Args>::type...);
0068
0069 //
0070 // InvokeObject and InvokeFunction provide static "Invoke" functions that can be
0071 // used as Invokers for objects or functions respectively.
0072 //
0073 // static_cast<R> handles the case the return type is void.
0074 template <typename Obj, typename R, typename... Args>
0075 R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
0076   auto o = static_cast<const Obj*>(ptr.obj);
0077   return static_cast<R>(
0078       absl::base_internal::invoke(*o, std::forward<Args>(args)...));
0079 }
0080
0081 template <typename Fun, typename R, typename... Args>
0082 R InvokeFunction(VoidPtr ptr, typename ForwardT<Args>::type... args) {
0083   auto f = reinterpret_cast<Fun>(ptr.fun);
0084   return static_cast<R>(
0085       absl::base_internal::invoke(f, std::forward<Args>(args)...));
0086 }
0087
0088 template <typename Sig>
0089 void AssertNonNull(const std::function<Sig>& f) {
0090   assert(f != nullptr);
0091   (void)f;
0092 }
0093
0094 template <typename Sig>
0095 void AssertNonNull(const AnyInvocable<Sig>& f) {
0096   assert(f != nullptr);
0097   (void)f;
0098 }
0099
0100 template <typename F>
0101 void AssertNonNull(const F&) {}
0102
0103 template <typename F, typename C>
0104 void AssertNonNull(F C::*f) {
0105   assert(f != nullptr);
0106   (void)f;
0107 }
0108
0109 template <bool C>
0110 using EnableIf = typename ::std::enable_if<C, int>::type;
0111
0112 }  // namespace functional_internal
0113 ABSL_NAMESPACE_END
0114 }  // namespace absl
0115
0116 #endif  // ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_