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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
// 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.
//
// -----------------------------------------------------------------------------
// File: function_ref.h
// -----------------------------------------------------------------------------
//
// This header file defines the `absl::FunctionRef` type for holding a
// non-owning reference to an object of any invocable type. This function
// reference is typically most useful as a type-erased argument type for
// accepting function types that neither take ownership nor copy the type; using
// the reference type in this case avoids a copy and an allocation. Best
// practices of other non-owning reference-like objects (such as
// `absl::string_view`) apply here.
//
// An `absl::FunctionRef` is similar in usage to a `std::function` but has the
// following differences:
//
// * It doesn't own the underlying object.
// * It doesn't have a null or empty state.
// * It never performs deep copies or allocations.
// * It's much faster and cheaper to construct.
// * It's trivially copyable and destructable.
//
// Generally, `absl::FunctionRef` should not be used as a return value, data
// member, or to initialize a `std::function`. Such usages will often lead to
// problematic lifetime issues. Once you convert something to an
// `absl::FunctionRef` you cannot make a deep copy later.
//
// This class is suitable for use wherever a "const std::function<>&"
// would be used without making a copy. ForEach functions and other versions of
// the visitor pattern are a good example of when this class should be used.
//
// This class is trivial to copy and should be passed by value.
#ifndef ABSL_FUNCTIONAL_FUNCTION_REF_H_
#define ABSL_FUNCTIONAL_FUNCTION_REF_H_
#include <cassert>
#include <functional>
#include <type_traits>
#include "absl/functional/internal/function_ref.h"
#include "absl/meta/type_traits.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
// FunctionRef
//
// Dummy class declaration to allow the partial specialization based on function
// types below.
template <typename T>
class FunctionRef;
// FunctionRef
//
// An `absl::FunctionRef` is a lightweight wrapper to any invokable object with
// a compatible signature. Generally, an `absl::FunctionRef` should only be used
// as an argument type and should be preferred as an argument over a const
// reference to a `std::function`.
//
// Example:
//
// // The following function takes a function callback by const reference
// bool Visitor(const std::function<void(my_proto&,
// absl::string_view)>& callback);
//
// // Assuming that the function is not stored or otherwise copied, it can be
// // replaced by an `absl::FunctionRef`:
// bool Visitor(absl::FunctionRef<void(my_proto&, absl::string_view)>
// callback);
//
// Note: the assignment operator within an `absl::FunctionRef` is intentionally
// deleted to prevent misuse; because the `absl::FunctionRef` does not own the
// underlying type, assignment likely indicates misuse.
template <typename R, typename... Args>
class FunctionRef<R(Args...)> {
private:
// Used to disable constructors for objects that are not compatible with the
// signature of this FunctionRef.
template <typename F,
typename FR = absl::base_internal::invoke_result_t<F, Args&&...>>
using EnableIfCompatible =
typename std::enable_if<std::is_void<R>::value ||
std::is_convertible<FR, R>::value>::type;
public:
// Constructs a FunctionRef from any invokable type.
template <typename F, typename = EnableIfCompatible<const F&>>
FunctionRef(const F& f) // NOLINT(runtime/explicit)
: invoker_(&absl::functional_internal::InvokeObject<F, R, Args...>) {
absl::functional_internal::AssertNonNull(f);
ptr_.obj = &f;
}
// Overload for function pointers. This eliminates a level of indirection that
// would happen if the above overload was used (it lets us store the pointer
// instead of a pointer to a pointer).
//
// This overload is also used for references to functions, since references to
// functions can decay to function pointers implicitly.
template <
typename F, typename = EnableIfCompatible<F*>,
absl::functional_internal::EnableIf<absl::is_function<F>::value> = 0>
FunctionRef(F* f) // NOLINT(runtime/explicit)
: invoker_(&absl::functional_internal::InvokeFunction<F*, R, Args...>) {
assert(f != nullptr);
ptr_.fun = reinterpret_cast<decltype(ptr_.fun)>(f);
}
// To help prevent subtle lifetime bugs, FunctionRef is not assignable.
// Typically, it should only be used as an argument type.
FunctionRef& operator=(const FunctionRef& rhs) = delete;
// Call the underlying object.
R operator()(Args... args) const {
return invoker_(ptr_, std::forward<Args>(args)...);
}
private:
absl::functional_internal::VoidPtr ptr_;
absl::functional_internal::Invoker<R, Args...> invoker_;
};
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_FUNCTIONAL_FUNCTION_REF_H_
|
