win-Debug/gen/mojo/public/interfaces/bindings/tests/struct_with_traits.mojom-blink.h

// mojo/public/interfaces/bindings/tests/struct_with_traits.mojom-blink.h is auto generated by mojom_bindings_generator.py, do not edit

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef MOJO_PUBLIC_INTERFACES_BINDINGS_TESTS_STRUCT_WITH_TRAITS_MOJOM_BLINK_H_
#define MOJO_PUBLIC_INTERFACES_BINDINGS_TESTS_STRUCT_WITH_TRAITS_MOJOM_BLINK_H_

#include <stdint.h>

#include <limits>
#include <optional>
#include <type_traits>
#include <utility>

#include "base/types/cxx23_to_underlying.h"
#include "mojo/public/cpp/bindings/clone_traits.h"
#include "mojo/public/cpp/bindings/equals_traits.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/struct_ptr.h"
#include "mojo/public/cpp/bindings/struct_traits.h"
#include "mojo/public/cpp/bindings/union_traits.h"

#include "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h"

#include "mojo/public/interfaces/bindings/tests/struct_with_traits.mojom-features.h"
#include "mojo/public/interfaces/bindings/tests/struct_with_traits.mojom-shared.h"
#include "mojo/public/interfaces/bindings/tests/struct_with_traits.mojom-blink-forward.h"

#include "mojo/public/cpp/bindings/lib/wtf_clone_equals_util.h"
#include "mojo/public/cpp/bindings/lib/wtf_hash_util.h"
#include "third_party/blink/renderer/platform/wtf/hash_functions.h"
#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"

#include "mojo/public/cpp/bindings/lib/control_message_handler.h"
#include "mojo/public/cpp/bindings/lib/message_size_estimator.h"
#include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"



#ifdef KYTHE_IS_RUNNING
#pragma kythe_inline_metadata "Metadata comment"
#endif


namespace mojo::test::blink {

class TraitsTestServiceProxy;

template <typename ImplRefTraits>
class TraitsTestServiceStub;

class TraitsTestServiceRequestValidator;
class TraitsTestServiceResponseValidator;


// @generated_from: mojo.test.TraitsTestService
class TraitsTestService
    : public TraitsTestServiceInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();

  static const char Name_[];
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = TraitsTestServiceInterfaceBase;
  using Proxy_ = TraitsTestServiceProxy;

  template <typename ImplRefTraits>
  using Stub_ = TraitsTestServiceStub<ImplRefTraits>;

  using RequestValidator_ = TraitsTestServiceRequestValidator;
  using ResponseValidator_ = TraitsTestServiceResponseValidator;
  enum MethodMinVersions : uint32_t {
    kEchoStructWithTraitsMinVersion = 0,
    kEchoTrivialStructWithTraitsMinVersion = 0,
    kEchoMoveOnlyStructWithTraitsMinVersion = 0,
    kEchoNullableMoveOnlyStructWithTraitsMinVersion = 0,
    kEchoEnumWithTraitsMinVersion = 0,
    kEchoStructWithTraitsForUniquePtrMinVersion = 0,
    kEchoNullableStructWithTraitsForUniquePtrMinVersion = 0,
    kEchoUnionWithTraitsMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct EchoStructWithTraits_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct EchoTrivialStructWithTraits_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct EchoMoveOnlyStructWithTraits_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct EchoNullableMoveOnlyStructWithTraits_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct EchoEnumWithTraits_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct EchoStructWithTraitsForUniquePtr_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct EchoNullableStructWithTraitsForUniquePtr_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct EchoUnionWithTraits_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~TraitsTestService() = default;


  using EchoStructWithTraitsCallback = base::OnceCallback<void(StructWithTraitsPtr)>;
  
// @generated_from: mojo.test.TraitsTestService.EchoStructWithTraits
  virtual void EchoStructWithTraits(StructWithTraitsPtr s, EchoStructWithTraitsCallback callback) = 0;


  using EchoTrivialStructWithTraitsCallback = base::OnceCallback<void(TrivialStructWithTraitsPtr)>;
  
// @generated_from: mojo.test.TraitsTestService.EchoTrivialStructWithTraits
  virtual void EchoTrivialStructWithTraits(TrivialStructWithTraitsPtr s, EchoTrivialStructWithTraitsCallback callback) = 0;


  using EchoMoveOnlyStructWithTraitsCallback = base::OnceCallback<void(MoveOnlyStructWithTraitsPtr)>;
  
// @generated_from: mojo.test.TraitsTestService.EchoMoveOnlyStructWithTraits
  virtual void EchoMoveOnlyStructWithTraits(MoveOnlyStructWithTraitsPtr s, EchoMoveOnlyStructWithTraitsCallback callback) = 0;


  using EchoNullableMoveOnlyStructWithTraitsCallback = base::OnceCallback<void(MoveOnlyStructWithTraitsPtr)>;
  
// @generated_from: mojo.test.TraitsTestService.EchoNullableMoveOnlyStructWithTraits
  virtual void EchoNullableMoveOnlyStructWithTraits(MoveOnlyStructWithTraitsPtr s, EchoNullableMoveOnlyStructWithTraitsCallback callback) = 0;


  using EchoEnumWithTraitsCallback = base::OnceCallback<void(EnumWithTraits)>;
  
// @generated_from: mojo.test.TraitsTestService.EchoEnumWithTraits
  virtual void EchoEnumWithTraits(EnumWithTraits e, EchoEnumWithTraitsCallback callback) = 0;


  using EchoStructWithTraitsForUniquePtrCallback = base::OnceCallback<void(StructWithTraitsForUniquePtrPtr)>;
  
// @generated_from: mojo.test.TraitsTestService.EchoStructWithTraitsForUniquePtr
  virtual void EchoStructWithTraitsForUniquePtr(StructWithTraitsForUniquePtrPtr e, EchoStructWithTraitsForUniquePtrCallback callback) = 0;


  using EchoNullableStructWithTraitsForUniquePtrCallback = base::OnceCallback<void(StructWithTraitsForUniquePtrPtr)>;
  
// @generated_from: mojo.test.TraitsTestService.EchoNullableStructWithTraitsForUniquePtr
  virtual void EchoNullableStructWithTraitsForUniquePtr(StructWithTraitsForUniquePtrPtr e, EchoNullableStructWithTraitsForUniquePtrCallback callback) = 0;


  using EchoUnionWithTraitsCallback = base::OnceCallback<void(UnionWithTraitsPtr)>;
  
// @generated_from: mojo.test.TraitsTestService.EchoUnionWithTraits
  virtual void EchoUnionWithTraits(UnionWithTraitsPtr u, EchoUnionWithTraitsCallback callback) = 0;
};

class TestUnserializedStructProxy;

template <typename ImplRefTraits>
class TestUnserializedStructStub;

class TestUnserializedStructRequestValidator;
class TestUnserializedStructResponseValidator;


// @generated_from: mojo.test.TestUnserializedStruct
class TestUnserializedStruct
    : public TestUnserializedStructInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();

  static const char Name_[];
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = TestUnserializedStructInterfaceBase;
  using Proxy_ = TestUnserializedStructProxy;

  template <typename ImplRefTraits>
  using Stub_ = TestUnserializedStructStub<ImplRefTraits>;

  using RequestValidator_ = TestUnserializedStructRequestValidator;
  using ResponseValidator_ = TestUnserializedStructResponseValidator;
  enum MethodMinVersions : uint32_t {
    kPassUnserializedStructMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct PassUnserializedStruct_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~TestUnserializedStruct() = default;


  using PassUnserializedStructCallback = base::OnceCallback<void(StructWithUnreachableTraitsPtr)>;
  
// @generated_from: mojo.test.TestUnserializedStruct.PassUnserializedStruct
  virtual void PassUnserializedStruct(StructWithUnreachableTraitsPtr s, PassUnserializedStructCallback callback) = 0;
};

class ForceSerializeTesterProxy;

template <typename ImplRefTraits>
class ForceSerializeTesterStub;

class ForceSerializeTesterRequestValidator;
class ForceSerializeTesterResponseValidator;


// @generated_from: mojo.test.ForceSerializeTester
class ForceSerializeTester
    : public ForceSerializeTesterInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();

  static const char Name_[];
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = ForceSerializeTesterInterfaceBase;
  using Proxy_ = ForceSerializeTesterProxy;

  template <typename ImplRefTraits>
  using Stub_ = ForceSerializeTesterStub<ImplRefTraits>;

  using RequestValidator_ = ForceSerializeTesterRequestValidator;
  using ResponseValidator_ = ForceSerializeTesterResponseValidator;
  enum MethodMinVersions : uint32_t {
    kSendForceSerializedStructMinVersion = 0,
    kSendNestedForceSerializedStructMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct SendForceSerializedStruct_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SendNestedForceSerializedStruct_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~ForceSerializeTester() = default;


  using SendForceSerializedStructCallback = base::OnceCallback<void(StructForceSerializePtr)>;
  
// @generated_from: mojo.test.ForceSerializeTester.SendForceSerializedStruct
  virtual void SendForceSerializedStruct(StructForceSerializePtr s, SendForceSerializedStructCallback callback) = 0;


  using SendNestedForceSerializedStructCallback = base::OnceCallback<void(StructNestedForceSerializePtr)>;
  
// @generated_from: mojo.test.ForceSerializeTester.SendNestedForceSerializedStruct
  virtual void SendNestedForceSerializedStruct(StructNestedForceSerializePtr s, SendNestedForceSerializedStructCallback callback) = 0;
};



// @generated_from: mojo.test.TraitsTestService
class  TraitsTestServiceProxy
    : public TraitsTestService {
 public:
  using InterfaceType = TraitsTestService;

  explicit TraitsTestServiceProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: mojo.test.TraitsTestService.EchoStructWithTraits
  void EchoStructWithTraits(StructWithTraitsPtr s, EchoStructWithTraitsCallback callback) final;
  
// @generated_from: mojo.test.TraitsTestService.EchoTrivialStructWithTraits
  void EchoTrivialStructWithTraits(TrivialStructWithTraitsPtr s, EchoTrivialStructWithTraitsCallback callback) final;
  
// @generated_from: mojo.test.TraitsTestService.EchoMoveOnlyStructWithTraits
  void EchoMoveOnlyStructWithTraits(MoveOnlyStructWithTraitsPtr s, EchoMoveOnlyStructWithTraitsCallback callback) final;
  
// @generated_from: mojo.test.TraitsTestService.EchoNullableMoveOnlyStructWithTraits
  void EchoNullableMoveOnlyStructWithTraits(MoveOnlyStructWithTraitsPtr s, EchoNullableMoveOnlyStructWithTraitsCallback callback) final;
  
// @generated_from: mojo.test.TraitsTestService.EchoEnumWithTraits
  void EchoEnumWithTraits(EnumWithTraits e, EchoEnumWithTraitsCallback callback) final;
  
// @generated_from: mojo.test.TraitsTestService.EchoStructWithTraitsForUniquePtr
  void EchoStructWithTraitsForUniquePtr(StructWithTraitsForUniquePtrPtr e, EchoStructWithTraitsForUniquePtrCallback callback) final;
  
// @generated_from: mojo.test.TraitsTestService.EchoNullableStructWithTraitsForUniquePtr
  void EchoNullableStructWithTraitsForUniquePtr(StructWithTraitsForUniquePtrPtr e, EchoNullableStructWithTraitsForUniquePtrCallback callback) final;
  
// @generated_from: mojo.test.TraitsTestService.EchoUnionWithTraits
  void EchoUnionWithTraits(UnionWithTraitsPtr u, EchoUnionWithTraitsCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



// @generated_from: mojo.test.TestUnserializedStruct
class  TestUnserializedStructProxy
    : public TestUnserializedStruct {
 public:
  using InterfaceType = TestUnserializedStruct;

  explicit TestUnserializedStructProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: mojo.test.TestUnserializedStruct.PassUnserializedStruct
  void PassUnserializedStruct(StructWithUnreachableTraitsPtr s, PassUnserializedStructCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



// @generated_from: mojo.test.ForceSerializeTester
class  ForceSerializeTesterProxy
    : public ForceSerializeTester {
 public:
  using InterfaceType = ForceSerializeTester;

  explicit ForceSerializeTesterProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: mojo.test.ForceSerializeTester.SendForceSerializedStruct
  void SendForceSerializedStruct(StructForceSerializePtr s, SendForceSerializedStructCallback callback) final;
  
// @generated_from: mojo.test.ForceSerializeTester.SendNestedForceSerializedStruct
  void SendNestedForceSerializedStruct(StructNestedForceSerializePtr s, SendNestedForceSerializedStructCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};
class  TraitsTestServiceStubDispatch {
 public:
  static bool Accept(TraitsTestService* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      TraitsTestService* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<TraitsTestService>>
class TraitsTestServiceStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  TraitsTestServiceStub() = default;
  ~TraitsTestServiceStub() override = default;

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return TraitsTestServiceStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return TraitsTestServiceStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class  TestUnserializedStructStubDispatch {
 public:
  static bool Accept(TestUnserializedStruct* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      TestUnserializedStruct* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<TestUnserializedStruct>>
class TestUnserializedStructStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  TestUnserializedStructStub() = default;
  ~TestUnserializedStructStub() override = default;

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return TestUnserializedStructStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return TestUnserializedStructStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class  ForceSerializeTesterStubDispatch {
 public:
  static bool Accept(ForceSerializeTester* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      ForceSerializeTester* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<ForceSerializeTester>>
class ForceSerializeTesterStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  ForceSerializeTesterStub() = default;
  ~ForceSerializeTesterStub() override = default;

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return ForceSerializeTesterStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return ForceSerializeTesterStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class  TraitsTestServiceRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  TestUnserializedStructRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ForceSerializeTesterRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  TraitsTestServiceResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  TestUnserializedStructResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ForceSerializeTesterResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};





// @generated_from: mojo.test.NestedStructWithTraits
class  NestedStructWithTraits {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<NestedStructWithTraits, T>::value>;
  using DataView = NestedStructWithTraitsDataView;
  using Data_ = internal::NestedStructWithTraits_Data;

  template <typename... Args>
  static NestedStructWithTraitsPtr New(Args&&... args) {
    return NestedStructWithTraitsPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static NestedStructWithTraitsPtr From(const U& u) {
    return mojo::TypeConverter<NestedStructWithTraitsPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, NestedStructWithTraits>::Convert(*this);
  }


  NestedStructWithTraits();

  explicit NestedStructWithTraits(
      int32_t value);


  ~NestedStructWithTraits();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = NestedStructWithTraitsPtr>
  NestedStructWithTraitsPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, NestedStructWithTraits::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, NestedStructWithTraits::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, NestedStructWithTraits::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  size_t Hash(size_t seed) const;
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        NestedStructWithTraits::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        NestedStructWithTraits::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::NestedStructWithTraits_UnserializedMessageContext<
            UserType, NestedStructWithTraits::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<NestedStructWithTraits::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return NestedStructWithTraits::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::NestedStructWithTraits_UnserializedMessageContext<
            UserType, NestedStructWithTraits::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<NestedStructWithTraits::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: mojo.test.NestedStructWithTraits.value
  int32_t value;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, NestedStructWithTraits::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, NestedStructWithTraits::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, NestedStructWithTraits::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, NestedStructWithTraits::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}






// @generated_from: mojo.test.StructWithUnreachableTraits
class  StructWithUnreachableTraits {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<StructWithUnreachableTraits, T>::value>;
  using DataView = StructWithUnreachableTraitsDataView;
  using Data_ = internal::StructWithUnreachableTraits_Data;

  template <typename... Args>
  static StructWithUnreachableTraitsPtr New(Args&&... args) {
    return StructWithUnreachableTraitsPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static StructWithUnreachableTraitsPtr From(const U& u) {
    return mojo::TypeConverter<StructWithUnreachableTraitsPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, StructWithUnreachableTraits>::Convert(*this);
  }


  StructWithUnreachableTraits();

  explicit StructWithUnreachableTraits(
      bool ignore_me);


  ~StructWithUnreachableTraits();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = StructWithUnreachableTraitsPtr>
  StructWithUnreachableTraitsPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, StructWithUnreachableTraits::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, StructWithUnreachableTraits::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, StructWithUnreachableTraits::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  size_t Hash(size_t seed) const;
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        StructWithUnreachableTraits::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        StructWithUnreachableTraits::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::StructWithUnreachableTraits_UnserializedMessageContext<
            UserType, StructWithUnreachableTraits::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<StructWithUnreachableTraits::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return StructWithUnreachableTraits::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::StructWithUnreachableTraits_UnserializedMessageContext<
            UserType, StructWithUnreachableTraits::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<StructWithUnreachableTraits::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: mojo.test.StructWithUnreachableTraits.ignore_me
  bool ignore_me;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, StructWithUnreachableTraits::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, StructWithUnreachableTraits::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, StructWithUnreachableTraits::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, StructWithUnreachableTraits::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}






// @generated_from: mojo.test.TrivialStructWithTraits
class  TrivialStructWithTraits {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<TrivialStructWithTraits, T>::value>;
  using DataView = TrivialStructWithTraitsDataView;
  using Data_ = internal::TrivialStructWithTraits_Data;

  template <typename... Args>
  static TrivialStructWithTraitsPtr New(Args&&... args) {
    return TrivialStructWithTraitsPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static TrivialStructWithTraitsPtr From(const U& u) {
    return mojo::TypeConverter<TrivialStructWithTraitsPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, TrivialStructWithTraits>::Convert(*this);
  }


  TrivialStructWithTraits();

  explicit TrivialStructWithTraits(
      int32_t value);


  ~TrivialStructWithTraits();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = TrivialStructWithTraitsPtr>
  TrivialStructWithTraitsPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, TrivialStructWithTraits::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, TrivialStructWithTraits::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, TrivialStructWithTraits::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  size_t Hash(size_t seed) const;
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        TrivialStructWithTraits::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        TrivialStructWithTraits::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::TrivialStructWithTraits_UnserializedMessageContext<
            UserType, TrivialStructWithTraits::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<TrivialStructWithTraits::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return TrivialStructWithTraits::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::TrivialStructWithTraits_UnserializedMessageContext<
            UserType, TrivialStructWithTraits::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<TrivialStructWithTraits::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: mojo.test.TrivialStructWithTraits.value
  int32_t value;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, TrivialStructWithTraits::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, TrivialStructWithTraits::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, TrivialStructWithTraits::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, TrivialStructWithTraits::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}







// @generated_from: mojo.test.StructWithTraitsForUniquePtr
class  StructWithTraitsForUniquePtr {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<StructWithTraitsForUniquePtr, T>::value>;
  using DataView = StructWithTraitsForUniquePtrDataView;
  using Data_ = internal::StructWithTraitsForUniquePtr_Data;

  template <typename... Args>
  static StructWithTraitsForUniquePtrPtr New(Args&&... args) {
    return StructWithTraitsForUniquePtrPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static StructWithTraitsForUniquePtrPtr From(const U& u) {
    return mojo::TypeConverter<StructWithTraitsForUniquePtrPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, StructWithTraitsForUniquePtr>::Convert(*this);
  }


  StructWithTraitsForUniquePtr();

  explicit StructWithTraitsForUniquePtr(
      int32_t f_int32);


  ~StructWithTraitsForUniquePtr();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = StructWithTraitsForUniquePtrPtr>
  StructWithTraitsForUniquePtrPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, StructWithTraitsForUniquePtr::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, StructWithTraitsForUniquePtr::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, StructWithTraitsForUniquePtr::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  size_t Hash(size_t seed) const;
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        StructWithTraitsForUniquePtr::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        StructWithTraitsForUniquePtr::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::StructWithTraitsForUniquePtr_UnserializedMessageContext<
            UserType, StructWithTraitsForUniquePtr::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<StructWithTraitsForUniquePtr::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return StructWithTraitsForUniquePtr::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::StructWithTraitsForUniquePtr_UnserializedMessageContext<
            UserType, StructWithTraitsForUniquePtr::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<StructWithTraitsForUniquePtr::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: mojo.test.StructWithTraitsForUniquePtr.f_int32
  int32_t f_int32;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, StructWithTraitsForUniquePtr::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, StructWithTraitsForUniquePtr::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, StructWithTraitsForUniquePtr::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, StructWithTraitsForUniquePtr::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





// @generated_from: mojo.test.EnumWithTraitsContainer
class  EnumWithTraitsContainer {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<EnumWithTraitsContainer, T>::value>;
  using DataView = EnumWithTraitsContainerDataView;
  using Data_ = internal::EnumWithTraitsContainer_Data;

  template <typename... Args>
  static EnumWithTraitsContainerPtr New(Args&&... args) {
    return EnumWithTraitsContainerPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static EnumWithTraitsContainerPtr From(const U& u) {
    return mojo::TypeConverter<EnumWithTraitsContainerPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, EnumWithTraitsContainer>::Convert(*this);
  }


  EnumWithTraitsContainer();

  explicit EnumWithTraitsContainer(
      EnumWithTraits f_field);


  ~EnumWithTraitsContainer();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = EnumWithTraitsContainerPtr>
  EnumWithTraitsContainerPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, EnumWithTraitsContainer::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, EnumWithTraitsContainer::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, EnumWithTraitsContainer::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  size_t Hash(size_t seed) const;
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        EnumWithTraitsContainer::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        EnumWithTraitsContainer::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::EnumWithTraitsContainer_UnserializedMessageContext<
            UserType, EnumWithTraitsContainer::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<EnumWithTraitsContainer::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return EnumWithTraitsContainer::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::EnumWithTraitsContainer_UnserializedMessageContext<
            UserType, EnumWithTraitsContainer::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<EnumWithTraitsContainer::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: mojo.test.EnumWithTraitsContainer.f_field
  EnumWithTraits f_field;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, EnumWithTraitsContainer::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, EnumWithTraitsContainer::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, EnumWithTraitsContainer::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, EnumWithTraitsContainer::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





// @generated_from: mojo.test.StructForceSerialize
class  StructForceSerialize {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<StructForceSerialize, T>::value>;
  using DataView = StructForceSerializeDataView;
  using Data_ = internal::StructForceSerialize_Data;

  template <typename... Args>
  static StructForceSerializePtr New(Args&&... args) {
    return StructForceSerializePtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static StructForceSerializePtr From(const U& u) {
    return mojo::TypeConverter<StructForceSerializePtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, StructForceSerialize>::Convert(*this);
  }


  StructForceSerialize();

  explicit StructForceSerialize(
      int32_t value);


  ~StructForceSerialize();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = StructForceSerializePtr>
  StructForceSerializePtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, StructForceSerialize::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, StructForceSerialize::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, StructForceSerialize::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  size_t Hash(size_t seed) const;
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        StructForceSerialize::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        StructForceSerialize::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::StructForceSerialize_UnserializedMessageContext<
            UserType, StructForceSerialize::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<StructForceSerialize::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return StructForceSerialize::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::StructForceSerialize_UnserializedMessageContext<
            UserType, StructForceSerialize::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<StructForceSerialize::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: mojo.test.StructForceSerialize.value
  int32_t value;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, StructForceSerialize::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, StructForceSerialize::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, StructForceSerialize::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, StructForceSerialize::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}






// @generated_from: mojo.test.UnionWithTraits
class  UnionWithTraits {
 public:
  using DataView = UnionWithTraitsDataView;
  using Data_ = internal::UnionWithTraits_Data;
  using Tag = Data_::UnionWithTraits_Tag;

  template <typename... Args>
  static UnionWithTraitsPtr New(Args&&... args) {
    static_assert(
        sizeof...(args) < 0,
        "Do not use Union::New(); to create a union of a given subtype, use "
        "New<SubType>(), not New() followed by set_<sub_type>(). To represent "
        "an empty union, mark the field or parameter as nullable in the mojom "
        "definition.");
    return nullptr;
  }
  // Construct an instance holding |f_int32|.
  static UnionWithTraitsPtr
  NewFInt32(
      int32_t value) {
    auto result = UnionWithTraitsPtr(std::in_place);
    result->set_f_int32(std::move(value));
    return result;
  }
  // Construct an instance holding |f_struct|.
  static UnionWithTraitsPtr
  NewFStruct(
      NestedStructWithTraitsPtr value) {
    auto result = UnionWithTraitsPtr(std::in_place);
    result->set_f_struct(std::move(value));
    return result;
  }

  template <typename U>
  static UnionWithTraitsPtr From(const U& u) {
    return mojo::TypeConverter<UnionWithTraitsPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, UnionWithTraits>::Convert(*this);
  }

  UnionWithTraits();
  ~UnionWithTraits();
  // Delete the copy constructor and copy assignment operators because `data_`
  // contains raw pointers that must not be copied.
  UnionWithTraits(const UnionWithTraits& other) = delete;
  UnionWithTraits& operator=(const UnionWithTraits& other) = delete;

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename UnionPtrType = UnionWithTraitsPtr>
  UnionWithTraitsPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T,
            typename std::enable_if<std::is_same<
                T, UnionWithTraits>::value>::type* = nullptr>
  bool Equals(const T& other) const;

  template <typename T,
            typename std::enable_if<std::is_same<
                T, UnionWithTraits>::value>::type* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  size_t Hash(size_t seed) const;

  Tag which() const {
    return tag_;
  }


  
// @generated_from: mojo.test.UnionWithTraits.f_int32
  bool is_f_int32() const { return tag_ == Tag::kFInt32; }

  
// @generated_from: mojo.test.UnionWithTraits.f_int32
  int32_t get_f_int32() const {
    CHECK(tag_ == Tag::kFInt32);
    return data_.f_int32;
  }

  
// @generated_from: mojo.test.UnionWithTraits.f_int32
  void set_f_int32(
      int32_t f_int32);
  
// @generated_from: mojo.test.UnionWithTraits.f_struct
  bool is_f_struct() const { return tag_ == Tag::kFStruct; }

  
// @generated_from: mojo.test.UnionWithTraits.f_struct
  NestedStructWithTraitsPtr& get_f_struct() const {
    CHECK(tag_ == Tag::kFStruct);
    return *(data_.f_struct);
  }

  
// @generated_from: mojo.test.UnionWithTraits.f_struct
  void set_f_struct(
      NestedStructWithTraitsPtr f_struct);

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        UnionWithTraits::DataView>(input);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    return mojo::internal::DeserializeImpl<UnionWithTraits::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

 private:
  union Union_ {
    Union_() = default;
    ~Union_() = default;
    int32_t f_int32;
    NestedStructWithTraitsPtr* f_struct;
  };

  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  void DestroyActive();
  Tag tag_;
  Union_ data_;
};






// @generated_from: mojo.test.StructWithTraits
class  StructWithTraits {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<StructWithTraits, T>::value>;
  using DataView = StructWithTraitsDataView;
  using Data_ = internal::StructWithTraits_Data;

  template <typename... Args>
  static StructWithTraitsPtr New(Args&&... args) {
    return StructWithTraitsPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static StructWithTraitsPtr From(const U& u) {
    return mojo::TypeConverter<StructWithTraitsPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, StructWithTraits>::Convert(*this);
  }


  StructWithTraits();

  StructWithTraits(
      EnumWithTraits f_enum,
      bool f_bool,
      uint32_t f_uint32,
      uint64_t f_uint64,
      const WTF::String& f_string,
      const WTF::String& f_string2,
      WTF::Vector<WTF::String> f_string_array,
      WTF::Vector<WTF::String> f_string_set,
      NestedStructWithTraitsPtr f_struct,
      WTF::Vector<NestedStructWithTraitsPtr> f_struct_array,
      WTF::HashMap<WTF::String, NestedStructWithTraitsPtr> f_struct_map);

StructWithTraits(const StructWithTraits&) = delete;
StructWithTraits& operator=(const StructWithTraits&) = delete;

  ~StructWithTraits();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = StructWithTraitsPtr>
  StructWithTraitsPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, StructWithTraits::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, StructWithTraits::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, StructWithTraits::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        StructWithTraits::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        StructWithTraits::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::StructWithTraits_UnserializedMessageContext<
            UserType, StructWithTraits::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<StructWithTraits::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return StructWithTraits::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::StructWithTraits_UnserializedMessageContext<
            UserType, StructWithTraits::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<StructWithTraits::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: mojo.test.StructWithTraits.f_enum
  EnumWithTraits f_enum;
  
// @generated_from: mojo.test.StructWithTraits.f_bool
  bool f_bool;
  
// @generated_from: mojo.test.StructWithTraits.f_uint32
  uint32_t f_uint32;
  
// @generated_from: mojo.test.StructWithTraits.f_uint64
  uint64_t f_uint64;
  
// @generated_from: mojo.test.StructWithTraits.f_string
  WTF::String f_string;
  
// @generated_from: mojo.test.StructWithTraits.f_string2
  WTF::String f_string2;
  
// @generated_from: mojo.test.StructWithTraits.f_string_array
  WTF::Vector<WTF::String> f_string_array;
  
// @generated_from: mojo.test.StructWithTraits.f_string_set
  WTF::Vector<WTF::String> f_string_set;
  
// @generated_from: mojo.test.StructWithTraits.f_struct
  NestedStructWithTraitsPtr f_struct;
  
// @generated_from: mojo.test.StructWithTraits.f_struct_array
  WTF::Vector<NestedStructWithTraitsPtr> f_struct_array;
  
// @generated_from: mojo.test.StructWithTraits.f_struct_map
  WTF::HashMap<WTF::String, NestedStructWithTraitsPtr> f_struct_map;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, StructWithTraits::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, StructWithTraits::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, StructWithTraits::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, StructWithTraits::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}






// @generated_from: mojo.test.StructWithTraitsContainer
class  StructWithTraitsContainer {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<StructWithTraitsContainer, T>::value>;
  using DataView = StructWithTraitsContainerDataView;
  using Data_ = internal::StructWithTraitsContainer_Data;

  template <typename... Args>
  static StructWithTraitsContainerPtr New(Args&&... args) {
    return StructWithTraitsContainerPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static StructWithTraitsContainerPtr From(const U& u) {
    return mojo::TypeConverter<StructWithTraitsContainerPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, StructWithTraitsContainer>::Convert(*this);
  }


  StructWithTraitsContainer();

  explicit StructWithTraitsContainer(
      StructWithTraitsPtr f_struct);

StructWithTraitsContainer(const StructWithTraitsContainer&) = delete;
StructWithTraitsContainer& operator=(const StructWithTraitsContainer&) = delete;

  ~StructWithTraitsContainer();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = StructWithTraitsContainerPtr>
  StructWithTraitsContainerPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, StructWithTraitsContainer::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, StructWithTraitsContainer::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, StructWithTraitsContainer::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        StructWithTraitsContainer::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        StructWithTraitsContainer::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::StructWithTraitsContainer_UnserializedMessageContext<
            UserType, StructWithTraitsContainer::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<StructWithTraitsContainer::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return StructWithTraitsContainer::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::StructWithTraitsContainer_UnserializedMessageContext<
            UserType, StructWithTraitsContainer::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<StructWithTraitsContainer::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: mojo.test.StructWithTraitsContainer.f_struct
  StructWithTraitsPtr f_struct;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, StructWithTraitsContainer::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, StructWithTraitsContainer::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, StructWithTraitsContainer::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, StructWithTraitsContainer::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}






// @generated_from: mojo.test.MoveOnlyStructWithTraits
class  MoveOnlyStructWithTraits {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<MoveOnlyStructWithTraits, T>::value>;
  using DataView = MoveOnlyStructWithTraitsDataView;
  using Data_ = internal::MoveOnlyStructWithTraits_Data;

  template <typename... Args>
  static MoveOnlyStructWithTraitsPtr New(Args&&... args) {
    return MoveOnlyStructWithTraitsPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static MoveOnlyStructWithTraitsPtr From(const U& u) {
    return mojo::TypeConverter<MoveOnlyStructWithTraitsPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, MoveOnlyStructWithTraits>::Convert(*this);
  }


  MoveOnlyStructWithTraits();

  explicit MoveOnlyStructWithTraits(
      ::mojo::ScopedHandle f_handle);

MoveOnlyStructWithTraits(const MoveOnlyStructWithTraits&) = delete;
MoveOnlyStructWithTraits& operator=(const MoveOnlyStructWithTraits&) = delete;

  ~MoveOnlyStructWithTraits();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = MoveOnlyStructWithTraitsPtr>
  MoveOnlyStructWithTraitsPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, MoveOnlyStructWithTraits::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, MoveOnlyStructWithTraits::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, MoveOnlyStructWithTraits::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        MoveOnlyStructWithTraits::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::MoveOnlyStructWithTraits_UnserializedMessageContext<
            UserType, MoveOnlyStructWithTraits::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<MoveOnlyStructWithTraits::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return MoveOnlyStructWithTraits::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::MoveOnlyStructWithTraits_UnserializedMessageContext<
            UserType, MoveOnlyStructWithTraits::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<MoveOnlyStructWithTraits::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: mojo.test.MoveOnlyStructWithTraits.f_handle
  ::mojo::ScopedHandle f_handle;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, MoveOnlyStructWithTraits::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, MoveOnlyStructWithTraits::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, MoveOnlyStructWithTraits::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, MoveOnlyStructWithTraits::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





// @generated_from: mojo.test.MoveOnlyStructWithTraitsContainer
class  MoveOnlyStructWithTraitsContainer {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<MoveOnlyStructWithTraitsContainer, T>::value>;
  using DataView = MoveOnlyStructWithTraitsContainerDataView;
  using Data_ = internal::MoveOnlyStructWithTraitsContainer_Data;

  template <typename... Args>
  static MoveOnlyStructWithTraitsContainerPtr New(Args&&... args) {
    return MoveOnlyStructWithTraitsContainerPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static MoveOnlyStructWithTraitsContainerPtr From(const U& u) {
    return mojo::TypeConverter<MoveOnlyStructWithTraitsContainerPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, MoveOnlyStructWithTraitsContainer>::Convert(*this);
  }


  MoveOnlyStructWithTraitsContainer();

  explicit MoveOnlyStructWithTraitsContainer(
      MoveOnlyStructWithTraitsPtr f_struct);

MoveOnlyStructWithTraitsContainer(const MoveOnlyStructWithTraitsContainer&) = delete;
MoveOnlyStructWithTraitsContainer& operator=(const MoveOnlyStructWithTraitsContainer&) = delete;

  ~MoveOnlyStructWithTraitsContainer();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = MoveOnlyStructWithTraitsContainerPtr>
  MoveOnlyStructWithTraitsContainerPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, MoveOnlyStructWithTraitsContainer::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, MoveOnlyStructWithTraitsContainer::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, MoveOnlyStructWithTraitsContainer::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        MoveOnlyStructWithTraitsContainer::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::MoveOnlyStructWithTraitsContainer_UnserializedMessageContext<
            UserType, MoveOnlyStructWithTraitsContainer::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<MoveOnlyStructWithTraitsContainer::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return MoveOnlyStructWithTraitsContainer::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::MoveOnlyStructWithTraitsContainer_UnserializedMessageContext<
            UserType, MoveOnlyStructWithTraitsContainer::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<MoveOnlyStructWithTraitsContainer::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: mojo.test.MoveOnlyStructWithTraitsContainer.f_struct
  MoveOnlyStructWithTraitsPtr f_struct;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, MoveOnlyStructWithTraitsContainer::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, MoveOnlyStructWithTraitsContainer::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, MoveOnlyStructWithTraitsContainer::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, MoveOnlyStructWithTraitsContainer::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}








// @generated_from: mojo.test.StructNestedForceSerialize
class  StructNestedForceSerialize {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<StructNestedForceSerialize, T>::value>;
  using DataView = StructNestedForceSerializeDataView;
  using Data_ = internal::StructNestedForceSerialize_Data;

  template <typename... Args>
  static StructNestedForceSerializePtr New(Args&&... args) {
    return StructNestedForceSerializePtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static StructNestedForceSerializePtr From(const U& u) {
    return mojo::TypeConverter<StructNestedForceSerializePtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, StructNestedForceSerialize>::Convert(*this);
  }


  StructNestedForceSerialize();

  explicit StructNestedForceSerialize(
      StructForceSerializePtr force);

StructNestedForceSerialize(const StructNestedForceSerialize&) = delete;
StructNestedForceSerialize& operator=(const StructNestedForceSerialize&) = delete;

  ~StructNestedForceSerialize();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = StructNestedForceSerializePtr>
  StructNestedForceSerializePtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, StructNestedForceSerialize::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, StructNestedForceSerialize::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, StructNestedForceSerialize::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  size_t Hash(size_t seed) const;
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        StructNestedForceSerialize::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        StructNestedForceSerialize::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::StructNestedForceSerialize_UnserializedMessageContext<
            UserType, StructNestedForceSerialize::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<StructNestedForceSerialize::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return StructNestedForceSerialize::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::StructNestedForceSerialize_UnserializedMessageContext<
            UserType, StructNestedForceSerialize::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<StructNestedForceSerialize::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: mojo.test.StructNestedForceSerialize.force
  StructForceSerializePtr force;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, StructNestedForceSerialize::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, StructNestedForceSerialize::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, StructNestedForceSerialize::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, StructNestedForceSerialize::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}

template <typename UnionPtrType>
UnionWithTraitsPtr UnionWithTraits::Clone() const {
  switch (tag_) {
    case Tag::kFInt32:
      return NewFInt32(
          mojo::Clone(data_.f_int32));
    case Tag::kFStruct:
      return NewFStruct(
          mojo::Clone(*data_.f_struct));
  }
  return nullptr;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, UnionWithTraits>::value>::type*>
bool UnionWithTraits::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::kFInt32:
      return mojo::Equals(data_.f_int32, other.data_.f_int32);
    case Tag::kFStruct:
      return mojo::Equals(*(data_.f_struct), *(other.data_.f_struct));
  }

  return false;
}
template <typename StructPtrType>
NestedStructWithTraitsPtr NestedStructWithTraits::Clone() const {
  return New(
      mojo::Clone(value)
  );
}

template <typename T, NestedStructWithTraits::EnableIfSame<T>*>
bool NestedStructWithTraits::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->value, other_struct.value))
    return false;
  return true;
}

template <typename T, NestedStructWithTraits::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.value < rhs.value)
    return true;
  if (rhs.value < lhs.value)
    return false;
  return false;
}
template <typename StructPtrType>
StructWithTraitsPtr StructWithTraits::Clone() const {
  return New(
      mojo::Clone(f_enum),
      mojo::Clone(f_bool),
      mojo::Clone(f_uint32),
      mojo::Clone(f_uint64),
      mojo::Clone(f_string),
      mojo::Clone(f_string2),
      mojo::Clone(f_string_array),
      mojo::Clone(f_string_set),
      mojo::Clone(f_struct),
      mojo::Clone(f_struct_array),
      mojo::Clone(f_struct_map)
  );
}

template <typename T, StructWithTraits::EnableIfSame<T>*>
bool StructWithTraits::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->f_enum, other_struct.f_enum))
    return false;
  if (!mojo::Equals(this->f_bool, other_struct.f_bool))
    return false;
  if (!mojo::Equals(this->f_uint32, other_struct.f_uint32))
    return false;
  if (!mojo::Equals(this->f_uint64, other_struct.f_uint64))
    return false;
  if (!mojo::Equals(this->f_string, other_struct.f_string))
    return false;
  if (!mojo::Equals(this->f_string2, other_struct.f_string2))
    return false;
  if (!mojo::Equals(this->f_string_array, other_struct.f_string_array))
    return false;
  if (!mojo::Equals(this->f_string_set, other_struct.f_string_set))
    return false;
  if (!mojo::Equals(this->f_struct, other_struct.f_struct))
    return false;
  if (!mojo::Equals(this->f_struct_array, other_struct.f_struct_array))
    return false;
  if (!mojo::Equals(this->f_struct_map, other_struct.f_struct_map))
    return false;
  return true;
}

template <typename T, StructWithTraits::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.f_enum < rhs.f_enum)
    return true;
  if (rhs.f_enum < lhs.f_enum)
    return false;
  if (lhs.f_bool < rhs.f_bool)
    return true;
  if (rhs.f_bool < lhs.f_bool)
    return false;
  if (lhs.f_uint32 < rhs.f_uint32)
    return true;
  if (rhs.f_uint32 < lhs.f_uint32)
    return false;
  if (lhs.f_uint64 < rhs.f_uint64)
    return true;
  if (rhs.f_uint64 < lhs.f_uint64)
    return false;
  if (lhs.f_string < rhs.f_string)
    return true;
  if (rhs.f_string < lhs.f_string)
    return false;
  if (lhs.f_string2 < rhs.f_string2)
    return true;
  if (rhs.f_string2 < lhs.f_string2)
    return false;
  if (lhs.f_string_array < rhs.f_string_array)
    return true;
  if (rhs.f_string_array < lhs.f_string_array)
    return false;
  if (lhs.f_string_set < rhs.f_string_set)
    return true;
  if (rhs.f_string_set < lhs.f_string_set)
    return false;
  if (lhs.f_struct < rhs.f_struct)
    return true;
  if (rhs.f_struct < lhs.f_struct)
    return false;
  if (lhs.f_struct_array < rhs.f_struct_array)
    return true;
  if (rhs.f_struct_array < lhs.f_struct_array)
    return false;
  if (lhs.f_struct_map < rhs.f_struct_map)
    return true;
  if (rhs.f_struct_map < lhs.f_struct_map)
    return false;
  return false;
}
template <typename StructPtrType>
StructWithUnreachableTraitsPtr StructWithUnreachableTraits::Clone() const {
  return New(
      mojo::Clone(ignore_me)
  );
}

template <typename T, StructWithUnreachableTraits::EnableIfSame<T>*>
bool StructWithUnreachableTraits::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->ignore_me, other_struct.ignore_me))
    return false;
  return true;
}

template <typename T, StructWithUnreachableTraits::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.ignore_me < rhs.ignore_me)
    return true;
  if (rhs.ignore_me < lhs.ignore_me)
    return false;
  return false;
}
template <typename StructPtrType>
StructWithTraitsContainerPtr StructWithTraitsContainer::Clone() const {
  return New(
      mojo::Clone(f_struct)
  );
}

template <typename T, StructWithTraitsContainer::EnableIfSame<T>*>
bool StructWithTraitsContainer::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->f_struct, other_struct.f_struct))
    return false;
  return true;
}

template <typename T, StructWithTraitsContainer::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.f_struct < rhs.f_struct)
    return true;
  if (rhs.f_struct < lhs.f_struct)
    return false;
  return false;
}
template <typename StructPtrType>
TrivialStructWithTraitsPtr TrivialStructWithTraits::Clone() const {
  return New(
      mojo::Clone(value)
  );
}

template <typename T, TrivialStructWithTraits::EnableIfSame<T>*>
bool TrivialStructWithTraits::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->value, other_struct.value))
    return false;
  return true;
}

template <typename T, TrivialStructWithTraits::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.value < rhs.value)
    return true;
  if (rhs.value < lhs.value)
    return false;
  return false;
}
template <typename StructPtrType>
MoveOnlyStructWithTraitsPtr MoveOnlyStructWithTraits::Clone() const {
  return New(
      mojo::Clone(f_handle)
  );
}

template <typename T, MoveOnlyStructWithTraits::EnableIfSame<T>*>
bool MoveOnlyStructWithTraits::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->f_handle, other_struct.f_handle))
    return false;
  return true;
}

template <typename T, MoveOnlyStructWithTraits::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.f_handle < rhs.f_handle)
    return true;
  if (rhs.f_handle < lhs.f_handle)
    return false;
  return false;
}
template <typename StructPtrType>
MoveOnlyStructWithTraitsContainerPtr MoveOnlyStructWithTraitsContainer::Clone() const {
  return New(
      mojo::Clone(f_struct)
  );
}

template <typename T, MoveOnlyStructWithTraitsContainer::EnableIfSame<T>*>
bool MoveOnlyStructWithTraitsContainer::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->f_struct, other_struct.f_struct))
    return false;
  return true;
}

template <typename T, MoveOnlyStructWithTraitsContainer::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.f_struct < rhs.f_struct)
    return true;
  if (rhs.f_struct < lhs.f_struct)
    return false;
  return false;
}
template <typename StructPtrType>
StructWithTraitsForUniquePtrPtr StructWithTraitsForUniquePtr::Clone() const {
  return New(
      mojo::Clone(f_int32)
  );
}

template <typename T, StructWithTraitsForUniquePtr::EnableIfSame<T>*>
bool StructWithTraitsForUniquePtr::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->f_int32, other_struct.f_int32))
    return false;
  return true;
}

template <typename T, StructWithTraitsForUniquePtr::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.f_int32 < rhs.f_int32)
    return true;
  if (rhs.f_int32 < lhs.f_int32)
    return false;
  return false;
}
template <typename StructPtrType>
EnumWithTraitsContainerPtr EnumWithTraitsContainer::Clone() const {
  return New(
      mojo::Clone(f_field)
  );
}

template <typename T, EnumWithTraitsContainer::EnableIfSame<T>*>
bool EnumWithTraitsContainer::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->f_field, other_struct.f_field))
    return false;
  return true;
}

template <typename T, EnumWithTraitsContainer::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.f_field < rhs.f_field)
    return true;
  if (rhs.f_field < lhs.f_field)
    return false;
  return false;
}
template <typename StructPtrType>
StructForceSerializePtr StructForceSerialize::Clone() const {
  return New(
      mojo::Clone(value)
  );
}

template <typename T, StructForceSerialize::EnableIfSame<T>*>
bool StructForceSerialize::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->value, other_struct.value))
    return false;
  return true;
}

template <typename T, StructForceSerialize::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.value < rhs.value)
    return true;
  if (rhs.value < lhs.value)
    return false;
  return false;
}
template <typename StructPtrType>
StructNestedForceSerializePtr StructNestedForceSerialize::Clone() const {
  return New(
      mojo::Clone(force)
  );
}

template <typename T, StructNestedForceSerialize::EnableIfSame<T>*>
bool StructNestedForceSerialize::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->force, other_struct.force))
    return false;
  return true;
}

template <typename T, StructNestedForceSerialize::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.force < rhs.force)
    return true;
  if (rhs.force < lhs.force)
    return false;
  return false;
}


}  // mojo::test::blink

namespace mojo {


template <>
struct  StructTraits<::mojo::test::blink::NestedStructWithTraits::DataView,
                                         ::mojo::test::blink::NestedStructWithTraitsPtr> {
  static bool IsNull(const ::mojo::test::blink::NestedStructWithTraitsPtr& input) { return !input; }
  static void SetToNull(::mojo::test::blink::NestedStructWithTraitsPtr* output) { output->reset(); }

  static decltype(::mojo::test::blink::NestedStructWithTraits::value) value(
      const ::mojo::test::blink::NestedStructWithTraitsPtr& input) {
    return input->value;
  }

  static bool Read(::mojo::test::blink::NestedStructWithTraits::DataView input, ::mojo::test::blink::NestedStructWithTraitsPtr* output);
};


template <>
struct  StructTraits<::mojo::test::blink::StructWithTraits::DataView,
                                         ::mojo::test::blink::StructWithTraitsPtr> {
  static bool IsNull(const ::mojo::test::blink::StructWithTraitsPtr& input) { return !input; }
  static void SetToNull(::mojo::test::blink::StructWithTraitsPtr* output) { output->reset(); }

  static decltype(::mojo::test::blink::StructWithTraits::f_enum) f_enum(
      const ::mojo::test::blink::StructWithTraitsPtr& input) {
    return input->f_enum;
  }

  static decltype(::mojo::test::blink::StructWithTraits::f_bool) f_bool(
      const ::mojo::test::blink::StructWithTraitsPtr& input) {
    return input->f_bool;
  }

  static decltype(::mojo::test::blink::StructWithTraits::f_uint32) f_uint32(
      const ::mojo::test::blink::StructWithTraitsPtr& input) {
    return input->f_uint32;
  }

  static decltype(::mojo::test::blink::StructWithTraits::f_uint64) f_uint64(
      const ::mojo::test::blink::StructWithTraitsPtr& input) {
    return input->f_uint64;
  }

  static const decltype(::mojo::test::blink::StructWithTraits::f_string)& f_string(
      const ::mojo::test::blink::StructWithTraitsPtr& input) {
    return input->f_string;
  }

  static const decltype(::mojo::test::blink::StructWithTraits::f_string2)& f_string2(
      const ::mojo::test::blink::StructWithTraitsPtr& input) {
    return input->f_string2;
  }

  static const decltype(::mojo::test::blink::StructWithTraits::f_string_array)& f_string_array(
      const ::mojo::test::blink::StructWithTraitsPtr& input) {
    return input->f_string_array;
  }

  static const decltype(::mojo::test::blink::StructWithTraits::f_string_set)& f_string_set(
      const ::mojo::test::blink::StructWithTraitsPtr& input) {
    return input->f_string_set;
  }

  static const decltype(::mojo::test::blink::StructWithTraits::f_struct)& f_struct(
      const ::mojo::test::blink::StructWithTraitsPtr& input) {
    return input->f_struct;
  }

  static const decltype(::mojo::test::blink::StructWithTraits::f_struct_array)& f_struct_array(
      const ::mojo::test::blink::StructWithTraitsPtr& input) {
    return input->f_struct_array;
  }

  static const decltype(::mojo::test::blink::StructWithTraits::f_struct_map)& f_struct_map(
      const ::mojo::test::blink::StructWithTraitsPtr& input) {
    return input->f_struct_map;
  }

  static bool Read(::mojo::test::blink::StructWithTraits::DataView input, ::mojo::test::blink::StructWithTraitsPtr* output);
};


template <>
struct  StructTraits<::mojo::test::blink::StructWithUnreachableTraits::DataView,
                                         ::mojo::test::blink::StructWithUnreachableTraitsPtr> {
  static bool IsNull(const ::mojo::test::blink::StructWithUnreachableTraitsPtr& input) { return !input; }
  static void SetToNull(::mojo::test::blink::StructWithUnreachableTraitsPtr* output) { output->reset(); }

  static decltype(::mojo::test::blink::StructWithUnreachableTraits::ignore_me) ignore_me(
      const ::mojo::test::blink::StructWithUnreachableTraitsPtr& input) {
    return input->ignore_me;
  }

  static bool Read(::mojo::test::blink::StructWithUnreachableTraits::DataView input, ::mojo::test::blink::StructWithUnreachableTraitsPtr* output);
};


template <>
struct  StructTraits<::mojo::test::blink::StructWithTraitsContainer::DataView,
                                         ::mojo::test::blink::StructWithTraitsContainerPtr> {
  static bool IsNull(const ::mojo::test::blink::StructWithTraitsContainerPtr& input) { return !input; }
  static void SetToNull(::mojo::test::blink::StructWithTraitsContainerPtr* output) { output->reset(); }

  static const decltype(::mojo::test::blink::StructWithTraitsContainer::f_struct)& f_struct(
      const ::mojo::test::blink::StructWithTraitsContainerPtr& input) {
    return input->f_struct;
  }

  static bool Read(::mojo::test::blink::StructWithTraitsContainer::DataView input, ::mojo::test::blink::StructWithTraitsContainerPtr* output);
};


template <>
struct  StructTraits<::mojo::test::blink::TrivialStructWithTraits::DataView,
                                         ::mojo::test::blink::TrivialStructWithTraitsPtr> {
  static bool IsNull(const ::mojo::test::blink::TrivialStructWithTraitsPtr& input) { return !input; }
  static void SetToNull(::mojo::test::blink::TrivialStructWithTraitsPtr* output) { output->reset(); }

  static decltype(::mojo::test::blink::TrivialStructWithTraits::value) value(
      const ::mojo::test::blink::TrivialStructWithTraitsPtr& input) {
    return input->value;
  }

  static bool Read(::mojo::test::blink::TrivialStructWithTraits::DataView input, ::mojo::test::blink::TrivialStructWithTraitsPtr* output);
};


template <>
struct  StructTraits<::mojo::test::blink::MoveOnlyStructWithTraits::DataView,
                                         ::mojo::test::blink::MoveOnlyStructWithTraitsPtr> {
  static bool IsNull(const ::mojo::test::blink::MoveOnlyStructWithTraitsPtr& input) { return !input; }
  static void SetToNull(::mojo::test::blink::MoveOnlyStructWithTraitsPtr* output) { output->reset(); }

  static  decltype(::mojo::test::blink::MoveOnlyStructWithTraits::f_handle)& f_handle(
       ::mojo::test::blink::MoveOnlyStructWithTraitsPtr& input) {
    return input->f_handle;
  }

  static bool Read(::mojo::test::blink::MoveOnlyStructWithTraits::DataView input, ::mojo::test::blink::MoveOnlyStructWithTraitsPtr* output);
};


template <>
struct  StructTraits<::mojo::test::blink::MoveOnlyStructWithTraitsContainer::DataView,
                                         ::mojo::test::blink::MoveOnlyStructWithTraitsContainerPtr> {
  static bool IsNull(const ::mojo::test::blink::MoveOnlyStructWithTraitsContainerPtr& input) { return !input; }
  static void SetToNull(::mojo::test::blink::MoveOnlyStructWithTraitsContainerPtr* output) { output->reset(); }

  static  decltype(::mojo::test::blink::MoveOnlyStructWithTraitsContainer::f_struct)& f_struct(
       ::mojo::test::blink::MoveOnlyStructWithTraitsContainerPtr& input) {
    return input->f_struct;
  }

  static bool Read(::mojo::test::blink::MoveOnlyStructWithTraitsContainer::DataView input, ::mojo::test::blink::MoveOnlyStructWithTraitsContainerPtr* output);
};


template <>
struct  StructTraits<::mojo::test::blink::StructWithTraitsForUniquePtr::DataView,
                                         ::mojo::test::blink::StructWithTraitsForUniquePtrPtr> {
  static bool IsNull(const ::mojo::test::blink::StructWithTraitsForUniquePtrPtr& input) { return !input; }
  static void SetToNull(::mojo::test::blink::StructWithTraitsForUniquePtrPtr* output) { output->reset(); }

  static decltype(::mojo::test::blink::StructWithTraitsForUniquePtr::f_int32) f_int32(
      const ::mojo::test::blink::StructWithTraitsForUniquePtrPtr& input) {
    return input->f_int32;
  }

  static bool Read(::mojo::test::blink::StructWithTraitsForUniquePtr::DataView input, ::mojo::test::blink::StructWithTraitsForUniquePtrPtr* output);
};


template <>
struct  StructTraits<::mojo::test::blink::EnumWithTraitsContainer::DataView,
                                         ::mojo::test::blink::EnumWithTraitsContainerPtr> {
  static bool IsNull(const ::mojo::test::blink::EnumWithTraitsContainerPtr& input) { return !input; }
  static void SetToNull(::mojo::test::blink::EnumWithTraitsContainerPtr* output) { output->reset(); }

  static decltype(::mojo::test::blink::EnumWithTraitsContainer::f_field) f_field(
      const ::mojo::test::blink::EnumWithTraitsContainerPtr& input) {
    return input->f_field;
  }

  static bool Read(::mojo::test::blink::EnumWithTraitsContainer::DataView input, ::mojo::test::blink::EnumWithTraitsContainerPtr* output);
};


template <>
struct  StructTraits<::mojo::test::blink::StructForceSerialize::DataView,
                                         ::mojo::test::blink::StructForceSerializePtr> {
  static bool IsNull(const ::mojo::test::blink::StructForceSerializePtr& input) { return !input; }
  static void SetToNull(::mojo::test::blink::StructForceSerializePtr* output) { output->reset(); }

  static decltype(::mojo::test::blink::StructForceSerialize::value) value(
      const ::mojo::test::blink::StructForceSerializePtr& input) {
    return input->value;
  }

  static bool Read(::mojo::test::blink::StructForceSerialize::DataView input, ::mojo::test::blink::StructForceSerializePtr* output);
};


template <>
struct  StructTraits<::mojo::test::blink::StructNestedForceSerialize::DataView,
                                         ::mojo::test::blink::StructNestedForceSerializePtr> {
  static bool IsNull(const ::mojo::test::blink::StructNestedForceSerializePtr& input) { return !input; }
  static void SetToNull(::mojo::test::blink::StructNestedForceSerializePtr* output) { output->reset(); }

  static const decltype(::mojo::test::blink::StructNestedForceSerialize::force)& force(
      const ::mojo::test::blink::StructNestedForceSerializePtr& input) {
    return input->force;
  }

  static bool Read(::mojo::test::blink::StructNestedForceSerialize::DataView input, ::mojo::test::blink::StructNestedForceSerializePtr* output);
};


template <>
struct  UnionTraits<::mojo::test::blink::UnionWithTraits::DataView,
                                        ::mojo::test::blink::UnionWithTraitsPtr> {
  static bool IsNull(const ::mojo::test::blink::UnionWithTraitsPtr& input) { return !input; }
  static void SetToNull(::mojo::test::blink::UnionWithTraitsPtr* output) { output->reset(); }

  static ::mojo::test::blink::UnionWithTraits::Tag GetTag(const ::mojo::test::blink::UnionWithTraitsPtr& input) {
    return input->which();
  }

  static  int32_t f_int32(const ::mojo::test::blink::UnionWithTraitsPtr& input) {
    return input->get_f_int32();
  }

  static const ::mojo::test::blink::NestedStructWithTraitsPtr& f_struct(const ::mojo::test::blink::UnionWithTraitsPtr& input) {
    return input->get_f_struct();
  }

  static bool Read(::mojo::test::blink::UnionWithTraits::DataView input, ::mojo::test::blink::UnionWithTraitsPtr* output);
};

}  // namespace mojo

#endif  // MOJO_PUBLIC_INTERFACES_BINDINGS_TESTS_STRUCT_WITH_TRAITS_MOJOM_BLINK_H_
/* Metadata comment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*/