blob: ef51d85fed9e7e5a5460a78595f245e3feeaef64 [file] [log] [blame]
Vitaly Bukacbed2062015-08-17 12:54:05 -07001// Copyright (c) 2011 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5// A Tuple is a generic templatized container, similar in concept to std::pair
6// and std::tuple. The convenient MakeTuple() function takes any number of
7// arguments and will construct and return the appropriate Tuple object. The
8// functions DispatchToMethod and DispatchToFunction take a function pointer or
9// instance and method pointer, and unpack a tuple into arguments to the call.
10//
11// Tuple elements are copied by value, and stored in the tuple. See the unit
12// tests for more details of how/when the values are copied.
13//
14// Example usage:
15// // These two methods of creating a Tuple are identical.
16// Tuple<int, const char*> tuple_a(1, "wee");
17// Tuple<int, const char*> tuple_b = MakeTuple(1, "wee");
18//
19// void SomeFunc(int a, const char* b) { }
20// DispatchToFunction(&SomeFunc, tuple_a); // SomeFunc(1, "wee")
21// DispatchToFunction(
22// &SomeFunc, MakeTuple(10, "foo")); // SomeFunc(10, "foo")
23//
24// struct { void SomeMeth(int a, int b, int c) { } } foo;
25// DispatchToMethod(&foo, &Foo::SomeMeth, MakeTuple(1, 2, 3));
26// // foo->SomeMeth(1, 2, 3);
27
28#ifndef BASE_TUPLE_H_
29#define BASE_TUPLE_H_
30
31#include "base/bind_helpers.h"
32
33namespace base {
34
35// Index sequences
36//
37// Minimal clone of the similarly-named C++14 functionality.
38
39template <size_t...>
40struct IndexSequence {};
41
42template <size_t... Ns>
43struct MakeIndexSequenceImpl;
44
45#if defined(_PREFAST_) && defined(OS_WIN)
46
47// Work around VC++ 2013 /analyze internal compiler error:
48// https://connect.microsoft.com/VisualStudio/feedback/details/1053626
49
50template <> struct MakeIndexSequenceImpl<0> {
51 using Type = IndexSequence<>;
52};
53template <> struct MakeIndexSequenceImpl<1> {
54 using Type = IndexSequence<0>;
55};
56template <> struct MakeIndexSequenceImpl<2> {
57 using Type = IndexSequence<0,1>;
58};
59template <> struct MakeIndexSequenceImpl<3> {
60 using Type = IndexSequence<0,1,2>;
61};
62template <> struct MakeIndexSequenceImpl<4> {
63 using Type = IndexSequence<0,1,2,3>;
64};
65template <> struct MakeIndexSequenceImpl<5> {
66 using Type = IndexSequence<0,1,2,3,4>;
67};
68template <> struct MakeIndexSequenceImpl<6> {
69 using Type = IndexSequence<0,1,2,3,4,5>;
70};
71template <> struct MakeIndexSequenceImpl<7> {
72 using Type = IndexSequence<0,1,2,3,4,5,6>;
73};
74template <> struct MakeIndexSequenceImpl<8> {
75 using Type = IndexSequence<0,1,2,3,4,5,6,7>;
76};
77template <> struct MakeIndexSequenceImpl<9> {
78 using Type = IndexSequence<0,1,2,3,4,5,6,7,8>;
79};
80template <> struct MakeIndexSequenceImpl<10> {
81 using Type = IndexSequence<0,1,2,3,4,5,6,7,8,9>;
82};
83template <> struct MakeIndexSequenceImpl<11> {
84 using Type = IndexSequence<0,1,2,3,4,5,6,7,8,9,10>;
85};
86template <> struct MakeIndexSequenceImpl<12> {
87 using Type = IndexSequence<0,1,2,3,4,5,6,7,8,9,10,11>;
88};
89template <> struct MakeIndexSequenceImpl<13> {
90 using Type = IndexSequence<0,1,2,3,4,5,6,7,8,9,10,11,12>;
91};
92
93#else // defined(WIN) && defined(_PREFAST_)
94
95template <size_t... Ns>
96struct MakeIndexSequenceImpl<0, Ns...> {
97 using Type = IndexSequence<Ns...>;
98};
99
100template <size_t N, size_t... Ns>
101struct MakeIndexSequenceImpl<N, Ns...>
102 : MakeIndexSequenceImpl<N - 1, N - 1, Ns...> {};
103
104#endif // defined(WIN) && defined(_PREFAST_)
105
106template <size_t N>
107using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::Type;
108
109// Traits ----------------------------------------------------------------------
110//
111// A simple traits class for tuple arguments.
112//
113// ValueType: the bare, nonref version of a type (same as the type for nonrefs).
114// RefType: the ref version of a type (same as the type for refs).
115// ParamType: what type to pass to functions (refs should not be constified).
116
117template <class P>
118struct TupleTraits {
119 typedef P ValueType;
120 typedef P& RefType;
121 typedef const P& ParamType;
122};
123
124template <class P>
125struct TupleTraits<P&> {
126 typedef P ValueType;
127 typedef P& RefType;
128 typedef P& ParamType;
129};
130
131// Tuple -----------------------------------------------------------------------
132//
133// This set of classes is useful for bundling 0 or more heterogeneous data types
134// into a single variable. The advantage of this is that it greatly simplifies
135// function objects that need to take an arbitrary number of parameters; see
136// RunnableMethod and IPC::MessageWithTuple.
137//
138// Tuple<> is supplied to act as a 'void' type. It can be used, for example,
139// when dispatching to a function that accepts no arguments (see the
140// Dispatchers below).
141// Tuple<A> is rarely useful. One such use is when A is non-const ref that you
142// want filled by the dispatchee, and the tuple is merely a container for that
143// output (a "tier"). See MakeRefTuple and its usages.
144
145template <typename IxSeq, typename... Ts>
146struct TupleBaseImpl;
147template <typename... Ts>
148using TupleBase = TupleBaseImpl<MakeIndexSequence<sizeof...(Ts)>, Ts...>;
149template <size_t N, typename T>
150struct TupleLeaf;
151
152template <typename... Ts>
153struct Tuple : TupleBase<Ts...> {
154 Tuple() : TupleBase<Ts...>() {}
155 explicit Tuple(typename TupleTraits<Ts>::ParamType... args)
156 : TupleBase<Ts...>(args...) {}
157};
158
159// Avoids ambiguity between Tuple's two constructors.
160template <>
161struct Tuple<> {};
162
163template <size_t... Ns, typename... Ts>
164struct TupleBaseImpl<IndexSequence<Ns...>, Ts...> : TupleLeaf<Ns, Ts>... {
165 TupleBaseImpl() : TupleLeaf<Ns, Ts>()... {}
166 explicit TupleBaseImpl(typename TupleTraits<Ts>::ParamType... args)
167 : TupleLeaf<Ns, Ts>(args)... {}
168};
169
170template <size_t N, typename T>
171struct TupleLeaf {
172 TupleLeaf() {}
173 explicit TupleLeaf(typename TupleTraits<T>::ParamType x) : x(x) {}
174
175 T& get() { return x; }
176 const T& get() const { return x; }
177
178 T x;
179};
180
181// Tuple getters --------------------------------------------------------------
182//
183// Allows accessing an arbitrary tuple element by index.
184//
185// Example usage:
186// base::Tuple<int, double> t2;
187// base::get<0>(t2) = 42;
188// base::get<1>(t2) = 3.14;
189
190template <size_t I, typename T>
191T& get(TupleLeaf<I, T>& leaf) {
192 return leaf.get();
193}
194
195template <size_t I, typename T>
196const T& get(const TupleLeaf<I, T>& leaf) {
197 return leaf.get();
198}
199
200// Tuple types ----------------------------------------------------------------
201//
202// Allows for selection of ValueTuple/RefTuple/ParamTuple without needing the
203// definitions of class types the tuple takes as parameters.
204
205template <typename T>
206struct TupleTypes;
207
208template <typename... Ts>
209struct TupleTypes<Tuple<Ts...>> {
210 using ValueTuple = Tuple<typename TupleTraits<Ts>::ValueType...>;
211 using RefTuple = Tuple<typename TupleTraits<Ts>::RefType...>;
212 using ParamTuple = Tuple<typename TupleTraits<Ts>::ParamType...>;
213};
214
215// Tuple creators -------------------------------------------------------------
216//
217// Helper functions for constructing tuples while inferring the template
218// argument types.
219
220template <typename... Ts>
221inline Tuple<Ts...> MakeTuple(const Ts&... arg) {
222 return Tuple<Ts...>(arg...);
223}
224
225// The following set of helpers make what Boost refers to as "Tiers" - a tuple
226// of references.
227
228template <typename... Ts>
229inline Tuple<Ts&...> MakeRefTuple(Ts&... arg) {
230 return Tuple<Ts&...>(arg...);
231}
232
233// Dispatchers ----------------------------------------------------------------
234//
235// Helper functions that call the given method on an object, with the unpacked
236// tuple arguments. Notice that they all have the same number of arguments,
237// so you need only write:
238// DispatchToMethod(object, &Object::method, args);
239// This is very useful for templated dispatchers, since they don't need to know
240// what type |args| is.
241
242// Non-Static Dispatchers with no out params.
243
244template <typename ObjT, typename Method, typename A>
245inline void DispatchToMethod(ObjT* obj, Method method, const A& arg) {
246 (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg));
247}
248
249template <typename ObjT, typename Method, typename... Ts, size_t... Ns>
250inline void DispatchToMethodImpl(ObjT* obj,
251 Method method,
252 const Tuple<Ts...>& arg,
253 IndexSequence<Ns...>) {
254 (obj->*method)(base::internal::UnwrapTraits<Ts>::Unwrap(get<Ns>(arg))...);
255}
256
257template <typename ObjT, typename Method, typename... Ts>
258inline void DispatchToMethod(ObjT* obj,
259 Method method,
260 const Tuple<Ts...>& arg) {
261 DispatchToMethodImpl(obj, method, arg, MakeIndexSequence<sizeof...(Ts)>());
262}
263
264// Static Dispatchers with no out params.
265
266template <typename Function, typename A>
267inline void DispatchToMethod(Function function, const A& arg) {
268 (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg));
269}
270
271template <typename Function, typename... Ts, size_t... Ns>
272inline void DispatchToFunctionImpl(Function function,
273 const Tuple<Ts...>& arg,
274 IndexSequence<Ns...>) {
275 (*function)(base::internal::UnwrapTraits<Ts>::Unwrap(get<Ns>(arg))...);
276}
277
278template <typename Function, typename... Ts>
279inline void DispatchToFunction(Function function, const Tuple<Ts...>& arg) {
280 DispatchToFunctionImpl(function, arg, MakeIndexSequence<sizeof...(Ts)>());
281}
282
283// Dispatchers with out parameters.
284
285template <typename ObjT,
286 typename Method,
287 typename In,
288 typename... OutTs,
289 size_t... OutNs>
290inline void DispatchToMethodImpl(ObjT* obj,
291 Method method,
292 const In& in,
293 Tuple<OutTs...>* out,
294 IndexSequence<OutNs...>) {
295 (obj->*method)(base::internal::UnwrapTraits<In>::Unwrap(in),
296 &get<OutNs>(*out)...);
297}
298
299template <typename ObjT, typename Method, typename In, typename... OutTs>
300inline void DispatchToMethod(ObjT* obj,
301 Method method,
302 const In& in,
303 Tuple<OutTs...>* out) {
304 DispatchToMethodImpl(obj, method, in, out,
305 MakeIndexSequence<sizeof...(OutTs)>());
306}
307
308template <typename ObjT,
309 typename Method,
310 typename... InTs,
311 typename... OutTs,
312 size_t... InNs,
313 size_t... OutNs>
314inline void DispatchToMethodImpl(ObjT* obj,
315 Method method,
316 const Tuple<InTs...>& in,
317 Tuple<OutTs...>* out,
318 IndexSequence<InNs...>,
319 IndexSequence<OutNs...>) {
320 (obj->*method)(base::internal::UnwrapTraits<InTs>::Unwrap(get<InNs>(in))...,
321 &get<OutNs>(*out)...);
322}
323
324template <typename ObjT, typename Method, typename... InTs, typename... OutTs>
325inline void DispatchToMethod(ObjT* obj,
326 Method method,
327 const Tuple<InTs...>& in,
328 Tuple<OutTs...>* out) {
329 DispatchToMethodImpl(obj, method, in, out,
330 MakeIndexSequence<sizeof...(InTs)>(),
331 MakeIndexSequence<sizeof...(OutTs)>());
332}
333
334} // namespace base
335
336#endif // BASE_TUPLE_H_