mojo::ArrayTraits: Add Support for Iterators

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 <stddef.h>
 #include <string.h>  // For |memcpy()|.
 
@@ skipping 38 matching lines @@
                  ? ArraySerializerType::POINTER
                  : (IsHandle<DataElement>::value
                         ? ArraySerializerType::HANDLE
                         : (std::is_same<Element, bool>::value
                                ? ArraySerializerType::BOOLEAN
                                : (std::is_enum<Element>::value
                                       ? ArraySerializerType::ENUM
                                       : ArraySerializerType::POD))));
 };
 
+template <
+    typename Traits,
+    typename MaybeConstUserType,
+    typename IteratorType,
+    typename std::enable_if<
+        HasGetBeginMethod<Traits, MaybeConstUserType>::value>::type* = nullptr>
+static decltype(Traits::GetValue(std::declval<IteratorType&>())) GetNextHelper(
+    MaybeConstUserType& input,
+    IteratorType& iter) {
+  auto& value = Traits::GetValue(iter);

[yzshen1, 2016/06/10 16:21:32]

Please update the comments in array_traits.h

[Fady Samuel, 2016/06/10 19:05:33]

Done.

+  Traits::AdvanceIterator(iter);
+  return value;
+}
+
+template <
+    typename Traits,
+    typename MaybeConstUserType,
+    typename IteratorType,
+    typename std::enable_if<
+        !HasGetBeginMethod<Traits, MaybeConstUserType>::value>::type* = nullptr>
+static decltype(Traits::GetAt(std::declval<MaybeConstUserType&>(), 0))
+GetNextHelper(MaybeConstUserType& input, size_t& index) {
+  DCHECK_LT(index, Traits::GetSize(input));
+  return Traits::GetAt(input, index++);
+}
+
 // Used as the UserTypeReader template parameter of ArraySerializer.
 template <typename MaybeConstUserType>
 class ArrayReader {

[yzshen1, 2016/06/10 16:21:32]

Maybe we should change this to ArrayIterator and let DeserializeElements
constructs an ArrayIterator after Resize()?

That way there is no need to extract GetNextHelper as standalone functions. And
the callsites seem more consistent too.

[Fady Samuel, 2016/06/10 19:05:33]

Done. I'm not sure how to get rid of GetNextHelper. I *think* we need it for
SFINAE. Also, I tried making it a static private method and failed. I wasn't
able to get it to compile, but my C++11 template knowledge is limited.

  public:
   using UserType = typename std::remove_const<MaybeConstUserType>::type;
   using Traits = ArrayTraits<UserType>;
+  using IteratorType = decltype(
+      CallGetBeginIfExists<Traits>(std::declval<MaybeConstUserType&>()));
 
-  explicit ArrayReader(MaybeConstUserType& input) : input_(input) {}
+  explicit ArrayReader(MaybeConstUserType& input)
+      : input_(input), iter_(CallGetBeginIfExists<Traits>(input)) {}
   ~ArrayReader() {}
 
   size_t GetSize() const { return Traits::GetSize(input_); }
 
-  using GetNextResult =
-      decltype(Traits::GetAt(std::declval<MaybeConstUserType&>(), 0));
-  GetNextResult GetNext() {
-    DCHECK_LT(index_, Traits::GetSize(input_));
-    return Traits::GetAt(input_, index_++);
+  decltype(GetNextHelper<Traits, MaybeConstUserType, IteratorType>(
+      std::declval<MaybeConstUserType&>(),
+      std::declval<IteratorType&>()))
+  GetNext() {
+    return GetNextHelper<Traits, MaybeConstUserType, IteratorType>(input_,
+                                                                   iter_);
   }
 
   using GetDataIfExistsResult = decltype(
       CallGetDataIfExists<Traits>(std::declval<MaybeConstUserType&>()));
   GetDataIfExistsResult GetDataIfExists() {
     return CallGetDataIfExists<Traits>(input_);
   }
 
  private:
   MaybeConstUserType& input_;
-  size_t index_ = 0;
+  IteratorType iter_;
 };
 
 // ArraySerializer is also used to serialize map keys and values. Therefore, it
 // has a UserTypeReader parameter which is an adaptor for reading to hide the
 // difference between ArrayTraits and MapTraits.
 template <typename MojomType,
           typename MaybeConstUserType,
           typename UserTypeReader,
           ArraySerializerType type = GetArraySerializerType<MojomType>::value>
 struct ArraySerializer;
 
 // Handles serialization and deserialization of arrays of pod types.
 template <typename MojomType,
           typename MaybeConstUserType,
           typename UserTypeReader>
 struct ArraySerializer<MojomType,
                        MaybeConstUserType,
                        UserTypeReader,
                        ArraySerializerType::POD> {
   using UserType = typename std::remove_const<MaybeConstUserType>::type;
   using Data = typename MojomType::Data_;
   using DataElement = typename Data::Element;
   using Element = typename MojomType::Element;
   using Traits = ArrayTraits<UserType>;
+  using IteratorType =
+      decltype(CallGetBeginIfExists<Traits>(std::declval<UserType&>()));
 
   static_assert(std::is_same<Element, DataElement>::value,
                 "Incorrect array serializer");
   static_assert(std::is_same<Element, typename Traits::Element>::value,
                 "Incorrect array serializer");
 
   static size_t GetSerializedSize(UserTypeReader* input,
                                   SerializationContext* context) {
     return sizeof(Data) + Align(input->GetSize() * sizeof(DataElement));
   }
@@ skipping 24 matching lines @@
   static bool DeserializeElements(Data* input,
                                   UserType* output,
                                   SerializationContext* context) {
     if (!Traits::Resize(*output, input->size()))
       return false;
     if (input->size()) {
       auto data = CallGetDataIfExists<Traits>(*output);
       if (data) {
         memcpy(data, input->storage(), input->size() * sizeof(DataElement));
       } else {
-        for (size_t i = 0; i < input->size(); ++i)
-          Traits::GetAt(*output, i) = input->at(i);
+        IteratorType iter = CallGetBeginIfExists<Traits>(*output);
+        for (size_t i = 0; i < input->size(); ++i) {
+          GetNextHelper<Traits, MaybeConstUserType, IteratorType>(
+              *output, iter) = input->at(i);
+        }
       }
     }
     return true;
   }
 };
 
 // Handles serialization and deserialization of arrays of enum types.
 template <typename MojomType,
           typename MaybeConstUserType,
           typename UserTypeReader>
@@ skipping 47 matching lines @@
 template <typename MojomType,
           typename MaybeConstUserType,
           typename UserTypeReader>
 struct ArraySerializer<MojomType,
                        MaybeConstUserType,
                        UserTypeReader,
                        ArraySerializerType::BOOLEAN> {
   using UserType = typename std::remove_const<MaybeConstUserType>::type;
   using Traits = ArrayTraits<UserType>;
   using Data = typename MojomType::Data_;
+  using IteratorType =
+      decltype(CallGetBeginIfExists<Traits>(std::declval<UserType&>()));
 
   static_assert(std::is_same<bool, typename UserType::Element>::value,
                 "Incorrect array serializer");
 
   static size_t GetSerializedSize(UserTypeReader* input,
                                   SerializationContext* context) {
     return sizeof(Data) + Align((input->GetSize() + 7) / 8);
   }
 
   static void SerializeElements(UserTypeReader* input,
                                 Buffer* buf,
                                 Data* output,
                                 const ContainerValidateParams* validate_params,
                                 SerializationContext* context) {
     DCHECK(!validate_params->element_is_nullable)
         << "Primitive type should be non-nullable";
     DCHECK(!validate_params->element_validate_params)
         << "Primitive type should not have array validate params";
 
     size_t size = input->GetSize();
     for (size_t i = 0; i < size; ++i)
       output->at(i) = input->GetNext();
   }
   static bool DeserializeElements(Data* input,
                                   UserType* output,
                                   SerializationContext* context) {
     if (!Traits::Resize(*output, input->size()))
       return false;
-    for (size_t i = 0; i < input->size(); ++i)
-      Traits::GetAt(*output, i) = input->at(i);
+    IteratorType iter = CallGetBeginIfExists<Traits>(*output);
+    for (size_t i = 0; i < input->size(); ++i) {
+      GetNextHelper<Traits, MaybeConstUserType, IteratorType>(*output, iter) =
+          input->at(i);
+    }
     return true;
   }
 };
 
 // Serializes and deserializes arrays of handles.
 template <typename MojomType,
           typename MaybeConstUserType,
           typename UserTypeReader>
 struct ArraySerializer<MojomType,
                        MaybeConstUserType,
@@ skipping 53 matching lines @@
           typename UserTypeReader>
 struct ArraySerializer<MojomType,
                        MaybeConstUserType,
                        UserTypeReader,
                        ArraySerializerType::POINTER> {
   using UserType = typename std::remove_const<MaybeConstUserType>::type;
   using Data = typename MojomType::Data_;
   using DataElement = typename Data::Element;
   using Element = typename MojomType::Element;
   using Traits = ArrayTraits<UserType>;
+  using IteratorType =
+      decltype(CallGetBeginIfExists<Traits>(std::declval<UserType&>()));
 
   static size_t GetSerializedSize(UserTypeReader* input,
                                   SerializationContext* context) {
     size_t element_count = input->GetSize();
     size_t size =
         sizeof(Data) +
         element_count *
             sizeof(Pointer<typename std::remove_pointer<DataElement>::type>);
     for (size_t i = 0; i < element_count; ++i)
       size += PrepareToSerialize<Element>(input->GetNext(), context);
@@ skipping 18 matching lines @@
           MakeMessageWithArrayIndex("null in array expecting valid pointers",
                                     size, i));
     }
   }
   static bool DeserializeElements(Data* input,
                                   UserType* output,
                                   SerializationContext* context) {
     bool success = true;
     if (!Traits::Resize(*output, input->size()))
       return false;
+    IteratorType iter = CallGetBeginIfExists<Traits>(*output);
     for (size_t i = 0; i < input->size(); ++i) {
       // Note that we rely on complete deserialization taking place in order to
       // transfer ownership of all encoded handles. Therefore we don't
       // short-circuit on failure here.
-      if (!Deserialize<Element>(input->at(i), &Traits::GetAt(*output, i),
-                                context)) {
+      if (!Deserialize<Element>(
+              input->at(i),
+              &GetNextHelper<Traits, MaybeConstUserType, IteratorType>(*output,
+                                                                       iter),
+              context)) {
         success = false;
       }
     }
     return success;
   }
 
  private:
   template <typename T,
             bool is_array_or_map = IsSpecializationOf<Array, T>::value ||
                                    IsSpecializationOf<Map, T>::value>
@@ skipping 27 matching lines @@
           typename MaybeConstUserType,
           typename UserTypeReader>
 struct ArraySerializer<MojomType,
                        MaybeConstUserType,
                        UserTypeReader,
                        ArraySerializerType::UNION> {
   using UserType = typename std::remove_const<MaybeConstUserType>::type;
   using Data = typename MojomType::Data_;
   using Element = typename MojomType::Element;
   using Traits = ArrayTraits<UserType>;
+  using IteratorType =
+      decltype(CallGetBeginIfExists<Traits>(std::declval<UserType&>()));
 
   static_assert(std::is_same<typename MojomType::Element,
                              typename Traits::Element>::value,
                 "Incorrect array serializer");
 
   static size_t GetSerializedSize(UserTypeReader* input,
                                   SerializationContext* context) {
     size_t element_count = input->GetSize();
     size_t size = sizeof(Data);
     for (size_t i = 0; i < element_count; ++i) {
@@ skipping 20 matching lines @@
                                     size, i));
     }
   }
 
   static bool DeserializeElements(Data* input,
                                   UserType* output,
                                   SerializationContext* context) {
     bool success = true;
     if (!Traits::Resize(*output, input->size()))
       return false;
+    IteratorType iter = CallGetBeginIfExists<Traits>(*output);
     for (size_t i = 0; i < input->size(); ++i) {
       // Note that we rely on complete deserialization taking place in order to
       // transfer ownership of all encoded handles. Therefore we don't
       // short-circuit on failure here.
-      if (!Deserialize<Element>(&input->at(i), &Traits::GetAt(*output, i),
-                                context)) {
+      if (!Deserialize<Element>(
+              &input->at(i),
+              &GetNextHelper<Traits, MaybeConstUserType, IteratorType>(*output,
+                                                                       iter),
+              context)) {
         success = false;
       }
     }
     return success;
   }
 };
 
 template <typename Element, typename MaybeConstUserType>
 struct Serializer<Array<Element>, MaybeConstUserType> {
   using UserType = typename std::remove_const<MaybeConstUserType>::type;
@@ skipping 41 matching lines @@
     if (!input)
       return CallSetToNullIfExists<Traits>(output);
     return Impl::DeserializeElements(input, output, context);
   }
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_