#include "mojo/public/c/system/macros.h"
#include "mojo/public/cpp/bindings/lib/array_internal.h"
+#include "mojo/public/cpp/bindings/lib/map_serialization.h"
#include "mojo/public/cpp/bindings/lib/string_serialization.h"
#include "mojo/public/cpp/bindings/lib/template_util.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
// Serialize_() doesn't seem to work. Therefore, this function is named
// differently from those Serialize_() overloads.
template <typename ValidateParams, typename E, typename F>
-inline void SerializeArray_(Array<E> input, internal::Buffer* buf,
+inline void SerializeArray_(Array<E> input,
+ internal::Buffer* buf,
internal::Array_Data<F>** output);
+template <typename ValueValidateParams,
+ typename KeyWrapperType,
+ typename ValueWrapperType,
+ typename KeySerializationType,
+ typename ValueSerializationType>
+inline void SerializeMap_(
+ Map<KeyWrapperType, ValueWrapperType> input,
+ internal::Buffer* buf,
+ internal::Map_Data<KeySerializationType, ValueSerializationType>** output);
+
template <typename E, typename F>
inline void Deserialize_(internal::Array_Data<F>* data, Array<E>* output);
template <typename E, typename F, bool move_only = IsMoveOnlyType<E>::value>
struct ArraySerializer;
-template <typename E, typename F> struct ArraySerializer<E, F, false> {
- MOJO_COMPILE_ASSERT(sizeof(E) == sizeof(F), wrong_array_serializer);
+template <typename E, typename F>
+struct ArraySerializer<E, F, false> {
+ static_assert(sizeof(E) == sizeof(F), "Incorrect array serializer");
static size_t GetSerializedSize(const Array<E>& input) {
return sizeof(Array_Data<F>) + Align(input.size() * sizeof(E));
}
template <bool element_is_nullable, typename ElementValidateParams>
- static void SerializeElements(
- Array<E> input, Buffer* buf, Array_Data<F>* output) {
- MOJO_COMPILE_ASSERT(!element_is_nullable,
- Primitive_type_should_be_non_nullable);
- MOJO_COMPILE_ASSERT(
- (IsSame<ElementValidateParams, NoValidateParams>::value),
- Primitive_type_should_not_have_array_validate_params);
+ static void SerializeElements(Array<E> input,
+ Buffer* buf,
+ Array_Data<F>* output) {
+ static_assert(!element_is_nullable,
+ "Primitive type should be non-nullable");
+ static_assert((IsSame<ElementValidateParams, NoValidateParams>::value),
+ "Primitive type should not have array validate params");
- memcpy(output->storage(), &input.storage()[0], input.size() * sizeof(E));
+ if (input.size())
+ memcpy(output->storage(), &input.storage()[0], input.size() * sizeof(E));
}
- static void DeserializeElements(
- Array_Data<F>* input, Array<E>* output) {
+ static void DeserializeElements(Array_Data<F>* input, Array<E>* output) {
std::vector<E> result(input->size());
- memcpy(&result[0], input->storage(), input->size() * sizeof(E));
+ if (input->size())
+ memcpy(&result[0], input->storage(), input->size() * sizeof(E));
output->Swap(&result);
}
};
-template <> struct ArraySerializer<bool, bool, false> {
+template <>
+struct ArraySerializer<bool, bool, false> {
static size_t GetSerializedSize(const Array<bool>& input) {
return sizeof(Array_Data<bool>) + Align((input.size() + 7) / 8);
}
template <bool element_is_nullable, typename ElementValidateParams>
- static void SerializeElements(
- Array<bool> input, Buffer* buf, Array_Data<bool>* output) {
- MOJO_COMPILE_ASSERT(!element_is_nullable,
- Primitive_type_should_be_non_nullable);
- MOJO_COMPILE_ASSERT(
- (IsSame<ElementValidateParams, NoValidateParams>::value),
- Primitive_type_should_not_have_array_validate_params);
+ static void SerializeElements(Array<bool> input,
+ Buffer* buf,
+ Array_Data<bool>* output) {
+ static_assert(!element_is_nullable,
+ "Primitive type should be non-nullable");
+ static_assert((IsSame<ElementValidateParams, NoValidateParams>::value),
+ "Primitive type should not have array validate params");
// TODO(darin): Can this be a memcpy somehow instead of a bit-by-bit copy?
for (size_t i = 0; i < input.size(); ++i)
output->at(i) = input[i];
}
- static void DeserializeElements(
- Array_Data<bool>* input, Array<bool>* output) {
+ static void DeserializeElements(Array_Data<bool>* input,
+ Array<bool>* output) {
Array<bool> result(input->size());
// TODO(darin): Can this be a memcpy somehow instead of a bit-by-bit copy?
for (size_t i = 0; i < input->size(); ++i)
}
};
-template <typename H> struct ArraySerializer<ScopedHandleBase<H>, H, true> {
- static size_t GetSerializedSize(const Array<ScopedHandleBase<H> >& input) {
+template <typename H>
+struct ArraySerializer<ScopedHandleBase<H>, H, true> {
+ static size_t GetSerializedSize(const Array<ScopedHandleBase<H>>& input) {
return sizeof(Array_Data<H>) + Align(input.size() * sizeof(H));
}
template <bool element_is_nullable, typename ElementValidateParams>
- static void SerializeElements(Array<ScopedHandleBase<H> > input,
+ static void SerializeElements(Array<ScopedHandleBase<H>> input,
Buffer* buf,
Array_Data<H>* output) {
- MOJO_COMPILE_ASSERT(
- (IsSame<ElementValidateParams, NoValidateParams>::value),
- Handle_type_should_not_have_array_validate_params);
+ static_assert((IsSame<ElementValidateParams, NoValidateParams>::value),
+ "Handle type should not have array validate params");
for (size_t i = 0; i < input.size(); ++i) {
output->at(i) = input[i].release(); // Transfer ownership of the handle.
VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
MakeMessageWithArrayIndex(
"invalid handle in array expecting valid handles",
- input.size(), i));
+ input.size(),
+ i));
}
}
- static void DeserializeElements(
- Array_Data<H>* input, Array<ScopedHandleBase<H> >* output) {
- Array<ScopedHandleBase<H> > result(input->size());
+ static void DeserializeElements(Array_Data<H>* input,
+ Array<ScopedHandleBase<H>>* output) {
+ Array<ScopedHandleBase<H>> result(input->size());
for (size_t i = 0; i < input->size(); ++i)
result.at(i) = MakeScopedHandle(FetchAndReset(&input->at(i)));
output->Swap(&result);
}
};
-template <typename S> struct ArraySerializer<S, typename S::Data_*, true> {
+// This template must only apply to pointer mojo entity (structs and arrays).
+// This is done by ensuring that WrapperTraits<S>::DataType is a pointer.
+template <typename S>
+struct ArraySerializer<S,
+ typename internal::EnableIf<
+ internal::IsPointer<typename internal::WrapperTraits<
+ S>::DataType>::value,
+ typename internal::WrapperTraits<S>::DataType>::type,
+ true> {
+ typedef typename internal::RemovePointer<
+ typename internal::WrapperTraits<S>::DataType>::type S_Data;
static size_t GetSerializedSize(const Array<S>& input) {
- size_t size = sizeof(Array_Data<typename S::Data_*>) +
- input.size() * sizeof(internal::StructPointer<typename S::Data_>);
+ size_t size = sizeof(Array_Data<S_Data*>) +
+ input.size() * sizeof(internal::StructPointer<S_Data>);
for (size_t i = 0; i < input.size(); ++i)
size += GetSerializedSize_(input[i]);
return size;
template <bool element_is_nullable, typename ElementValidateParams>
static void SerializeElements(Array<S> input,
Buffer* buf,
- Array_Data<typename S::Data_*>* output) {
+ Array_Data<S_Data*>* output) {
for (size_t i = 0; i < input.size(); ++i) {
- typename S::Data_* element;
+ S_Data* element;
SerializeCaller<S, ElementValidateParams>::Run(
input[i].Pass(), buf, &element);
output->at(i) = element;
"null in array expecting valid pointers", input.size(), i));
}
}
- static void DeserializeElements(
- Array_Data<typename S::Data_*>* input, Array<S>* output) {
+ static void DeserializeElements(Array_Data<S_Data*>* input,
+ Array<S>* output) {
Array<S> result(input->size());
for (size_t i = 0; i < input->size(); ++i) {
S element;
private:
template <typename T, typename Params>
struct SerializeCaller {
- static void Run(T input, Buffer* buf, typename T::Data_** output) {
- MOJO_COMPILE_ASSERT((IsSame<Params, NoValidateParams>::value),
- Struct_type_should_not_have_array_validate_params);
+ static void Run(T input,
+ Buffer* buf,
+ typename internal::WrapperTraits<T>::DataType* output) {
+ static_assert((IsSame<Params, NoValidateParams>::value),
+ "Struct type should not have array validate params");
Serialize_(input.Pass(), buf, output);
}
SerializeArray_<Params>(input.Pass(), buf, output);
}
};
+
+ template <typename T, typename U, typename Params>
+ struct SerializeCaller<Map<T, U>, Params> {
+ static void Run(Map<T, U> input,
+ Buffer* buf,
+ typename Map<T, U>::Data_** output) {
+ SerializeMap_<Params>(input.Pass(), buf, output);
+ }
+ };
};
-template <> struct ArraySerializer<String, String_Data*, false> {
+template <>
+struct ArraySerializer<String, String_Data*, false> {
static size_t GetSerializedSize(const Array<String>& input) {
size_t size = sizeof(Array_Data<String_Data*>) +
- input.size() * sizeof(internal::StringPointer);
+ input.size() * sizeof(internal::StringPointer);
for (size_t i = 0; i < input.size(); ++i)
size += GetSerializedSize_(input[i]);
return size;
}
template <bool element_is_nullable, typename ElementValidateParams>
- static void SerializeElements(
- Array<String> input,
- Buffer* buf,
- Array_Data<String_Data*>* output) {
- MOJO_COMPILE_ASSERT(
+ static void SerializeElements(Array<String> input,
+ Buffer* buf,
+ Array_Data<String_Data*>* output) {
+ static_assert(
(IsSame<ElementValidateParams,
- ArrayValidateParams<0, false, NoValidateParams> >::value),
- String_type_has_unexpected_array_validate_params);
+ ArrayValidateParams<0, false, NoValidateParams>>::value),
+ "String type has unexpected array validate params");
for (size_t i = 0; i < input.size(); ++i) {
String_Data* element;
"null in array expecting valid strings", input.size(), i));
}
}
- static void DeserializeElements(
- Array_Data<String_Data*>* input, Array<String>* output) {
+ static void DeserializeElements(Array_Data<String_Data*>* input,
+ Array<String>* output) {
Array<String> result(input->size());
for (size_t i = 0; i < input->size(); ++i)
Deserialize_(input->at(i), &result[i]);
}
template <typename ValidateParams, typename E, typename F>
-inline void SerializeArray_(Array<E> input, internal::Buffer* buf,
+inline void SerializeArray_(Array<E> input,
+ internal::Buffer* buf,
internal::Array_Data<F>** output) {
if (input) {
MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
internal::VALIDATION_ERROR_UNEXPECTED_ARRAY_HEADER,
internal::MakeMessageWithExpectedArraySize(
"fixed-size array has wrong number of elements",
- input.size(), ValidateParams::expected_num_elements));
+ input.size(),
+ ValidateParams::expected_num_elements));
internal::Array_Data<F>* result =
internal::Array_Data<F>::New(input.size(), buf);
internal::ArraySerializer<E, F>::template SerializeElements<
ValidateParams::element_is_nullable,
typename ValidateParams::ElementValidateParams>(
- internal::Forward(input), buf, result);
+ internal::Forward(input), buf, result);
}
*output = result;
} else {
- *output = NULL;
+ *output = nullptr;
}
}
projects / platform / framework / web / crosswalk.git / blobdiff