android-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. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef MOJO_PUBLIC_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 <type_traits>
#include <utility>

#include "third_party/abseil-cpp/absl/types/optional.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-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/raw_ptr_impl_ref_traits.h"



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


namespace WTF {
struct mojo_test_internal_EnumWithTraits_DataHashFn {
  static unsigned GetHash(const ::mojo::test::EnumWithTraits& value) {
    using utype = std::underlying_type<::mojo::test::EnumWithTraits>::type;
    return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
  }
  static bool Equal(const ::mojo::test::EnumWithTraits& left, const ::mojo::test::EnumWithTraits& right) {
    return left == right;
  }
  static const bool safe_to_compare_to_empty_or_deleted = true;
};

template <>
struct HashTraits<::mojo::test::EnumWithTraits>
    : public GenericHashTraits<::mojo::test::EnumWithTraits> {
  static_assert(true,
                "-1000000 is a reserved enum value");
  static_assert(true,
                "-1000001 is a reserved enum value");
  static const bool kEmptyValueIsZero = false;
  static ::mojo::test::EnumWithTraits EmptyValue() { return static_cast<::mojo::test::EnumWithTraits>(-1000000); }
  static void ConstructDeletedValue(::mojo::test::EnumWithTraits& slot, bool) {
    slot = static_cast<::mojo::test::EnumWithTraits>(-1000001);
  }
  static bool IsDeletedValue(const ::mojo::test::EnumWithTraits& value) {
    return value == static_cast<::mojo::test::EnumWithTraits>(-1000001);
  }
};
}  // namespace WTF


namespace mojo {
namespace test {
namespace blink {

class TraitsTestServiceProxy;

template <typename ImplRefTraits>
class TraitsTestServiceStub;

class TraitsTestServiceRequestValidator;
class TraitsTestServiceResponseValidator;


// @generated_from: mojo.test.TraitsTestService
class  TraitsTestService
    : public TraitsTestServiceInterfaceBase {
 public:
  static const char Name_[];
  static std::pair<uint32_t, const void*> 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 HasSyncMethods_ = 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 void IPCSymbol();
  };
  struct EchoTrivialStructWithTraits_Sym {
    NOINLINE static void IPCSymbol();
  };
  struct EchoMoveOnlyStructWithTraits_Sym {
    NOINLINE static void IPCSymbol();
  };
  struct EchoNullableMoveOnlyStructWithTraits_Sym {
    NOINLINE static void IPCSymbol();
  };
  struct EchoEnumWithTraits_Sym {
    NOINLINE static void IPCSymbol();
  };
  struct EchoStructWithTraitsForUniquePtr_Sym {
    NOINLINE static void IPCSymbol();
  };
  struct EchoNullableStructWithTraitsForUniquePtr_Sym {
    NOINLINE static void IPCSymbol();
  };
  struct EchoUnionWithTraits_Sym {
    NOINLINE static void IPCSymbol();
  };
#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:
  static const char Name_[];
  static std::pair<uint32_t, const void*> 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 HasSyncMethods_ = 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 void IPCSymbol();
  };
#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:
  static const char Name_[];
  static std::pair<uint32_t, const void*> 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 HasSyncMethods_ = 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 void IPCSymbol();
  };
  struct SendNestedForceSerializedStruct_Sym {
    NOINLINE static void IPCSymbol();
  };
#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(
        absl::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); }
  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(
        absl::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); }
  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(
        absl::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); }
  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(
        absl::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); }
  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(
        absl::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); }
  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(
        absl::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); }
  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.");
  }
  // Construct an instance holding |f_int32|.
  static UnionWithTraitsPtr
  NewFInt32(
      int32_t f_int32) {
    auto result = UnionWithTraitsPtr(absl::in_place);
    result->set_f_int32(std::move(f_int32));
    return result;
  }
  // Construct an instance holding |f_struct|.
  static UnionWithTraitsPtr
  NewFStruct(
      NestedStructWithTraitsPtr f_struct) {
    auto result = UnionWithTraitsPtr(absl::in_place);
    result->set_f_struct(std::move(f_struct));
    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();

  // 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(
        absl::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 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(
        absl::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 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(
        absl::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 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(
        absl::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 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(
        absl::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); }
  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;
}


}  // namespace blink
}  // namespace test
}  // namespace mojo

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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*/