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

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_
   6 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_
   7
   8 #include <string.h>  // For |memcpy()|.
   9
  10 #include <vector>
  11
  12 #include "mojo/public/cpp/bindings/lib/array_internal.h"
  13 #include "mojo/public/cpp/bindings/lib/string_serialization.h"
  14
  15 namespace mojo {
  16
  17 template <typename E>
  18 inline size_t GetSerializedSize_(const Array<E>& input);
  19
  20 template <typename E, typename F>
  21 inline void Serialize_(Array<E> input, internal::Buffer* buf,
  22                        internal::Array_Data<F>** output);
  23 template <typename E, typename F>
  24 inline void Deserialize_(internal::Array_Data<F>* data, Array<E>* output);
  25
  26 namespace internal {
  27
  28 template <typename E, typename F, bool move_only = IsMoveOnlyType<E>::value>
  29 struct ArraySerializer;
  30
  31 template <typename E, typename F> struct ArraySerializer<E, F, false> {
  32   MOJO_COMPILE_ASSERT(sizeof(E) == sizeof(F), wrong_array_serializer);
  33   static size_t GetSerializedSize(const Array<E>& input) {
  34     return sizeof(Array_Data<F>) + Align(input.size() * sizeof(E));
  35   }
  36   static void SerializeElements(
  37       Array<E> input, Buffer* buf, Array_Data<F>* output) {
  38     memcpy(output->storage(), &input.storage()[0], input.size() * sizeof(E));
  39   }
  40   static void DeserializeElements(
  41       Array_Data<F>* input, Array<E>* output) {
  42     std::vector<E> result(input->size());
  43     memcpy(&result[0], input->storage(), input->size() * sizeof(E));
  44     output->Swap(&result);
  45   }
  46 };
  47
  48 template <> struct ArraySerializer<bool, bool, false> {
  49   static size_t GetSerializedSize(const Array<bool>& input) {
  50     return sizeof(Array_Data<bool>) + Align((input.size() + 7) / 8);
  51   }
  52   static void SerializeElements(
  53       Array<bool> input, Buffer* buf, Array_Data<bool>* output) {
  54     // TODO(darin): Can this be a memcpy somehow instead of a bit-by-bit copy?
  55     for (size_t i = 0; i < input.size(); ++i)
  56       output->at(i) = input[i];
  57   }
  58   static void DeserializeElements(
  59       Array_Data<bool>* input, Array<bool>* output) {
  60     Array<bool> result(input->size());
  61     // TODO(darin): Can this be a memcpy somehow instead of a bit-by-bit copy?
  62     for (size_t i = 0; i < input->size(); ++i)
  63       result.at(i) = input->at(i);
  64     output->Swap(&result);
  65   }
  66 };
  67
  68 template <typename H> struct ArraySerializer<ScopedHandleBase<H>, H, true> {
  69   static size_t GetSerializedSize(const Array<ScopedHandleBase<H> >& input) {
  70     return sizeof(Array_Data<H>) + Align(input.size() * sizeof(H));
  71   }
  72   static void SerializeElements(
  73       Array<ScopedHandleBase<H> > input,
  74       Buffer* buf,
  75       Array_Data<H>* output) {
  76     for (size_t i = 0; i < input.size(); ++i)
  77       output->at(i) = input[i].release();  // Transfer ownership of the handle.
  78   }
  79   static void DeserializeElements(
  80       Array_Data<H>* input, Array<ScopedHandleBase<H> >* output) {
  81     Array<ScopedHandleBase<H> > result(input->size());
  82     for (size_t i = 0; i < input->size(); ++i)
  83       result.at(i) = MakeScopedHandle(FetchAndReset(&input->at(i)));
  84     output->Swap(&result);
  85   }
  86 };
  87
  88 template <typename S> struct ArraySerializer<S, typename S::Data_*, true> {
  89   static size_t GetSerializedSize(const Array<S>& input) {
  90     size_t size = sizeof(Array_Data<typename S::Data_*>) +
  91         input.size() * sizeof(internal::StructPointer<typename S::Data_>);
  92     for (size_t i = 0; i < input.size(); ++i)
  93       size += GetSerializedSize_(input[i]);
  94     return size;
  95   }
  96   static void SerializeElements(
  97       Array<S> input,
  98       Buffer* buf,
  99       Array_Data<typename S::Data_*>* output) {
 100     for (size_t i = 0; i < input.size(); ++i) {
 101       typename S::Data_* element;
 102       Serialize_(input[i].Pass(), buf, &element);
 103       output->at(i) = element;
 104     }
 105   }
 106   static void DeserializeElements(
 107       Array_Data<typename S::Data_*>* input, Array<S>* output) {
 108     Array<S> result(input->size());
 109     for (size_t i = 0; i < input->size(); ++i) {
 110       S element;
 111       Deserialize_(input->at(i), &element);
 112       result[i] = element.Pass();
 113     }
 114     output->Swap(&result);
 115   }
 116 };
 117
 118 template <> struct ArraySerializer<String, String_Data*, false> {
 119   static size_t GetSerializedSize(const Array<String>& input) {
 120     size_t size = sizeof(Array_Data<String_Data*>) +
 121         input.size() * sizeof(internal::StringPointer);
 122     for (size_t i = 0; i < input.size(); ++i)
 123       size += GetSerializedSize_(input[i]);
 124     return size;
 125   }
 126   static void SerializeElements(
 127       Array<String> input,
 128       Buffer* buf,
 129       Array_Data<String_Data*>* output) {
 130     for (size_t i = 0; i < input.size(); ++i) {
 131       String_Data* element;
 132       Serialize_(input[i], buf, &element);
 133       output->at(i) = element;
 134     }
 135   }
 136   static void DeserializeElements(
 137       Array_Data<String_Data*>* input, Array<String>* output) {
 138     Array<String> result(input->size());
 139     for (size_t i = 0; i < input->size(); ++i)
 140       Deserialize_(input->at(i), &result[i]);
 141     output->Swap(&result);
 142   }
 143 };
 144
 145 }  // namespace internal
 146
 147 template <typename E>
 148 inline size_t GetSerializedSize_(const Array<E>& input) {
 149   if (!input)
 150     return 0;
 151   typedef typename internal::WrapperTraits<E>::DataType F;
 152   return internal::ArraySerializer<E, F>::GetSerializedSize(input);
 153 }
 154
 155 template <typename E, typename F>
 156 inline void Serialize_(Array<E> input, internal::Buffer* buf,
 157                        internal::Array_Data<F>** output) {
 158   if (input) {
 159     internal::Array_Data<F>* result =
 160         internal::Array_Data<F>::New(input.size(), buf);
 161     internal::ArraySerializer<E, F>::SerializeElements(
 162         internal::Forward(input), buf, result);
 163     *output = result;
 164   } else {
 165     *output = NULL;
 166   }
 167 }
 168
 169 template <typename E, typename F>
 170 inline void Deserialize_(internal::Array_Data<F>* input,
 171                          Array<E>* output) {
 172   if (input) {
 173     internal::ArraySerializer<E, F>::DeserializeElements(input, output);
 174   } else {
 175     output->reset();
 176   }
 177 }
 178
 179 }  // namespace mojo
 180
 181 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_