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
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef MOJO_PUBLIC_CPP_BINDINGS_LIB_TEMPLATE_UTIL_H_
#define MOJO_PUBLIC_CPP_BINDINGS_LIB_TEMPLATE_UTIL_H_
namespace mojo {
namespace internal {
template<class T, T v>
struct IntegralConstant {
static const T value = v;
};
template <class T, T v> const T IntegralConstant<T, v>::value;
typedef IntegralConstant<bool, true> TrueType;
typedef IntegralConstant<bool, false> FalseType;
template <class T> struct IsConst : FalseType {};
template <class T> struct IsConst<const T> : TrueType {};
template<bool B, typename T = void>
struct EnableIf {};
template<typename T>
struct EnableIf<true, T> { typedef T type; };
// Types YesType and NoType are guaranteed such that sizeof(YesType) <
// sizeof(NoType).
typedef char YesType;
struct NoType {
YesType dummy[2];
};
// A helper template to determine if given type is non-const move-only-type,
// i.e. if a value of the given type should be passed via .Pass() in a
// destructive way.
template <typename T> struct IsMoveOnlyType {
template <typename U>
static YesType Test(const typename U::MoveOnlyTypeForCPP03*);
template <typename U>
static NoType Test(...);
static const bool value = sizeof(Test<T>(0)) == sizeof(YesType) &&
!IsConst<T>::value;
};
template <typename T>
typename EnableIf<!IsMoveOnlyType<T>::value, T>::type& Forward(T& t) {
return t;
}
template <typename T>
typename EnableIf<IsMoveOnlyType<T>::value, T>::type Forward(T& t) {
return t.Pass();
}
// This goop is a trick used to implement a template that can be used to
// determine if a given class is the base class of another given class.
template<typename, typename> struct IsSame {
static bool const value = false;
};
template<typename A> struct IsSame<A, A> {
static bool const value = true;
};
template<typename Base, typename Derived> struct IsBaseOf {
private:
// This class doesn't work correctly with forward declarations.
// Because sizeof cannot be applied to incomplete types, this line prevents us
// from passing in forward declarations.
typedef char (*EnsureTypesAreComplete)[sizeof(Base) + sizeof(Derived)];
static Derived* CreateDerived();
static char (&Check(Base*))[1];
static char (&Check(...))[2];
public:
static bool const value = sizeof Check(CreateDerived()) == 1 &&
!IsSame<Base const, void const>::value;
};
} // namespace internal
} // namespace mojo
#endif // MOJO_PUBLIC_CPP_BINDINGS_LIB_TEMPLATE_UTIL_H_
|
