/src/abseil-cpp/absl/functional/internal/function_ref.h

Source
// Copyright 2019 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
#define ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_

#include <cassert>
#include <functional>
#include <type_traits>

#include "absl/base/config.h"
#include "absl/functional/any_invocable.h"
#include "absl/meta/type_traits.h"

namespace absl {
ABSL_NAMESPACE_BEGIN
namespace functional_internal {

// Like a void* that can handle function pointers as well. The standard does not
// allow function pointers to round-trip through void*, but void(*)() is fine.
//
// Note: It's important that this class remains trivial and is the same size as
// a pointer, since this allows the compiler to perform tail-call optimizations
// when the underlying function is a callable object with a matching signature.
union VoidPtr {
  const void* obj;
  void (*fun)();
};

// Chooses the best type for passing T as an argument.
// Attempt to be close to SystemV AMD64 ABI. Objects with trivial copy ctor are
// passed by value.
template <typename T, bool IsLValueReference = std::is_lvalue_reference_v<T>>
struct PassByValue : std::false_type {};

template <typename T>
struct PassByValue<T, /*IsLValueReference=*/false>
    : std::bool_constant<
          std::is_trivially_copy_constructible_v<T> &&
          std::is_trivially_copy_assignable_v<std::remove_cv_t<T>> &&
          std::is_trivially_destructible_v<T> &&
          sizeof(T) <= 2 * sizeof(void*)> {};

template <typename T>
struct ForwardT : std::conditional<PassByValue<T>::value, T, T&&> {};

// An Invoker takes a pointer to the type-erased invokable object, followed by
// the arguments that the invokable object expects.
//
// Note: The order of arguments here is an optimization, since member functions
// have an implicit "this" pointer as their first argument, putting VoidPtr
// first allows the compiler to perform tail-call optimization in many cases.
template <typename R, typename... Args>
using Invoker = R (*)(VoidPtr, typename ForwardT<Args>::type...);

//
// InvokeObject and InvokeFunction provide static "Invoke" functions that can be
// used as Invokers for objects or functions respectively.
//
// static_cast<R> handles the case the return type is void.
template <typename Obj, typename R, typename... Args>
R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
  using T = std::remove_reference_t<Obj>;
  return static_cast<R>(std::invoke(
      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
      std::forward<typename ForwardT<Args>::type>(args)...));
}

template <typename Obj, typename Fun, Fun F, typename R, typename... Args>
R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
  using T = std::remove_reference_t<Obj>;
  Obj&& obj =
      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj)));
  // Avoid std::invoke() since the callee is a known function at compile time
  if constexpr (std::is_member_function_pointer_v<Fun>) {
    return static_cast<R>((std::forward<Obj>(obj).*F)(
        std::forward<typename ForwardT<Args>::type>(args)...));
  } else {
    return static_cast<R>(
        F(std::forward<Obj>(obj),
          std::forward<typename ForwardT<Args>::type>(args)...));
  }
}

template <typename T, typename Fun, Fun F, typename R, typename... Args>
R InvokePtr(VoidPtr ptr, typename ForwardT<Args>::type... args) {
  T* obj = const_cast<T*>(static_cast<const T*>(ptr.obj));
  // Avoid std::invoke() since the callee is a known function at compile time
  if constexpr (std::is_member_function_pointer_v<Fun>) {
    return static_cast<R>(
        (obj->*F)(std::forward<typename ForwardT<Args>::type>(args)...));
  } else {
    return static_cast<R>(
        F(obj, std::forward<typename ForwardT<Args>::type>(args)...));
  }
}

template <typename Fun, typename R, typename... Args>
R InvokeFunction(VoidPtr ptr, typename ForwardT<Args>::type... args) {
  auto f = reinterpret_cast<Fun>(ptr.fun);
  return static_cast<R>(
      std::invoke(f, std::forward<typename ForwardT<Args>::type>(args)...));
}

template <typename Fun, Fun F, typename R, typename... Args>
R InvokeFunction(VoidPtr, typename ForwardT<Args>::type... args) {
  return static_cast<R>(
      F(std::forward<typename ForwardT<Args>::type>(args)...));
}

template <typename Sig>
void AssertNonNull(const std::function<Sig>& f) {
  assert(f != nullptr);
  (void)f;
}

template <typename Sig>
void AssertNonNull(const AnyInvocable<Sig>& f) {
  assert(f != nullptr);
  (void)f;
}

template <typename F>
void AssertNonNull(const F&) {}

template <typename F, typename C>
void AssertNonNull(F C::* f) {
  assert(f != nullptr);
  (void)f;
}

template <bool C>
using EnableIf = typename ::std::enable_if_t<C, int>;

}  // namespace functional_internal
ABSL_NAMESPACE_END
}  // namespace absl

#endif  // ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_

Line	Count	Source
1		// Copyright 2019 The Abseil Authors.
2		//
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		// https://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		#ifndef ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
16		#define ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
17
18		#include <cassert>
19		#include <functional>
20		#include <type_traits>
21
22		#include "absl/base/config.h"
23		#include "absl/functional/any_invocable.h"
24		#include "absl/meta/type_traits.h"
25
26		namespace absl {
27		ABSL_NAMESPACE_BEGIN
28		namespace functional_internal {
29
30		// Like a void* that can handle function pointers as well. The standard does not
31		// allow function pointers to round-trip through void, but void()() is fine.
32		//
33		// Note: It's important that this class remains trivial and is the same size as
34		// a pointer, since this allows the compiler to perform tail-call optimizations
35		// when the underlying function is a callable object with a matching signature.
36		union VoidPtr {
37		const void* obj;
38		void (*fun)();
39		};
40
41		// Chooses the best type for passing T as an argument.
42		// Attempt to be close to SystemV AMD64 ABI. Objects with trivial copy ctor are
43		// passed by value.
44		template <typename T, bool IsLValueReference = std::is_lvalue_reference_v<T>>
45		struct PassByValue : std::false_type {};
46
47		template <typename T>
48		struct PassByValue<T, /IsLValueReference=/false>
49		: std::bool_constant<
50		std::is_trivially_copy_constructible_v<T> &&
51		std::is_trivially_copy_assignable_v<std::remove_cv_t<T>> &&
52		std::is_trivially_destructible_v<T> &&
53		sizeof(T) <= 2 * sizeof(void*)> {};
54
55		template <typename T>
56		struct ForwardT : std::conditional<PassByValue<T>::value, T, T&&> {};
57
58		// An Invoker takes a pointer to the type-erased invokable object, followed by
59		// the arguments that the invokable object expects.
60		//
61		// Note: The order of arguments here is an optimization, since member functions
62		// have an implicit "this" pointer as their first argument, putting VoidPtr
63		// first allows the compiler to perform tail-call optimization in many cases.
64		template <typename R, typename... Args>
65		using Invoker = R (*)(VoidPtr, typename ForwardT<Args>::type...);
66
67		//
68		// InvokeObject and InvokeFunction provide static "Invoke" functions that can be
69		// used as Invokers for objects or functions respectively.
70		//
71		// static_cast<R> handles the case the return type is void.
72		template <typename Obj, typename R, typename... Args>
73	0	R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
74	0	using T = std::remove_reference_t<Obj>;
75	0	return static_cast<R>(std::invoke(
76	0	std::forward<Obj>(const_cast<T>(static_cast<const T*>(ptr.obj))),
77	0	std::forward<typename ForwardT<Args>::type>(args)...));
78	0	} Unexecuted instantiation: void absl::functional_internal::InvokeObject<absl::Cord::HashFragmented<absl::hash_internal::MixingHashState>(absl::hash_internal::MixingHashState) const::{lambda(std::__1::basic_string_view<char, std::__1::char_traits<char> >)#1}&, void, std::__1::basic_string_view<char, std::__1::char_traits<char> > >(absl::functional_internal::VoidPtr, absl::functional_internal::ForwardT<std::__1::basic_string_view<char, std::__1::char_traits<char> > >::type) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::InvokeObject<absl::str_format_internal::(anonymous namespace)::BinaryToDecimal::RunConversion(absl::uint128, int, absl::FunctionRef<void (absl::str_format_internal::(anonymous namespace)::BinaryToDecimal)>)::{lambda(absl::Span<unsigned int>)#1}&, void, absl::Span<unsigned int> >(absl::functional_internal::VoidPtr, absl::functional_internal::ForwardT<absl::Span<unsigned int> >::type) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::InvokeObject<absl::str_format_internal::(anonymous namespace)::FormatFPositiveExpSlow(absl::uint128, int, absl::str_format_internal::(anonymous namespace)::FormatState const&, bool)::$_0&, void, absl::str_format_internal::(anonymous namespace)::BinaryToDecimal>(absl::functional_internal::VoidPtr, absl::functional_internal::ForwardT<absl::str_format_internal::(anonymous namespace)::BinaryToDecimal>::type) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::InvokeObject<absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator::RunConversion(absl::uint128, int, absl::FunctionRef<void (absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator)>)::{lambda(absl::Span<unsigned int>)#1}&, void, absl::Span<unsigned int> >(absl::functional_internal::VoidPtr, absl::functional_internal::ForwardT<absl::Span<unsigned int> >::type) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::InvokeObject<absl::str_format_internal::(anonymous namespace)::FormatFNegativeExpSlow(absl::uint128, int, absl::str_format_internal::(anonymous namespace)::FormatState const&, unsigned long)::$_0&, void, absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator>(absl::functional_internal::VoidPtr, absl::functional_internal::ForwardT<absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator>::type) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::InvokeObject<absl::str_format_internal::(anonymous namespace)::FormatEPositiveExpSlow(absl::uint128, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&, unsigned long)::$_0&, void, absl::str_format_internal::(anonymous namespace)::BinaryToDecimal>(absl::functional_internal::VoidPtr, absl::functional_internal::ForwardT<absl::str_format_internal::(anonymous namespace)::BinaryToDecimal>::type) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::InvokeObject<absl::str_format_internal::(anonymous namespace)::FormatENegativeExpSlow(absl::uint128, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&, unsigned long)::$_0&, void, absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator>(absl::functional_internal::VoidPtr, absl::functional_internal::ForwardT<absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator>::type) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::InvokeObject<absl::str_format_internal::(anonymous namespace)::FormatGPositiveExpSlow<absl::uint128>(absl::uint128, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&)::{lambda(absl::str_format_internal::(anonymous namespace)::BinaryToDecimal)#1}&, void, absl::str_format_internal::(anonymous namespace)::BinaryToDecimal>(absl::functional_internal::VoidPtr, absl::functional_internal::ForwardT<absl::str_format_internal::(anonymous namespace)::BinaryToDecimal>::type) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::InvokeObject<absl::str_format_internal::(anonymous namespace)::FormatGNegativeExpSlow<absl::uint128>(absl::uint128, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&)::{lambda(absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator)#1}&, void, absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator>(absl::functional_internal::VoidPtr, absl::functional_internal::ForwardT<absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator>::type) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::InvokeObject<absl::str_format_internal::(anonymous namespace)::FormatGPositiveExpSlow<unsigned long>(unsigned long, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&)::{lambda(absl::str_format_internal::(anonymous namespace)::BinaryToDecimal)#1}&, void, absl::str_format_internal::(anonymous namespace)::BinaryToDecimal>(absl::functional_internal::VoidPtr, absl::functional_internal::ForwardT<absl::str_format_internal::(anonymous namespace)::BinaryToDecimal>::type) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::InvokeObject<absl::str_format_internal::(anonymous namespace)::FormatGNegativeExpSlow<unsigned long>(unsigned long, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&)::{lambda(absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator)#1}&, void, absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator>(absl::functional_internal::VoidPtr, absl::functional_internal::ForwardT<absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator>::type)
79
80		template <typename Obj, typename Fun, Fun F, typename R, typename... Args>
81		R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
82		using T = std::remove_reference_t<Obj>;
83		Obj&& obj =
84		std::forward<Obj>(const_cast<T>(static_cast<const T*>(ptr.obj)));
85		// Avoid std::invoke() since the callee is a known function at compile time
86		if constexpr (std::is_member_function_pointer_v<Fun>) {
87		return static_cast<R>((std::forward<Obj>(obj).*F)(
88		std::forward<typename ForwardT<Args>::type>(args)...));
89		} else {
90		return static_cast<R>(
91		F(std::forward<Obj>(obj),
92		std::forward<typename ForwardT<Args>::type>(args)...));
93		}
94		}
95
96		template <typename T, typename Fun, Fun F, typename R, typename... Args>
97		R InvokePtr(VoidPtr ptr, typename ForwardT<Args>::type... args) {
98		T* obj = const_cast<T>(static_cast<const T>(ptr.obj));
99		// Avoid std::invoke() since the callee is a known function at compile time
100		if constexpr (std::is_member_function_pointer_v<Fun>) {
101		return static_cast<R>(
102		(obj->*F)(std::forward<typename ForwardT<Args>::type>(args)...));
103		} else {
104		return static_cast<R>(
105		F(obj, std::forward<typename ForwardT<Args>::type>(args)...));
106		}
107		}
108
109		template <typename Fun, typename R, typename... Args>
110		R InvokeFunction(VoidPtr ptr, typename ForwardT<Args>::type... args) {
111		auto f = reinterpret_cast<Fun>(ptr.fun);
112		return static_cast<R>(
113		std::invoke(f, std::forward<typename ForwardT<Args>::type>(args)...));
114		}
115
116		template <typename Fun, Fun F, typename R, typename... Args>
117		R InvokeFunction(VoidPtr, typename ForwardT<Args>::type... args) {
118		return static_cast<R>(
119		F(std::forward<typename ForwardT<Args>::type>(args)...));
120		}
121
122		template <typename Sig>
123		void AssertNonNull(const std::function<Sig>& f) {
124		assert(f != nullptr);
125		(void)f;
126		}
127
128		template <typename Sig>
129		void AssertNonNull(const AnyInvocable<Sig>& f) {
130		assert(f != nullptr);
131		(void)f;
132		}
133
134		template <typename F>
135	0	void AssertNonNull(const F&) {} Unexecuted instantiation: void absl::functional_internal::AssertNonNull<absl::Cord::HashFragmented<absl::hash_internal::MixingHashState>(absl::hash_internal::MixingHashState) const::{lambda(std::__1::basic_string_view<char, std::__1::char_traits<char> >)#1}>(absl::Cord::HashFragmented<absl::hash_internal::MixingHashState>(absl::hash_internal::MixingHashState) const::{lambda(std::__1::basic_string_view<char, std::__1::char_traits<char> >)#1} const&) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::AssertNonNull<absl::str_format_internal::(anonymous namespace)::BinaryToDecimal::RunConversion(absl::uint128, int, absl::FunctionRef<void (absl::str_format_internal::(anonymous namespace)::BinaryToDecimal)>)::{lambda(absl::Span<unsigned int>)#1}>(absl::str_format_internal::(anonymous namespace)::BinaryToDecimal::RunConversion(absl::uint128, int, absl::FunctionRef<void (absl::str_format_internal::(anonymous namespace)::BinaryToDecimal)>)::{lambda(absl::Span<unsigned int>)#1} const&) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::AssertNonNull<absl::str_format_internal::(anonymous namespace)::FormatFPositiveExpSlow(absl::uint128, int, absl::str_format_internal::(anonymous namespace)::FormatState const&, bool)::$_0>(absl::str_format_internal::(anonymous namespace)::FormatFPositiveExpSlow(absl::uint128, int, absl::str_format_internal::(anonymous namespace)::FormatState const&, bool)::$_0 const&) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::AssertNonNull<absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator::RunConversion(absl::uint128, int, absl::FunctionRef<void (absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator)>)::{lambda(absl::Span<unsigned int>)#1}>(absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator::RunConversion(absl::uint128, int, absl::FunctionRef<void (absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator)>)::{lambda(absl::Span<unsigned int>)#1} const&) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::AssertNonNull<absl::str_format_internal::(anonymous namespace)::FormatFNegativeExpSlow(absl::uint128, int, absl::str_format_internal::(anonymous namespace)::FormatState const&, unsigned long)::$_0>(absl::str_format_internal::(anonymous namespace)::FormatFNegativeExpSlow(absl::uint128, int, absl::str_format_internal::(anonymous namespace)::FormatState const&, unsigned long)::$_0 const&) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::AssertNonNull<absl::str_format_internal::(anonymous namespace)::FormatEPositiveExpSlow(absl::uint128, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&, unsigned long)::$_0>(absl::str_format_internal::(anonymous namespace)::FormatEPositiveExpSlow(absl::uint128, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&, unsigned long)::$_0 const&) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::AssertNonNull<absl::str_format_internal::(anonymous namespace)::FormatENegativeExpSlow(absl::uint128, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&, unsigned long)::$_0>(absl::str_format_internal::(anonymous namespace)::FormatENegativeExpSlow(absl::uint128, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&, unsigned long)::$_0 const&) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::AssertNonNull<absl::str_format_internal::(anonymous namespace)::FormatGPositiveExpSlow<absl::uint128>(absl::uint128, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&)::{lambda(absl::str_format_internal::(anonymous namespace)::BinaryToDecimal)#1}>(absl::str_format_internal::(anonymous namespace)::FormatGPositiveExpSlow<absl::uint128>(absl::uint128, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&)::{lambda(absl::str_format_internal::(anonymous namespace)::BinaryToDecimal)#1} const&) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::AssertNonNull<absl::str_format_internal::(anonymous namespace)::FormatGNegativeExpSlow<absl::uint128>(absl::uint128, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&)::{lambda(absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator)#1}>(absl::str_format_internal::(anonymous namespace)::FormatGNegativeExpSlow<absl::uint128>(absl::uint128, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&)::{lambda(absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator)#1} const&) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::AssertNonNull<absl::str_format_internal::(anonymous namespace)::FormatGPositiveExpSlow<unsigned long>(unsigned long, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&)::{lambda(absl::str_format_internal::(anonymous namespace)::BinaryToDecimal)#1}>(absl::str_format_internal::(anonymous namespace)::FormatGPositiveExpSlow<unsigned long>(unsigned long, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&)::{lambda(absl::str_format_internal::(anonymous namespace)::BinaryToDecimal)#1} const&) Unexecuted instantiation: float_conversion.cc:void absl::functional_internal::AssertNonNull<absl::str_format_internal::(anonymous namespace)::FormatGNegativeExpSlow<unsigned long>(unsigned long, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&)::{lambda(absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator)#1}>(absl::str_format_internal::(anonymous namespace)::FormatGNegativeExpSlow<unsigned long>(unsigned long, int, bool, absl::str_format_internal::(anonymous namespace)::FormatState const&)::{lambda(absl::str_format_internal::(anonymous namespace)::FractionalDigitGenerator)#1} const&)
136
137		template <typename F, typename C>
138		void AssertNonNull(F C::* f) {
139		assert(f != nullptr);
140		(void)f;
141		}
142
143		template <bool C>
144		using EnableIf = typename ::std::enable_if_t<C, int>;
145
146		} // namespace functional_internal
147		ABSL_NAMESPACE_END
148		} // namespace absl
149
150		#endif // ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_

Coverage Report

Created: 2026-09-14 06:45