For reference only.

mojo/public/cpp/bindings/gen/sample_service.mojom.cc

+// Copyright 2013 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.
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+#endif
+
+#include "mojo/public/interfaces/bindings/tests/sample_service.mojom.h"
+
+#include "mojo/public/cpp/bindings/lib/array_serialization.h"
+#include "mojo/public/cpp/bindings/lib/bindings_serialization.h"
+#include "mojo/public/cpp/bindings/lib/string_serialization.h"
+#include "mojo/public/cpp/bindings/lib/message_builder.h"
+namespace sample {
+
+const uint8_t kThree = 3;
+
+namespace internal {
+namespace {
+
+#pragma pack(push, 1)
+const uint32_t kService_Frobinate_Name = 0;
+
+class Service_Frobinate_Params_Data {
+ public:
+  static Service_Frobinate_Params_Data* New(mojo::internal::Buffer* buf) {
+    return new (buf->Allocate(sizeof(Service_Frobinate_Params_Data)))
+        Service_Frobinate_Params_Data();
+  }
+
+  mojo::internal::StructHeader header_;
+
+  mojo::internal::StructPointer<internal::Foo_Data> foo;
+  int32_t baz;
+  mojo::MessagePipeHandle port;
+
+  void EncodePointersAndHandles(std::vector<mojo::Handle>* handles) {
+    mojo::internal::Encode(&foo, handles);
+    mojo::internal::EncodeHandle(&port, handles);
+  }
+
+  bool DecodePointersAndHandles(mojo::Message* message) {
+    if (!mojo::internal::Decode(&foo, message))
+      return false;
+    if (!mojo::internal::DecodeHandle(&port,
+                                      message->mutable_handles()))
+      return false;
+    return true;
+  }
+
+ private:
+  Service_Frobinate_Params_Data() {
+    header_.num_bytes = sizeof(*this);
+    header_.num_fields = 3;
+  }
+};
+MOJO_COMPILE_ASSERT(sizeof(Service_Frobinate_Params_Data) == 24,
+                    bad_sizeof_Service_Frobinate_Params_Data);
+
+const uint32_t kServiceClient_DidFrobinate_Name = 0;
+
+class ServiceClient_DidFrobinate_Params_Data {
+ public:
+  static ServiceClient_DidFrobinate_Params_Data* New(mojo::internal::Buffer* buf) {
+    return new (buf->Allocate(sizeof(ServiceClient_DidFrobinate_Params_Data)))
+        ServiceClient_DidFrobinate_Params_Data();
+  }
+
+  mojo::internal::StructHeader header_;
+
+  int32_t result;
+  uint8_t padfinal_[4];
+
+  void EncodePointersAndHandles(std::vector<mojo::Handle>* handles) {
+    
+  }
+
+  bool DecodePointersAndHandles(mojo::Message* message) {
+    
+    return true;
+  }
+
+ private:
+  ServiceClient_DidFrobinate_Params_Data() {
+    header_.num_bytes = sizeof(*this);
+    header_.num_fields = 1;
+  }
+};
+MOJO_COMPILE_ASSERT(sizeof(ServiceClient_DidFrobinate_Params_Data) == 16,
+                    bad_sizeof_ServiceClient_DidFrobinate_Params_Data);
+
+const uint32_t kPort_PostMessage_Name = 0;
+
+class Port_PostMessage_Params_Data {
+ public:
+  static Port_PostMessage_Params_Data* New(mojo::internal::Buffer* buf) {
+    return new (buf->Allocate(sizeof(Port_PostMessage_Params_Data)))
+        Port_PostMessage_Params_Data();
+  }
+
+  mojo::internal::StructHeader header_;
+
+  mojo::internal::StringPointer message_text;
+  mojo::MessagePipeHandle port;
+  uint8_t padfinal_[4];
+
+  void EncodePointersAndHandles(std::vector<mojo::Handle>* handles) {
+    mojo::internal::Encode(&message_text, handles);
+    mojo::internal::EncodeHandle(&port, handles);
+  }
+
+  bool DecodePointersAndHandles(mojo::Message* message) {
+    if (!mojo::internal::Decode(&message_text, message))
+      return false;
+    if (!mojo::internal::DecodeHandle(&port,
+                                      message->mutable_handles()))
+      return false;
+    return true;
+  }
+
+ private:
+  Port_PostMessage_Params_Data() {
+    header_.num_bytes = sizeof(*this);
+    header_.num_fields = 2;
+  }
+};
+MOJO_COMPILE_ASSERT(sizeof(Port_PostMessage_Params_Data) == 24,
+                    bad_sizeof_Port_PostMessage_Params_Data);
+
+
+#pragma pack(pop)
+
+}  // namespace
+
+
+// static
+Bar_Data* Bar_Data::New(mojo::internal::Buffer* buf) {
+  return new (buf->Allocate(sizeof(Bar_Data))) Bar_Data();
+}
+
+Bar_Data::Bar_Data() {
+  header_.num_bytes = sizeof(*this);
+  header_.num_fields = 4;
+}
+
+void Bar_Data::EncodePointersAndHandles(
+    std::vector<mojo::Handle>* handles) {
+  
+}
+
+bool Bar_Data::DecodePointersAndHandles(mojo::Message* message) {
+  
+  return true;
+}
+
+
+// static
+Foo_Data* Foo_Data::New(mojo::internal::Buffer* buf) {
+  return new (buf->Allocate(sizeof(Foo_Data))) Foo_Data();
+}
+
+Foo_Data::Foo_Data() {
+  header_.num_bytes = sizeof(*this);
+  header_.num_fields = 14;
+}
+
+void Foo_Data::EncodePointersAndHandles(
+    std::vector<mojo::Handle>* handles) {
+  mojo::internal::Encode(&bar, handles);
+  mojo::internal::Encode(&data, handles);
+  mojo::internal::Encode(&extra_bars, handles);
+  mojo::internal::Encode(&name, handles);
+  mojo::internal::Encode(&input_streams, handles);
+  mojo::internal::Encode(&output_streams, handles);
+  mojo::internal::Encode(&array_of_array_of_bools, handles);
+  mojo::internal::Encode(&multi_array_of_strings, handles);
+  mojo::internal::EncodeHandle(&source, handles);
+}
+
+bool Foo_Data::DecodePointersAndHandles(mojo::Message* message) {
+  if (!mojo::internal::Decode(&bar, message))
+    return false;
+  if (!mojo::internal::Decode(&data, message))
+    return false;
+  if (!mojo::internal::Decode(&extra_bars, message))
+    return false;
+  if (!mojo::internal::Decode(&name, message))
+    return false;
+  if (!mojo::internal::Decode(&input_streams, message))
+    return false;
+  if (!mojo::internal::Decode(&output_streams, message))
+    return false;
+  if (!mojo::internal::Decode(&array_of_array_of_bools, message))
+    return false;
+  if (!mojo::internal::Decode(&multi_array_of_strings, message))
+    return false;
+  if (!mojo::internal::DecodeHandle(&source,
+                                    message->mutable_handles()))
+    return false;
+  return true;
+}
+
+
+// static
+DefaultsTestInner_Data* DefaultsTestInner_Data::New(mojo::internal::Buffer* buf) {
+  return new (buf->Allocate(sizeof(DefaultsTestInner_Data))) DefaultsTestInner_Data();
+}
+
+DefaultsTestInner_Data::DefaultsTestInner_Data() {
+  header_.num_bytes = sizeof(*this);
+  header_.num_fields = 1;
+}
+
+void DefaultsTestInner_Data::EncodePointersAndHandles(
+    std::vector<mojo::Handle>* handles) {
+  
+}
+
+bool DefaultsTestInner_Data::DecodePointersAndHandles(mojo::Message* message) {
+  
+  return true;
+}
+
+
+// static
+DefaultsTest_Data* DefaultsTest_Data::New(mojo::internal::Buffer* buf) {
+  return new (buf->Allocate(sizeof(DefaultsTest_Data))) DefaultsTest_Data();
+}
+
+DefaultsTest_Data::DefaultsTest_Data() {
+  header_.num_bytes = sizeof(*this);
+  header_.num_fields = 21;
+}
+
+void DefaultsTest_Data::EncodePointersAndHandles(
+    std::vector<mojo::Handle>* handles) {
+  mojo::internal::Encode(&a18, handles);
+  mojo::internal::Encode(&a19, handles);
+  mojo::internal::Encode(&a20, handles);
+}
+
+bool DefaultsTest_Data::DecodePointersAndHandles(mojo::Message* message) {
+  if (!mojo::internal::Decode(&a18, message))
+    return false;
+  if (!mojo::internal::Decode(&a19, message))
+    return false;
+  if (!mojo::internal::Decode(&a20, message))
+    return false;
+  return true;
+}
+
+
+// static
+StructWithHoleV1_Data* StructWithHoleV1_Data::New(mojo::internal::Buffer* buf) {
+  return new (buf->Allocate(sizeof(StructWithHoleV1_Data))) StructWithHoleV1_Data();
+}
+
+StructWithHoleV1_Data::StructWithHoleV1_Data() {
+  header_.num_bytes = sizeof(*this);
+  header_.num_fields = 2;
+}
+
+void StructWithHoleV1_Data::EncodePointersAndHandles(
+    std::vector<mojo::Handle>* handles) {
+  
+}
+
+bool StructWithHoleV1_Data::DecodePointersAndHandles(mojo::Message* message) {
+  
+  return true;
+}
+
+
+// static
+StructWithHoleV2_Data* StructWithHoleV2_Data::New(mojo::internal::Buffer* buf) {
+  return new (buf->Allocate(sizeof(StructWithHoleV2_Data))) StructWithHoleV2_Data();
+}
+
+StructWithHoleV2_Data::StructWithHoleV2_Data() {
+  header_.num_bytes = sizeof(*this);
+  header_.num_fields = 3;
+}
+
+void StructWithHoleV2_Data::EncodePointersAndHandles(
+    std::vector<mojo::Handle>* handles) {
+  
+}
+
+bool StructWithHoleV2_Data::DecodePointersAndHandles(mojo::Message* message) {
+  
+  return true;
+}
+
+
+}  // namespace internal
+
+
+const char* Foo::kFooby = "Fooby";
+
+
+
+// static
+BarPtr Bar::New() {
+  BarPtr rv;
+  mojo::internal::StructHelper<Bar>::Initialize(&rv);
+  return rv.Pass();
+}
+
+Bar::Bar()
+    : alpha((0x100-1)),
+      beta(),
+      gamma(),
+      type(Bar::TYPE_VERTICAL) {
+}
+
+Bar::~Bar() {
+}
+// static
+FooPtr Foo::New() {
+  FooPtr rv;
+  mojo::internal::StructHelper<Foo>::Initialize(&rv);
+  return rv.Pass();
+}
+
+Foo::Foo()
+    : name(Foo::kFooby),
+      x(),
+      y(),
+      a(true),
+      b(),
+      c(),
+      bar(),
+      extra_bars(),
+      data(),
+      source(),
+      input_streams(),
+      output_streams(),
+      array_of_array_of_bools(),
+      multi_array_of_strings() {
+}
+
+Foo::~Foo() {
+}
+// static
+DefaultsTestInnerPtr DefaultsTestInner::New() {
+  DefaultsTestInnerPtr rv;
+  mojo::internal::StructHelper<DefaultsTestInner>::Initialize(&rv);
+  return rv.Pass();
+}
+
+DefaultsTestInner::DefaultsTestInner()
+    : x(123) {
+}
+
+DefaultsTestInner::~DefaultsTestInner() {
+}
+// static
+DefaultsTestPtr DefaultsTest::New() {
+  DefaultsTestPtr rv;
+  mojo::internal::StructHelper<DefaultsTest>::Initialize(&rv);
+  return rv.Pass();
+}
+
+DefaultsTest::DefaultsTest()
+    : a0(-12),
+      a1(12),
+      a2(1234),
+      a3(34567),
+      a4(123456),
+      a5(),
+      a6(111111111111),
+      a7(),
+      a8(0x12345),
+      a9(-0x12345),
+      a10(+1234),
+      a11(true),
+      a12(false),
+      a13(123.25),
+      a14(1234567890.123),
+      a15(1E10),
+      a16(-1.2E+20),
+      a17(+1.23E-20),
+      a18(),
+      a19(),
+      a20() {
+}
+
+DefaultsTest::~DefaultsTest() {
+}
+// static
+StructWithHoleV1Ptr StructWithHoleV1::New() {
+  StructWithHoleV1Ptr rv;
+  mojo::internal::StructHelper<StructWithHoleV1>::Initialize(&rv);
+  return rv.Pass();
+}
+
+StructWithHoleV1::StructWithHoleV1()
+    : v1(1),
+      v2(2) {
+}
+
+StructWithHoleV1::~StructWithHoleV1() {
+}
+// static
+StructWithHoleV2Ptr StructWithHoleV2::New() {
+  StructWithHoleV2Ptr rv;
+  mojo::internal::StructHelper<StructWithHoleV2>::Initialize(&rv);
+  return rv.Pass();
+}
+
+StructWithHoleV2::StructWithHoleV2()
+    : v1(1),
+      v2(2),
+      v3(3) {
+}
+
+StructWithHoleV2::~StructWithHoleV2() {
+}
+
+
+const uint8_t Service::kFavoriteBaz = 1;
+
+ServiceProxy::ServiceProxy(mojo::MessageReceiver* receiver)
+    : receiver_(receiver) {
+}
+void ServiceProxy::Frobinate(
+    FooPtr in_foo, Service::BazOptions in_baz, PortPtr in_port) {
+  size_t payload_size =
+      mojo::internal::Align(sizeof(internal::Service_Frobinate_Params_Data));
+  if (in_foo)
+    payload_size += GetSerializedSize_(in_foo);
+  mojo::internal::MessageBuilder builder(internal::kService_Frobinate_Name, payload_size);
+
+  internal::Service_Frobinate_Params_Data* params =
+      internal::Service_Frobinate_Params_Data::New(builder.buffer());
+
+  if (in_foo)
+    Serialize_(mojo::internal::Forward(in_foo), builder.buffer(), &params->foo.ptr);
+  params->baz = in_baz;
+  if (!in_port.get()) {
+    params->port = mojo::MessagePipeHandle();
+  } else {
+    // Delegate handle.
+    params->port =
+        in_port.ResetAndReturnMessagePipe().release();
+  }
+  mojo::Message message;
+  params->EncodePointersAndHandles(message.mutable_handles());
+  builder.Finish(&message);
+  bool ok MOJO_ALLOW_UNUSED = receiver_->Accept(&message);
+  // This return value may be ignored as !ok implies the Connector has
+  // encountered an error, which will be visible through other means.
+}
+
+ServiceStub::ServiceStub()
+    : sink_(NULL) {
+}
+
+bool ServiceStub::Accept(mojo::Message* message) {
+  switch (message->header()->name) {
+    case internal::kService_Frobinate_Name: {
+      internal::Service_Frobinate_Params_Data* params =
+          reinterpret_cast<internal::Service_Frobinate_Params_Data*>(
+              message->mutable_payload());
+
+      if (!params->DecodePointersAndHandles(message))
+        return false;
+      
+      FooPtr p1;
+      if (params->foo.ptr)
+        Deserialize_(params->foo.ptr, &p1);
+      sink_->Frobinate(p1.Pass(), static_cast<Service::BazOptions>(params->baz), mojo::MakeProxy<Port>(mojo::MakeScopedHandle(mojo::internal::FetchAndReset(&params->port))));
+      return true;
+    }
+  }
+  return false;
+}
+
+bool ServiceStub::AcceptWithResponder(
+    mojo::Message* message, mojo::MessageReceiver* responder) {
+  switch (message->header()->name) {
+    case internal::kService_Frobinate_Name: {
+      break;
+    }
+  }
+  return false;
+}
+
+ServiceRequestValidator::ServiceRequestValidator(
+    mojo::MessageReceiver* sink) : MessageFilter(sink) {
+}
+
+bool ServiceRequestValidator::Accept(mojo::Message* message) {
+  // TODO(yzshen): implement validation logic.
+  return sink_->Accept(message);
+}
+
+
+
+ServiceClientProxy::ServiceClientProxy(mojo::MessageReceiver* receiver)
+    : receiver_(receiver) {
+}
+void ServiceClientProxy::DidFrobinate(
+    int32_t in_result) {
+  size_t payload_size =
+      mojo::internal::Align(sizeof(internal::ServiceClient_DidFrobinate_Params_Data));
+  mojo::internal::MessageBuilder builder(internal::kServiceClient_DidFrobinate_Name, payload_size);
+
+  internal::ServiceClient_DidFrobinate_Params_Data* params =
+      internal::ServiceClient_DidFrobinate_Params_Data::New(builder.buffer());
+
+  params->result = in_result;
+  mojo::Message message;
+  params->EncodePointersAndHandles(message.mutable_handles());
+  builder.Finish(&message);
+  bool ok MOJO_ALLOW_UNUSED = receiver_->Accept(&message);
+  // This return value may be ignored as !ok implies the Connector has
+  // encountered an error, which will be visible through other means.
+}
+
+ServiceClientStub::ServiceClientStub()
+    : sink_(NULL) {
+}
+
+bool ServiceClientStub::Accept(mojo::Message* message) {
+  switch (message->header()->name) {
+    case internal::kServiceClient_DidFrobinate_Name: {
+      internal::ServiceClient_DidFrobinate_Params_Data* params =
+          reinterpret_cast<internal::ServiceClient_DidFrobinate_Params_Data*>(
+              message->mutable_payload());
+
+      if (!params->DecodePointersAndHandles(message))
+        return false;
+      
+      sink_->DidFrobinate(params->result);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool ServiceClientStub::AcceptWithResponder(
+    mojo::Message* message, mojo::MessageReceiver* responder) {
+  switch (message->header()->name) {
+    case internal::kServiceClient_DidFrobinate_Name: {
+      break;
+    }
+  }
+  return false;
+}
+
+ServiceClientRequestValidator::ServiceClientRequestValidator(
+    mojo::MessageReceiver* sink) : MessageFilter(sink) {
+}
+
+bool ServiceClientRequestValidator::Accept(mojo::Message* message) {
+  // TODO(yzshen): implement validation logic.
+  return sink_->Accept(message);
+}
+
+
+
+PortProxy::PortProxy(mojo::MessageReceiver* receiver)
+    : receiver_(receiver) {
+}
+void PortProxy::PostMessage(
+    const mojo::String& in_message_text, PortPtr in_port) {
+  size_t payload_size =
+      mojo::internal::Align(sizeof(internal::Port_PostMessage_Params_Data));
+  if (in_message_text)
+    payload_size += GetSerializedSize_(in_message_text);
+  mojo::internal::MessageBuilder builder(internal::kPort_PostMessage_Name, payload_size);
+
+  internal::Port_PostMessage_Params_Data* params =
+      internal::Port_PostMessage_Params_Data::New(builder.buffer());
+
+  if (in_message_text)
+    Serialize_(mojo::internal::Forward(in_message_text), builder.buffer(), &params->message_text.ptr);
+  if (!in_port.get()) {
+    params->port = mojo::MessagePipeHandle();
+  } else {
+    // Delegate handle.
+    params->port =
+        in_port.ResetAndReturnMessagePipe().release();
+  }
+  mojo::Message message;
+  params->EncodePointersAndHandles(message.mutable_handles());
+  builder.Finish(&message);
+  bool ok MOJO_ALLOW_UNUSED = receiver_->Accept(&message);
+  // This return value may be ignored as !ok implies the Connector has
+  // encountered an error, which will be visible through other means.
+}
+
+PortStub::PortStub()
+    : sink_(NULL) {
+}
+
+bool PortStub::Accept(mojo::Message* message) {
+  switch (message->header()->name) {
+    case internal::kPort_PostMessage_Name: {
+      internal::Port_PostMessage_Params_Data* params =
+          reinterpret_cast<internal::Port_PostMessage_Params_Data*>(
+              message->mutable_payload());
+
+      if (!params->DecodePointersAndHandles(message))
+        return false;
+      
+      mojo::String p1;
+      if (params->message_text.ptr)
+        Deserialize_(params->message_text.ptr, &p1);
+      sink_->PostMessage(p1, mojo::MakeProxy<Port>(mojo::MakeScopedHandle(mojo::internal::FetchAndReset(&params->port))));
+      return true;
+    }
+  }
+  return false;
+}
+
+bool PortStub::AcceptWithResponder(
+    mojo::Message* message, mojo::MessageReceiver* responder) {
+  switch (message->header()->name) {
+    case internal::kPort_PostMessage_Name: {
+      break;
+    }
+  }
+  return false;
+}
+
+PortRequestValidator::PortRequestValidator(
+    mojo::MessageReceiver* sink) : MessageFilter(sink) {
+}
+
+bool PortRequestValidator::Accept(mojo::Message* message) {
+  // TODO(yzshen): implement validation logic.
+  return sink_->Accept(message);
+}
+size_t GetSerializedSize_(const BarPtr& input) {
+  size_t size = mojo::internal::Align(sizeof(internal::Bar_Data));
+  return size;
+}
+
+void Serialize_(BarPtr input, mojo::internal::Buffer* buf,
+                internal::Bar_Data** output) {
+  internal::Bar_Data* result =
+      internal::Bar_Data::New(buf);
+  result->alpha = input->alpha;
+  result->beta = input->beta;
+  result->gamma = input->gamma;
+  result->type = input->type;
+  *output = result;
+}
+
+void Deserialize_(internal::Bar_Data* input,
+                  BarPtr* output) {
+  BarPtr result(Bar::New());
+  result->alpha = input->alpha;
+  result->beta = input->beta;
+  result->gamma = input->gamma;
+  result->type = static_cast<Bar::Type>(
+      input->type);
+  *output = result.Pass();
+}
+size_t GetSerializedSize_(const FooPtr& input) {
+  size_t size = mojo::internal::Align(sizeof(internal::Foo_Data));
+  if (input->bar)
+    size += GetSerializedSize_(input->bar);
+  if (input->data)
+    size += GetSerializedSize_(input->data);
+  if (input->extra_bars)
+    size += GetSerializedSize_(input->extra_bars);
+  if (input->name)
+    size += GetSerializedSize_(input->name);
+  if (input->input_streams)
+    size += GetSerializedSize_(input->input_streams);
+  if (input->output_streams)
+    size += GetSerializedSize_(input->output_streams);
+  if (input->array_of_array_of_bools)
+    size += GetSerializedSize_(input->array_of_array_of_bools);
+  if (input->multi_array_of_strings)
+    size += GetSerializedSize_(input->multi_array_of_strings);
+  return size;
+}
+
+void Serialize_(FooPtr input, mojo::internal::Buffer* buf,
+                internal::Foo_Data** output) {
+  internal::Foo_Data* result =
+      internal::Foo_Data::New(buf);
+  result->x = input->x;
+  result->y = input->y;
+  result->a = input->a;
+  result->b = input->b;
+  result->c = input->c;
+  result->source = input->source.release();
+  if (input->bar)
+    Serialize_(mojo::internal::Forward(input->bar), buf, &result->bar.ptr);
+  if (input->data)
+    Serialize_(mojo::internal::Forward(input->data), buf, &result->data.ptr);
+  if (input->extra_bars)
+    Serialize_(mojo::internal::Forward(input->extra_bars), buf, &result->extra_bars.ptr);
+  if (input->name)
+    Serialize_(mojo::internal::Forward(input->name), buf, &result->name.ptr);
+  if (input->input_streams)
+    Serialize_(mojo::internal::Forward(input->input_streams), buf, &result->input_streams.ptr);
+  if (input->output_streams)
+    Serialize_(mojo::internal::Forward(input->output_streams), buf, &result->output_streams.ptr);
+  if (input->array_of_array_of_bools)
+    Serialize_(mojo::internal::Forward(input->array_of_array_of_bools), buf, &result->array_of_array_of_bools.ptr);
+  if (input->multi_array_of_strings)
+    Serialize_(mojo::internal::Forward(input->multi_array_of_strings), buf, &result->multi_array_of_strings.ptr);
+  *output = result;
+}
+
+void Deserialize_(internal::Foo_Data* input,
+                  FooPtr* output) {
+  FooPtr result(Foo::New());
+  result->x = input->x;
+  result->y = input->y;
+  result->a = input->a;
+  result->b = input->b;
+  result->c = input->c;
+  result->source.reset(mojo::internal::FetchAndReset(&input->source));
+  if (input->bar.ptr)
+    Deserialize_(input->bar.ptr, &result->bar);
+  if (input->data.ptr)
+    Deserialize_(input->data.ptr, &result->data);
+  if (input->extra_bars.ptr)
+    Deserialize_(input->extra_bars.ptr, &result->extra_bars);
+  if (input->name.ptr)
+    Deserialize_(input->name.ptr, &result->name);
+  if (input->input_streams.ptr)
+    Deserialize_(input->input_streams.ptr, &result->input_streams);
+  if (input->output_streams.ptr)
+    Deserialize_(input->output_streams.ptr, &result->output_streams);
+  if (input->array_of_array_of_bools.ptr)
+    Deserialize_(input->array_of_array_of_bools.ptr, &result->array_of_array_of_bools);
+  if (input->multi_array_of_strings.ptr)
+    Deserialize_(input->multi_array_of_strings.ptr, &result->multi_array_of_strings);
+  *output = result.Pass();
+}
+size_t GetSerializedSize_(const DefaultsTestInnerPtr& input) {
+  size_t size = mojo::internal::Align(sizeof(internal::DefaultsTestInner_Data));
+  return size;
+}
+
+void Serialize_(DefaultsTestInnerPtr input, mojo::internal::Buffer* buf,
+                internal::DefaultsTestInner_Data** output) {
+  internal::DefaultsTestInner_Data* result =
+      internal::DefaultsTestInner_Data::New(buf);
+  result->x = input->x;
+  *output = result;
+}
+
+void Deserialize_(internal::DefaultsTestInner_Data* input,
+                  DefaultsTestInnerPtr* output) {
+  DefaultsTestInnerPtr result(DefaultsTestInner::New());
+  result->x = input->x;
+  *output = result.Pass();
+}
+size_t GetSerializedSize_(const DefaultsTestPtr& input) {
+  size_t size = mojo::internal::Align(sizeof(internal::DefaultsTest_Data));
+  if (input->a18)
+    size += GetSerializedSize_(input->a18);
+  if (input->a19)
+    size += GetSerializedSize_(input->a19);
+  if (input->a20)
+    size += GetSerializedSize_(input->a20);
+  return size;
+}
+
+void Serialize_(DefaultsTestPtr input, mojo::internal::Buffer* buf,
+                internal::DefaultsTest_Data** output) {
+  internal::DefaultsTest_Data* result =
+      internal::DefaultsTest_Data::New(buf);
+  result->a0 = input->a0;
+  result->a1 = input->a1;
+  result->a2 = input->a2;
+  result->a3 = input->a3;
+  result->a11 = input->a11;
+  result->a12 = input->a12;
+  result->a4 = input->a4;
+  result->a5 = input->a5;
+  result->a6 = input->a6;
+  result->a7 = input->a7;
+  result->a8 = input->a8;
+  result->a9 = input->a9;
+  result->a10 = input->a10;
+  result->a13 = input->a13;
+  result->a14 = input->a14;
+  result->a15 = input->a15;
+  result->a16 = input->a16;
+  result->a17 = input->a17;
+  if (input->a18)
+    Serialize_(mojo::internal::Forward(input->a18), buf, &result->a18.ptr);
+  if (input->a19)
+    Serialize_(mojo::internal::Forward(input->a19), buf, &result->a19.ptr);
+  if (input->a20)
+    Serialize_(mojo::internal::Forward(input->a20), buf, &result->a20.ptr);
+  *output = result;
+}
+
+void Deserialize_(internal::DefaultsTest_Data* input,
+                  DefaultsTestPtr* output) {
+  DefaultsTestPtr result(DefaultsTest::New());
+  result->a0 = input->a0;
+  result->a1 = input->a1;
+  result->a2 = input->a2;
+  result->a3 = input->a3;
+  result->a11 = input->a11;
+  result->a12 = input->a12;
+  result->a4 = input->a4;
+  result->a5 = input->a5;
+  result->a6 = input->a6;
+  result->a7 = input->a7;
+  result->a8 = input->a8;
+  result->a9 = input->a9;
+  result->a10 = input->a10;
+  result->a13 = input->a13;
+  result->a14 = input->a14;
+  result->a15 = input->a15;
+  result->a16 = input->a16;
+  result->a17 = input->a17;
+  if (input->a18.ptr)
+    Deserialize_(input->a18.ptr, &result->a18);
+  if (input->a19.ptr)
+    Deserialize_(input->a19.ptr, &result->a19);
+  if (input->a20.ptr)
+    Deserialize_(input->a20.ptr, &result->a20);
+  *output = result.Pass();
+}
+size_t GetSerializedSize_(const StructWithHoleV1Ptr& input) {
+  size_t size = mojo::internal::Align(sizeof(internal::StructWithHoleV1_Data));
+  return size;
+}
+
+void Serialize_(StructWithHoleV1Ptr input, mojo::internal::Buffer* buf,
+                internal::StructWithHoleV1_Data** output) {
+  internal::StructWithHoleV1_Data* result =
+      internal::StructWithHoleV1_Data::New(buf);
+  result->v1 = input->v1;
+  result->v2 = input->v2;
+  *output = result;
+}
+
+void Deserialize_(internal::StructWithHoleV1_Data* input,
+                  StructWithHoleV1Ptr* output) {
+  StructWithHoleV1Ptr result(StructWithHoleV1::New());
+  result->v1 = input->v1;
+  result->v2 = input->v2;
+  *output = result.Pass();
+}
+size_t GetSerializedSize_(const StructWithHoleV2Ptr& input) {
+  size_t size = mojo::internal::Align(sizeof(internal::StructWithHoleV2_Data));
+  return size;
+}
+
+void Serialize_(StructWithHoleV2Ptr input, mojo::internal::Buffer* buf,
+                internal::StructWithHoleV2_Data** output) {
+  internal::StructWithHoleV2_Data* result =
+      internal::StructWithHoleV2_Data::New(buf);
+  result->v1 = input->v1;
+  result->v3 = input->v3;
+  result->v2 = input->v2;
+  *output = result;
+}
+
+void Deserialize_(internal::StructWithHoleV2_Data* input,
+                  StructWithHoleV2Ptr* output) {
+  StructWithHoleV2Ptr result(StructWithHoleV2::New());
+  result->v1 = input->v1;
+  result->v3 = input->v3;
+  result->v2 = input->v2;
+  *output = result.Pass();
+}
+
+}  // namespace sample
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif