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
|
// Copyright 2013 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_BINDINGS_INTERNAL_H_
#define MOJO_PUBLIC_CPP_BINDINGS_LIB_BINDINGS_INTERNAL_H_
#include "mojo/public/cpp/bindings/lib/template_util.h"
#include "mojo/public/cpp/bindings/struct_ptr.h"
#include "mojo/public/cpp/system/core.h"
namespace mojo {
class String;
template <typename T>
class Array;
template <typename K, typename V>
class Map;
namespace internal {
template <typename T>
class Array_Data;
#pragma pack(push, 1)
struct StructHeader {
uint32_t num_bytes;
uint32_t num_fields;
};
static_assert(sizeof(StructHeader) == 8, "Bad sizeof(StructHeader)");
struct ArrayHeader {
uint32_t num_bytes;
uint32_t num_elements;
};
static_assert(sizeof(ArrayHeader) == 8, "Bad_sizeof(ArrayHeader)");
template <typename T>
union StructPointer {
uint64_t offset;
T* ptr;
};
static_assert(sizeof(StructPointer<char>) == 8, "Bad_sizeof(StructPointer)");
template <typename T>
union ArrayPointer {
uint64_t offset;
Array_Data<T>* ptr;
};
static_assert(sizeof(ArrayPointer<char>) == 8, "Bad_sizeof(ArrayPointer)");
union StringPointer {
uint64_t offset;
Array_Data<char>* ptr;
};
static_assert(sizeof(StringPointer) == 8, "Bad_sizeof(StringPointer)");
#pragma pack(pop)
template <typename T>
void ResetIfNonNull(T* ptr) {
if (ptr)
*ptr = T();
}
template <typename T>
T FetchAndReset(T* ptr) {
T temp = *ptr;
*ptr = T();
return temp;
}
template <typename H>
struct IsHandle {
enum { value = IsBaseOf<Handle, H>::value };
};
template <typename T, bool move_only = IsMoveOnlyType<T>::value>
struct WrapperTraits;
template <typename T>
struct WrapperTraits<T, false> {
typedef T DataType;
};
template <typename H>
struct WrapperTraits<ScopedHandleBase<H>, true> {
typedef H DataType;
};
template <typename S>
struct WrapperTraits<StructPtr<S>, true> {
typedef typename S::Data_* DataType;
};
template <typename S>
struct WrapperTraits<InlinedStructPtr<S>, true> {
typedef typename S::Data_* DataType;
};
template <typename S>
struct WrapperTraits<S, true> {
typedef typename S::Data_* DataType;
};
template <typename T, typename Enable = void>
struct ValueTraits {
static bool Equals(const T& a, const T& b) { return a == b; }
};
template <typename T>
struct ValueTraits<
T,
typename EnableIf<IsSpecializationOf<Array, T>::value ||
IsSpecializationOf<Map, T>::value ||
IsSpecializationOf<StructPtr, T>::value ||
IsSpecializationOf<InlinedStructPtr, T>::value>::type> {
static bool Equals(const T& a, const T& b) { return a.Equals(b); }
};
template <typename T>
struct ValueTraits<ScopedHandleBase<T>> {
static bool Equals(const ScopedHandleBase<T>& a,
const ScopedHandleBase<T>& b) {
return a.get().value() == b.get().value();
}
};
} // namespace internal
} // namespace mojo
#endif // MOJO_PUBLIC_CPP_BINDINGS_LIB_BINDINGS_INTERNAL_H_
|
