Implement unions as members of structs.

mojo/public/cpp/bindings/lib/array_serialization.h

 // 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_ARRAY_SERIALIZATION_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_
 
 #include <string.h>  // For |memcpy()|.
 
 #include <vector>
@@ skipping 27 matching lines @@
 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);
 
 namespace internal {
 
-template <typename E, typename F, bool move_only = IsMoveOnlyType<E>::value>
+template <typename E,
+          typename F,
+          bool move_only = IsMoveOnlyType<E>::value,
+          bool is_union = internal::IsWrappedUnionPtr<E>::value>

[yzshen1, 2015/02/25 21:07:00]

nit: internal:: is not needed.

[azani, 2015/03/03 00:44:15]

Done.

 struct ArraySerializer;
 
 template <typename E, typename F>
-struct ArraySerializer<E, F, false> {
+struct ArraySerializer<E, F, false, 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) {
     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");
 
     if (input.size())
       memcpy(output->storage(), &input.storage()[0], input.size() * sizeof(E));
   }
   static void DeserializeElements(Array_Data<F>* input, Array<E>* output) {
     std::vector<E> result(input->size());
     if (input->size())
       memcpy(&result[0], input->storage(), input->size() * sizeof(E));
     output->Swap(&result);
   }
 };
 
 template <>
-struct ArraySerializer<bool, bool, false> {
+struct ArraySerializer<bool, bool, false, 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) {
     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) {
     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)
       result.at(i) = input->at(i);
     output->Swap(&result);
   }
 };
 
 template <typename H>
-struct ArraySerializer<ScopedHandleBase<H>, H, true> {
+struct ArraySerializer<ScopedHandleBase<H>, H, true, false> {
   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,
                                 Buffer* buf,
                                 Array_Data<H>* output) {
     static_assert((IsSame<ElementValidateParams, NoValidateParams>::value),
                   "Handle type should not have array validate params");
 
@@ skipping 18 matching lines @@
 };
 
 // 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> {
+                       true,
+                       false> {
   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<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>
@@ skipping 48 matching lines @@
   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 <typename U, typename U_Data>

[yzshen1, 2015/02/25 21:06:59]

nit: Please comment about what is this specialization for.
(It would be nice if we do the same for others as well.)

[azani, 2015/03/03 00:44:15]

Done.

+struct ArraySerializer<U, U_Data, true, true> {
+  static size_t GetSerializedSize(const Array<U>& input) {
+    size_t size = sizeof(Array_Data<U_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<U> input,
+                                Buffer* buf,
+                                Array_Data<U_Data>* output) {
+    for (size_t i = 0; i < input.size(); ++i) {
+      U_Data* result = output->storage() + i;
+      Serialize_(input[i].Pass(), buf, &result);

[yzshen1, 2015/02/25 21:07:00]

I think maybe we should make a different SerializeUnion_ signature for unions,
which takes a boolean indicating whether |*result| is already allocated.

[azani, 2015/03/03 00:44:15]

Done.

+    }

[yzshen1, 2015/02/25 21:07:00]

Please look at line 168: we need to do similar things here (DCHECK that an
unexpected null pointer in an array which is supported to store non-null
pointers.)

[azani, 2015/03/03 00:44:15]

Done.

+  }
+
+  static void DeserializeElements(Array_Data<U_Data>* input, Array<U>* output) {
+    Array<U> result(input->size());
+    for (size_t i = 0; i < input->size(); ++i) {
+      U element;
+      Deserialize_(&input->at(i), &element);
+      result[i] = element.Pass();
+    }
+    output->Swap(&result);
+  }
+};
+/*

[yzshen1, 2015/02/25 21:07:00]

If something is not useful, please remove it instead of commenting it out.

[azani, 2015/03/03 00:44:15]

Done.

+template <typename U>
+struct ArraySerializer<U,
+                       typename internal::EnableIf<
+                         internal::IsWrappedUnionPtr<U>::value,
+                         typename internal::WrapperTraits<U>::DataType>::type,
+true> {
+  static const int i = 10;
+  static size_t GetSerializedSize(const Array<U>& input) {
+    return 0;
+  }
+};
+*/
+
 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);
     for (size_t i = 0; i < input.size(); ++i)
       size += GetSerializedSize_(input[i]);
     return size;
   }
   template <bool element_is_nullable, typename ElementValidateParams>
@@ skipping 68 matching lines @@
   if (input) {
     internal::ArraySerializer<E, F>::DeserializeElements(input, output);
   } else {
     output->reset();
   }
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_