blob: 5a048586425d4c1c47d14bd0cdf23f3dabc4e14a [file] [log] [blame]
oshima@chromium.orgcc654912011-09-28 09:33:59 +09001// Copyright (c) 2011 The Chromium Authors. All rights reserved.
license.botf003cfe2008-08-24 09:55:55 +09002// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit3f4a7322008-07-27 06:49:38 +09004
mdempskyf705f9f2014-12-10 20:22:23 +09005// 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.
deanm@google.com96aac0a2008-08-25 22:42:07 +090010//
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.
mdempskyf705f9f2014-12-10 20:22:23 +090016// Tuple<int, const char*> tuple_a(1, "wee");
17// Tuple<int, const char*> tuple_b = MakeTuple(1, "wee");
deanm@google.com96aac0a2008-08-25 22:42:07 +090018//
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
tfarinab6d62d82015-05-14 07:10:15 +090028#ifndef BASE_TUPLE_H_
29#define BASE_TUPLE_H_
initial.commit3f4a7322008-07-27 06:49:38 +090030
rsleevi@chromium.org274c7222013-06-27 21:48:02 +090031#include "base/bind_helpers.h"
32
brettw79a90902015-05-30 07:15:47 +090033namespace base {
34
mdempsky0c1d6ed2014-12-10 12:10:59 +090035// 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
brucedawson864de222015-01-22 07:02:16 +090045#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};
brucedawson8b052562015-04-21 03:20:37 +090086template <> 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};
brucedawson864de222015-01-22 07:02:16 +090092
93#else // defined(WIN) && defined(_PREFAST_)
94
mdempsky0c1d6ed2014-12-10 12:10:59 +090095template <size_t... Ns>
96struct MakeIndexSequenceImpl<0, Ns...> {
97 using Type = IndexSequence<Ns...>;
98};
99
100template <size_t N, size_t... Ns>
mdempskyf705f9f2014-12-10 20:22:23 +0900101struct MakeIndexSequenceImpl<N, Ns...>
102 : MakeIndexSequenceImpl<N - 1, N - 1, Ns...> {};
mdempsky0c1d6ed2014-12-10 12:10:59 +0900103
brucedawson864de222015-01-22 07:02:16 +0900104#endif // defined(WIN) && defined(_PREFAST_)
105
mdempsky0c1d6ed2014-12-10 12:10:59 +0900106template <size_t N>
107using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::Type;
108
initial.commit3f4a7322008-07-27 06:49:38 +0900109// 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//
mdempskyf705f9f2014-12-10 20:22:23 +0900138// Tuple<> is supplied to act as a 'void' type. It can be used, for example,
deanm@google.comff4b7292008-08-21 19:58:08 +0900139// when dispatching to a function that accepts no arguments (see the
140// Dispatchers below).
mdempskyf705f9f2014-12-10 20:22:23 +0900141// Tuple<A> is rarely useful. One such use is when A is non-const ref that you
initial.commit3f4a7322008-07-27 06:49:38 +0900142// want filled by the dispatchee, and the tuple is merely a container for that
143// output (a "tier"). See MakeRefTuple and its usages.
144
mdempskyf705f9f2014-12-10 20:22:23 +0900145template <typename IxSeq, typename... Ts>
146struct TupleBaseImpl;
mdempsky0c1d6ed2014-12-10 12:10:59 +0900147template <typename... Ts>
mdempskyf705f9f2014-12-10 20:22:23 +0900148using TupleBase = TupleBaseImpl<MakeIndexSequence<sizeof...(Ts)>, Ts...>;
149template <size_t N, typename T>
150struct TupleLeaf;
initial.commit3f4a7322008-07-27 06:49:38 +0900151
mdempskyf705f9f2014-12-10 20:22:23 +0900152template <typename... Ts>
tzik703f6712015-11-19 05:34:55 +0900153struct Tuple final : TupleBase<Ts...> {
mdempskyf705f9f2014-12-10 20:22:23 +0900154 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.
mdempsky0c1d6ed2014-12-10 12:10:59 +0900160template <>
tzik703f6712015-11-19 05:34:55 +0900161struct Tuple<> final {};
mdempsky0c1d6ed2014-12-10 12:10:59 +0900162
mdempskyf705f9f2014-12-10 20:22:23 +0900163template <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)... {}
initial.commit3f4a7322008-07-27 06:49:38 +0900168};
169
mdempskyf705f9f2014-12-10 20:22:23 +0900170template <size_t N, typename T>
171struct TupleLeaf {
mdempsky00c97232014-12-16 08:26:13 +0900172 TupleLeaf() {}
mdempskyf705f9f2014-12-10 20:22:23 +0900173 explicit TupleLeaf(typename TupleTraits<T>::ParamType x) : x(x) {}
initial.commit3f4a7322008-07-27 06:49:38 +0900174
mdempskyf705f9f2014-12-10 20:22:23 +0900175 T& get() { return x; }
176 const T& get() const { return x; }
initial.commit3f4a7322008-07-27 06:49:38 +0900177
mdempskyf705f9f2014-12-10 20:22:23 +0900178 T x;
initial.commit3f4a7322008-07-27 06:49:38 +0900179};
180
mdempsky0c1d6ed2014-12-10 12:10:59 +0900181// Tuple getters --------------------------------------------------------------
mdempskyf705f9f2014-12-10 20:22:23 +0900182//
183// Allows accessing an arbitrary tuple element by index.
184//
185// Example usage:
brettw79a90902015-05-30 07:15:47 +0900186// base::Tuple<int, double> t2;
187// base::get<0>(t2) = 42;
188// base::get<1>(t2) = 3.14;
mdempsky0c1d6ed2014-12-10 12:10:59 +0900189
mdempskyf705f9f2014-12-10 20:22:23 +0900190template <size_t I, typename T>
191T& get(TupleLeaf<I, T>& leaf) {
192 return leaf.get();
mdempsky0c1d6ed2014-12-10 12:10:59 +0900193}
194
mdempskyf705f9f2014-12-10 20:22:23 +0900195template <size_t I, typename T>
196const T& get(const TupleLeaf<I, T>& leaf) {
197 return leaf.get();
mdempsky0c1d6ed2014-12-10 12:10:59 +0900198}
199
erg@google.come6ffcb52010-08-18 03:38:24 +0900200// 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
mdempsky0c1d6ed2014-12-10 12:10:59 +0900205template <typename T>
206struct TupleTypes;
erg@google.come6ffcb52010-08-18 03:38:24 +0900207
mdempsky0c1d6ed2014-12-10 12:10:59 +0900208template <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...>;
erg@google.come6ffcb52010-08-18 03:38:24 +0900213};
214
initial.commit3f4a7322008-07-27 06:49:38 +0900215// Tuple creators -------------------------------------------------------------
216//
217// Helper functions for constructing tuples while inferring the template
218// argument types.
219
mdempsky0c1d6ed2014-12-10 12:10:59 +0900220template <typename... Ts>
221inline Tuple<Ts...> MakeTuple(const Ts&... arg) {
222 return Tuple<Ts...>(arg...);
phajdan.jr@chromium.org5a468fc2010-07-21 01:56:26 +0900223}
224
initial.commit3f4a7322008-07-27 06:49:38 +0900225// The following set of helpers make what Boost refers to as "Tiers" - a tuple
226// of references.
227
mdempsky0c1d6ed2014-12-10 12:10:59 +0900228template <typename... Ts>
229inline Tuple<Ts&...> MakeRefTuple(Ts&... arg) {
230 return Tuple<Ts&...>(arg...);
phajdan.jr@chromium.org5a468fc2010-07-21 01:56:26 +0900231}
232
initial.commit3f4a7322008-07-27 06:49:38 +0900233// 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
mdempsky0c1d6ed2014-12-10 12:10:59 +0900244template <typename ObjT, typename Method, typename A>
initial.commit3f4a7322008-07-27 06:49:38 +0900245inline void DispatchToMethod(ObjT* obj, Method method, const A& arg) {
rsleevi@chromium.org274c7222013-06-27 21:48:02 +0900246 (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg));
initial.commit3f4a7322008-07-27 06:49:38 +0900247}
248
mdempsky0c1d6ed2014-12-10 12:10:59 +0900249template <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))...);
initial.commit3f4a7322008-07-27 06:49:38 +0900255}
256
mdempsky0c1d6ed2014-12-10 12:10:59 +0900257template <typename ObjT, typename Method, typename... Ts>
maruel@chromium.org8fe7adc2009-03-04 00:01:12 +0900258inline void DispatchToMethod(ObjT* obj,
259 Method method,
mdempsky0c1d6ed2014-12-10 12:10:59 +0900260 const Tuple<Ts...>& arg) {
261 DispatchToMethodImpl(obj, method, arg, MakeIndexSequence<sizeof...(Ts)>());
noelutz@google.comdd96ed82011-02-18 04:47:13 +0900262}
263
initial.commit3f4a7322008-07-27 06:49:38 +0900264// Static Dispatchers with no out params.
265
mdempsky0c1d6ed2014-12-10 12:10:59 +0900266template <typename Function, typename A>
267inline void DispatchToMethod(Function function, const A& arg) {
268 (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg));
initial.commit3f4a7322008-07-27 06:49:38 +0900269}
270
mdempsky0c1d6ed2014-12-10 12:10:59 +0900271template <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))...);
initial.commit3f4a7322008-07-27 06:49:38 +0900276}
277
mdempsky0c1d6ed2014-12-10 12:10:59 +0900278template <typename Function, typename... Ts>
279inline void DispatchToFunction(Function function, const Tuple<Ts...>& arg) {
280 DispatchToFunctionImpl(function, arg, MakeIndexSequence<sizeof...(Ts)>());
initial.commit3f4a7322008-07-27 06:49:38 +0900281}
282
mdempsky0c1d6ed2014-12-10 12:10:59 +0900283// 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)...);
initial.commit3f4a7322008-07-27 06:49:38 +0900297}
298
mdempsky0c1d6ed2014-12-10 12:10:59 +0900299template <typename ObjT, typename Method, typename In, typename... OutTs>
maruel@chromium.org8fe7adc2009-03-04 00:01:12 +0900300inline void DispatchToMethod(ObjT* obj,
301 Method method,
mdempsky0c1d6ed2014-12-10 12:10:59 +0900302 const In& in,
303 Tuple<OutTs...>* out) {
304 DispatchToMethodImpl(obj, method, in, out,
305 MakeIndexSequence<sizeof...(OutTs)>());
initial.commit3f4a7322008-07-27 06:49:38 +0900306}
307
mdempsky0c1d6ed2014-12-10 12:10:59 +0900308template <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)...);
initial.commit3f4a7322008-07-27 06:49:38 +0900322}
323
mdempsky0c1d6ed2014-12-10 12:10:59 +0900324template <typename ObjT, typename Method, typename... InTs, typename... OutTs>
maruel@chromium.org8fe7adc2009-03-04 00:01:12 +0900325inline void DispatchToMethod(ObjT* obj,
326 Method method,
mdempsky0c1d6ed2014-12-10 12:10:59 +0900327 const Tuple<InTs...>& in,
328 Tuple<OutTs...>* out) {
329 DispatchToMethodImpl(obj, method, in, out,
330 MakeIndexSequence<sizeof...(InTs)>(),
331 MakeIndexSequence<sizeof...(OutTs)>());
ojan@google.com38355092008-10-10 06:58:05 +0900332}
333
brettw79a90902015-05-30 07:15:47 +0900334} // namespace base
335
tfarinab6d62d82015-05-14 07:10:15 +0900336#endif // BASE_TUPLE_H_