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
|
// Copyright 2016 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_SERIALIZATION_FORWARD_H_
#define MOJO_PUBLIC_CPP_BINDINGS_LIB_SERIALIZATION_FORWARD_H_
#include "base/optional.h"
#include "mojo/public/cpp/bindings/array_traits.h"
#include "mojo/public/cpp/bindings/enum_traits.h"
#include "mojo/public/cpp/bindings/lib/template_util.h"
#include "mojo/public/cpp/bindings/map_traits.h"
#include "mojo/public/cpp/bindings/string_traits.h"
#include "mojo/public/cpp/bindings/struct_traits.h"
#include "mojo/public/cpp/bindings/union_traits.h"
// This file is included by serialization implementation files to avoid circular
// includes.
// Users of the serialization funtions should include serialization.h (and also
// wtf_serialization.h if necessary).
namespace mojo {
namespace internal {
template <typename MojomType, typename MaybeConstUserType>
struct Serializer;
template <typename T>
struct IsOptionalWrapper {
static const bool value = IsSpecializationOf<
base::Optional,
typename std::remove_const<
typename std::remove_reference<T>::type>::type>::value;
};
// PrepareToSerialize() must be matched by a Serialize() for the same input
// later. Moreover, within the same SerializationContext if PrepareToSerialize()
// is called for |input_1|, ..., |input_n|, Serialize() must be called for
// those objects in the exact same order.
template <typename MojomType,
typename InputUserType,
typename... Args,
typename std::enable_if<
!IsOptionalWrapper<InputUserType>::value>::type* = nullptr>
size_t PrepareToSerialize(InputUserType&& input, Args&&... args) {
return Serializer<MojomType,
typename std::remove_reference<InputUserType>::type>::
PrepareToSerialize(std::forward<InputUserType>(input),
std::forward<Args>(args)...);
}
template <typename MojomType,
typename InputUserType,
typename... Args,
typename std::enable_if<
!IsOptionalWrapper<InputUserType>::value>::type* = nullptr>
void Serialize(InputUserType&& input, Args&&... args) {
Serializer<MojomType, typename std::remove_reference<InputUserType>::type>::
Serialize(std::forward<InputUserType>(input),
std::forward<Args>(args)...);
}
template <typename MojomType,
typename DataType,
typename InputUserType,
typename... Args,
typename std::enable_if<
!IsOptionalWrapper<InputUserType>::value>::type* = nullptr>
bool Deserialize(DataType&& input, InputUserType* output, Args&&... args) {
return Serializer<MojomType, InputUserType>::Deserialize(
std::forward<DataType>(input), output, std::forward<Args>(args)...);
}
// Specialization that unwraps base::Optional<>.
template <typename MojomType,
typename InputUserType,
typename... Args,
typename std::enable_if<
IsOptionalWrapper<InputUserType>::value>::type* = nullptr>
size_t PrepareToSerialize(InputUserType&& input, Args&&... args) {
if (!input)
return 0;
return PrepareToSerialize<MojomType>(*input, std::forward<Args>(args)...);
}
template <typename MojomType,
typename InputUserType,
typename DataType,
typename... Args,
typename std::enable_if<
IsOptionalWrapper<InputUserType>::value>::type* = nullptr>
void Serialize(InputUserType&& input,
Buffer* buffer,
DataType** output,
Args&&... args) {
if (!input) {
*output = nullptr;
return;
}
Serialize<MojomType>(*input, buffer, output, std::forward<Args>(args)...);
}
template <typename MojomType,
typename DataType,
typename InputUserType,
typename... Args,
typename std::enable_if<
IsOptionalWrapper<InputUserType>::value>::type* = nullptr>
bool Deserialize(DataType&& input, InputUserType* output, Args&&... args) {
if (!input) {
*output = base::nullopt;
return true;
}
if (!*output)
output->emplace();
return Deserialize<MojomType>(std::forward<DataType>(input), &output->value(),
std::forward<Args>(args)...);
}
} // namespace internal
} // namespace mojo
#endif // MOJO_PUBLIC_CPP_BINDINGS_LIB_SERIALIZATION_FORWARD_H_
|
