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
|
// 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_TYPE_CONVERTER_H_
#define MOJO_PUBLIC_CPP_BINDINGS_TYPE_CONVERTER_H_
#include <stdint.h>
#include <vector>
namespace mojo {
// NOTE: TypeConverter is deprecated. Please consider StructTraits /
// UnionTraits / EnumTraits / ArrayTraits / MapTraits / StringTraits if you
// would like to convert between custom types and the wire format of mojom
// types.
//
// Specialize the following class:
// template <typename T, typename U> struct TypeConverter;
// to perform type conversion for Mojom-defined structs and arrays. Here, T is
// the target type; U is the input type.
//
// Specializations should implement the following interfaces:
// namespace mojo {
// template <>
// struct TypeConverter<X, Y> {
// static X Convert(const Y& input);
// };
// template <>
// struct TypeConverter<Y, X> {
// static Y Convert(const X& input);
// };
// }
//
// EXAMPLE:
//
// Suppose you have the following Mojom-defined struct:
//
// module geometry {
// struct Point {
// int32_t x;
// int32_t y;
// };
// }
//
// Now, imagine you wanted to write a TypeConverter specialization for
// gfx::Point. It might look like this:
//
// namespace mojo {
// template <>
// struct TypeConverter<geometry::PointPtr, gfx::Point> {
// static geometry::PointPtr Convert(const gfx::Point& input) {
// geometry::PointPtr result;
// result->x = input.x();
// result->y = input.y();
// return result;
// }
// };
// template <>
// struct TypeConverter<gfx::Point, geometry::PointPtr> {
// static gfx::Point Convert(const geometry::PointPtr& input) {
// return input ? gfx::Point(input->x, input->y) : gfx::Point();
// }
// };
// }
//
// With the above TypeConverter defined, it is possible to write code like this:
//
// void AcceptPoint(const geometry::PointPtr& input) {
// // With an explicit cast using the .To<> method.
// gfx::Point pt = input.To<gfx::Point>();
//
// // With an explicit cast using the static From() method.
// geometry::PointPtr output = geometry::Point::From(pt);
//
// // Inferring the input type using the ConvertTo helper function.
// gfx::Point pt2 = ConvertTo<gfx::Point>(input);
// }
//
template <typename T, typename U>
struct TypeConverter;
template <typename T, typename U>
inline T ConvertTo(const U& obj);
// The following specialization is useful when you are converting between
// Array<POD> and std::vector<POD>.
template <typename T>
struct TypeConverter<T, T> {
static T Convert(const T& obj) { return obj; }
};
template <typename T, typename Container>
struct TypeConverter<std::vector<T>, Container> {
static std::vector<T> Convert(const Container& container) {
std::vector<T> output;
output.reserve(container.size());
for (const auto& obj : container) {
output.push_back(ConvertTo<T>(obj));
}
return output;
}
};
// The following helper function is useful for shorthand. The compiler can infer
// the input type, so you can write:
// OutputType out = ConvertTo<OutputType>(input);
template <typename T, typename U>
inline T ConvertTo(const U& obj) {
return TypeConverter<T, U>::Convert(obj);
};
} // namespace mojo
#endif // MOJO_PUBLIC_CPP_BINDINGS_TYPE_CONVERTER_H_
|
