[Android] Use proper mouse wheel delta
[chromium-blink-merge.git] / base / tuple.h
blobef51d85fed9e7e5a5460a78595f245e3feeaef64
1 // 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.
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.
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.
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");
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")
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);
28 #ifndef BASE_TUPLE_H_
29 #define BASE_TUPLE_H_
31 #include "base/bind_helpers.h"
33 namespace base {
35 // Index sequences
37 // Minimal clone of the similarly-named C++14 functionality.
39 template <size_t...>
40 struct IndexSequence {};
42 template <size_t... Ns>
43 struct MakeIndexSequenceImpl;
45 #if defined(_PREFAST_) && defined(OS_WIN)
47 // Work around VC++ 2013 /analyze internal compiler error:
48 // https://connect.microsoft.com/VisualStudio/feedback/details/1053626
50 template <> struct MakeIndexSequenceImpl<0> {
51 using Type = IndexSequence<>;
53 template <> struct MakeIndexSequenceImpl<1> {
54 using Type = IndexSequence<0>;
56 template <> struct MakeIndexSequenceImpl<2> {
57 using Type = IndexSequence<0,1>;
59 template <> struct MakeIndexSequenceImpl<3> {
60 using Type = IndexSequence<0,1,2>;
62 template <> struct MakeIndexSequenceImpl<4> {
63 using Type = IndexSequence<0,1,2,3>;
65 template <> struct MakeIndexSequenceImpl<5> {
66 using Type = IndexSequence<0,1,2,3,4>;
68 template <> struct MakeIndexSequenceImpl<6> {
69 using Type = IndexSequence<0,1,2,3,4,5>;
71 template <> struct MakeIndexSequenceImpl<7> {
72 using Type = IndexSequence<0,1,2,3,4,5,6>;
74 template <> struct MakeIndexSequenceImpl<8> {
75 using Type = IndexSequence<0,1,2,3,4,5,6,7>;
77 template <> struct MakeIndexSequenceImpl<9> {
78 using Type = IndexSequence<0,1,2,3,4,5,6,7,8>;
80 template <> struct MakeIndexSequenceImpl<10> {
81 using Type = IndexSequence<0,1,2,3,4,5,6,7,8,9>;
83 template <> struct MakeIndexSequenceImpl<11> {
84 using Type = IndexSequence<0,1,2,3,4,5,6,7,8,9,10>;
86 template <> struct MakeIndexSequenceImpl<12> {
87 using Type = IndexSequence<0,1,2,3,4,5,6,7,8,9,10,11>;
89 template <> struct MakeIndexSequenceImpl<13> {
90 using Type = IndexSequence<0,1,2,3,4,5,6,7,8,9,10,11,12>;
93 #else // defined(WIN) && defined(_PREFAST_)
95 template <size_t... Ns>
96 struct MakeIndexSequenceImpl<0, Ns...> {
97 using Type = IndexSequence<Ns...>;
100 template <size_t N, size_t... Ns>
101 struct MakeIndexSequenceImpl<N, Ns...>
102 : MakeIndexSequenceImpl<N - 1, N - 1, Ns...> {};
104 #endif // defined(WIN) && defined(_PREFAST_)
106 template <size_t N>
107 using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::Type;
109 // Traits ----------------------------------------------------------------------
111 // A simple traits class for tuple arguments.
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).
117 template <class P>
118 struct TupleTraits {
119 typedef P ValueType;
120 typedef P& RefType;
121 typedef const P& ParamType;
124 template <class P>
125 struct TupleTraits<P&> {
126 typedef P ValueType;
127 typedef P& RefType;
128 typedef P& ParamType;
131 // Tuple -----------------------------------------------------------------------
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.
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.
145 template <typename IxSeq, typename... Ts>
146 struct TupleBaseImpl;
147 template <typename... Ts>
148 using TupleBase = TupleBaseImpl<MakeIndexSequence<sizeof...(Ts)>, Ts...>;
149 template <size_t N, typename T>
150 struct TupleLeaf;
152 template <typename... Ts>
153 struct Tuple : TupleBase<Ts...> {
154 Tuple() : TupleBase<Ts...>() {}
155 explicit Tuple(typename TupleTraits<Ts>::ParamType... args)
156 : TupleBase<Ts...>(args...) {}
159 // Avoids ambiguity between Tuple's two constructors.
160 template <>
161 struct Tuple<> {};
163 template <size_t... Ns, typename... Ts>
164 struct 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)... {}
170 template <size_t N, typename T>
171 struct TupleLeaf {
172 TupleLeaf() {}
173 explicit TupleLeaf(typename TupleTraits<T>::ParamType x) : x(x) {}
175 T& get() { return x; }
176 const T& get() const { return x; }
178 T x;
181 // Tuple getters --------------------------------------------------------------
183 // Allows accessing an arbitrary tuple element by index.
185 // Example usage:
186 // base::Tuple<int, double> t2;
187 // base::get<0>(t2) = 42;
188 // base::get<1>(t2) = 3.14;
190 template <size_t I, typename T>
191 T& get(TupleLeaf<I, T>& leaf) {
192 return leaf.get();
195 template <size_t I, typename T>
196 const T& get(const TupleLeaf<I, T>& leaf) {
197 return leaf.get();
200 // Tuple types ----------------------------------------------------------------
202 // Allows for selection of ValueTuple/RefTuple/ParamTuple without needing the
203 // definitions of class types the tuple takes as parameters.
205 template <typename T>
206 struct TupleTypes;
208 template <typename... Ts>
209 struct 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...>;
215 // Tuple creators -------------------------------------------------------------
217 // Helper functions for constructing tuples while inferring the template
218 // argument types.
220 template <typename... Ts>
221 inline Tuple<Ts...> MakeTuple(const Ts&... arg) {
222 return Tuple<Ts...>(arg...);
225 // The following set of helpers make what Boost refers to as "Tiers" - a tuple
226 // of references.
228 template <typename... Ts>
229 inline Tuple<Ts&...> MakeRefTuple(Ts&... arg) {
230 return Tuple<Ts&...>(arg...);
233 // Dispatchers ----------------------------------------------------------------
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.
242 // Non-Static Dispatchers with no out params.
244 template <typename ObjT, typename Method, typename A>
245 inline void DispatchToMethod(ObjT* obj, Method method, const A& arg) {
246 (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg));
249 template <typename ObjT, typename Method, typename... Ts, size_t... Ns>
250 inline 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))...);
257 template <typename ObjT, typename Method, typename... Ts>
258 inline void DispatchToMethod(ObjT* obj,
259 Method method,
260 const Tuple<Ts...>& arg) {
261 DispatchToMethodImpl(obj, method, arg, MakeIndexSequence<sizeof...(Ts)>());
264 // Static Dispatchers with no out params.
266 template <typename Function, typename A>
267 inline void DispatchToMethod(Function function, const A& arg) {
268 (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg));
271 template <typename Function, typename... Ts, size_t... Ns>
272 inline void DispatchToFunctionImpl(Function function,
273 const Tuple<Ts...>& arg,
274 IndexSequence<Ns...>) {
275 (*function)(base::internal::UnwrapTraits<Ts>::Unwrap(get<Ns>(arg))...);
278 template <typename Function, typename... Ts>
279 inline void DispatchToFunction(Function function, const Tuple<Ts...>& arg) {
280 DispatchToFunctionImpl(function, arg, MakeIndexSequence<sizeof...(Ts)>());
283 // Dispatchers with out parameters.
285 template <typename ObjT,
286 typename Method,
287 typename In,
288 typename... OutTs,
289 size_t... OutNs>
290 inline 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)...);
299 template <typename ObjT, typename Method, typename In, typename... OutTs>
300 inline 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)>());
308 template <typename ObjT,
309 typename Method,
310 typename... InTs,
311 typename... OutTs,
312 size_t... InNs,
313 size_t... OutNs>
314 inline 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)...);
324 template <typename ObjT, typename Method, typename... InTs, typename... OutTs>
325 inline 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)>());
334 } // namespace base
336 #endif // BASE_TUPLE_H_