Google Git
Sign in
chromium / chromium / src / out / 4151107ea1613e89152c1a944bd45944683cc1f2 / . / android-Debug / gen / mojo / public / interfaces / bindings / tests / validation_test_interfaces.mojom-blink.h
blob: a2243fb6164e51b93d675babea1848108331261b [file] [log] [blame]
// mojo/public/interfaces/bindings/tests/validation_test_interfaces.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_VALIDATION_TEST_INTERFACES_MOJOM_BLINK_H_
#define MOJO_PUBLIC_INTERFACES_BINDINGS_TESTS_VALIDATION_TEST_INTERFACES_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/validation_test_interfaces.mojom-shared.h"
#include "mojo/public/interfaces/bindings/tests/validation_test_interfaces.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_EnumA_DataHashFn {
static unsigned GetHash(const ::mojo::test::EnumA& value) {
using utype = std::underlying_type<::mojo::test::EnumA>::type;
return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
}
static bool Equal(const ::mojo::test::EnumA& left, const ::mojo::test::EnumA& right) {
return left == right;
}
static const bool safe_to_compare_to_empty_or_deleted = true;
};
template <>
struct HashTraits<::mojo::test::EnumA>
: public GenericHashTraits<::mojo::test::EnumA> {
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::EnumA EmptyValue() { return static_cast<::mojo::test::EnumA>(-1000000); }
static void ConstructDeletedValue(::mojo::test::EnumA& slot, bool) {
slot = static_cast<::mojo::test::EnumA>(-1000001);
}
static bool IsDeletedValue(const ::mojo::test::EnumA& value) {
return value == static_cast<::mojo::test::EnumA>(-1000001);
}
};
} // namespace WTF
namespace WTF {
struct mojo_test_internal_EnumB_DataHashFn {
static unsigned GetHash(const ::mojo::test::EnumB& value) {
using utype = std::underlying_type<::mojo::test::EnumB>::type;
return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
}
static bool Equal(const ::mojo::test::EnumB& left, const ::mojo::test::EnumB& right) {
return left == right;
}
static const bool safe_to_compare_to_empty_or_deleted = true;
};
template <>
struct HashTraits<::mojo::test::EnumB>
: public GenericHashTraits<::mojo::test::EnumB> {
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::EnumB EmptyValue() { return static_cast<::mojo::test::EnumB>(-1000000); }
static void ConstructDeletedValue(::mojo::test::EnumB& slot, bool) {
slot = static_cast<::mojo::test::EnumB>(-1000001);
}
static bool IsDeletedValue(const ::mojo::test::EnumB& value) {
return value == static_cast<::mojo::test::EnumB>(-1000001);
}
};
} // namespace WTF
namespace WTF {
struct mojo_test_internal_EmptyEnum_DataHashFn {
static unsigned GetHash(const ::mojo::test::EmptyEnum& value) {
using utype = std::underlying_type<::mojo::test::EmptyEnum>::type;
return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
}
static bool Equal(const ::mojo::test::EmptyEnum& left, const ::mojo::test::EmptyEnum& right) {
return left == right;
}
static const bool safe_to_compare_to_empty_or_deleted = true;
};
template <>
struct HashTraits<::mojo::test::EmptyEnum>
: public GenericHashTraits<::mojo::test::EmptyEnum> {
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::EmptyEnum EmptyValue() { return static_cast<::mojo::test::EmptyEnum>(-1000000); }
static void ConstructDeletedValue(::mojo::test::EmptyEnum& slot, bool) {
slot = static_cast<::mojo::test::EmptyEnum>(-1000001);
}
static bool IsDeletedValue(const ::mojo::test::EmptyEnum& value) {
return value == static_cast<::mojo::test::EmptyEnum>(-1000001);
}
};
} // namespace WTF
namespace WTF {
struct mojo_test_internal_ExtensibleEmptyEnum_DataHashFn {
static unsigned GetHash(const ::mojo::test::ExtensibleEmptyEnum& value) {
using utype = std::underlying_type<::mojo::test::ExtensibleEmptyEnum>::type;
return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
}
static bool Equal(const ::mojo::test::ExtensibleEmptyEnum& left, const ::mojo::test::ExtensibleEmptyEnum& right) {
return left == right;
}
static const bool safe_to_compare_to_empty_or_deleted = true;
};
template <>
struct HashTraits<::mojo::test::ExtensibleEmptyEnum>
: public GenericHashTraits<::mojo::test::ExtensibleEmptyEnum> {
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::ExtensibleEmptyEnum EmptyValue() { return static_cast<::mojo::test::ExtensibleEmptyEnum>(-1000000); }
static void ConstructDeletedValue(::mojo::test::ExtensibleEmptyEnum& slot, bool) {
slot = static_cast<::mojo::test::ExtensibleEmptyEnum>(-1000001);
}
static bool IsDeletedValue(const ::mojo::test::ExtensibleEmptyEnum& value) {
return value == static_cast<::mojo::test::ExtensibleEmptyEnum>(-1000001);
}
};
} // namespace WTF
namespace WTF {
struct mojo_test_internal_BasicEnum_DataHashFn {
static unsigned GetHash(const ::mojo::test::BasicEnum& value) {
using utype = std::underlying_type<::mojo::test::BasicEnum>::type;
return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
}
static bool Equal(const ::mojo::test::BasicEnum& left, const ::mojo::test::BasicEnum& right) {
return left == right;
}
static const bool safe_to_compare_to_empty_or_deleted = true;
};
template <>
struct HashTraits<::mojo::test::BasicEnum>
: public GenericHashTraits<::mojo::test::BasicEnum> {
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::BasicEnum EmptyValue() { return static_cast<::mojo::test::BasicEnum>(-1000000); }
static void ConstructDeletedValue(::mojo::test::BasicEnum& slot, bool) {
slot = static_cast<::mojo::test::BasicEnum>(-1000001);
}
static bool IsDeletedValue(const ::mojo::test::BasicEnum& value) {
return value == static_cast<::mojo::test::BasicEnum>(-1000001);
}
};
} // namespace WTF
namespace WTF {
struct mojo_test_internal_StructWithEnum_EnumWithin_DataHashFn {
static unsigned GetHash(const ::mojo::test::StructWithEnum_EnumWithin& value) {
using utype = std::underlying_type<::mojo::test::StructWithEnum_EnumWithin>::type;
return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
}
static bool Equal(const ::mojo::test::StructWithEnum_EnumWithin& left, const ::mojo::test::StructWithEnum_EnumWithin& right) {
return left == right;
}
static const bool safe_to_compare_to_empty_or_deleted = true;
};
template <>
struct HashTraits<::mojo::test::StructWithEnum_EnumWithin>
: public GenericHashTraits<::mojo::test::StructWithEnum_EnumWithin> {
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::StructWithEnum_EnumWithin EmptyValue() { return static_cast<::mojo::test::StructWithEnum_EnumWithin>(-1000000); }
static void ConstructDeletedValue(::mojo::test::StructWithEnum_EnumWithin& slot, bool) {
slot = static_cast<::mojo::test::StructWithEnum_EnumWithin>(-1000001);
}
static bool IsDeletedValue(const ::mojo::test::StructWithEnum_EnumWithin& value) {
return value == static_cast<::mojo::test::StructWithEnum_EnumWithin>(-1000001);
}
};
} // namespace WTF
namespace mojo {
namespace test {
namespace blink {
class InterfaceAProxy;
template <typename ImplRefTraits>
class InterfaceAStub;
class InterfaceARequestValidator;
// @generated_from: mojo.test.InterfaceA
class InterfaceA
: public InterfaceAInterfaceBase {
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_ = InterfaceAInterfaceBase;
using Proxy_ = InterfaceAProxy;
template <typename ImplRefTraits>
using Stub_ = InterfaceAStub<ImplRefTraits>;
using RequestValidator_ = InterfaceARequestValidator;
using ResponseValidator_ = mojo::PassThroughFilter;
enum MethodMinVersions : uint32_t {
};
// 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)
#endif // !BUILDFLAG(IS_FUCHSIA)
virtual ~InterfaceA() = default;
};
class BoundsCheckTestInterfaceProxy;
template <typename ImplRefTraits>
class BoundsCheckTestInterfaceStub;
class BoundsCheckTestInterfaceRequestValidator;
class BoundsCheckTestInterfaceResponseValidator;
// @generated_from: mojo.test.BoundsCheckTestInterface
class BoundsCheckTestInterface
: public BoundsCheckTestInterfaceInterfaceBase {
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_ = BoundsCheckTestInterfaceInterfaceBase;
using Proxy_ = BoundsCheckTestInterfaceProxy;
template <typename ImplRefTraits>
using Stub_ = BoundsCheckTestInterfaceStub<ImplRefTraits>;
using RequestValidator_ = BoundsCheckTestInterfaceRequestValidator;
using ResponseValidator_ = BoundsCheckTestInterfaceResponseValidator;
enum MethodMinVersions : uint32_t {
kMethod0MinVersion = 0,
kMethod1MinVersion = 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 Method0_Sym {
NOINLINE static void IPCSymbol();
};
struct Method1_Sym {
NOINLINE static void IPCSymbol();
};
#endif // !BUILDFLAG(IS_FUCHSIA)
virtual ~BoundsCheckTestInterface() = default;
using Method0Callback = base::OnceCallback<void(uint8_t)>;
// @generated_from: mojo.test.BoundsCheckTestInterface.Method0
virtual void Method0(uint8_t param0, Method0Callback callback) = 0;
// @generated_from: mojo.test.BoundsCheckTestInterface.Method1
virtual void Method1(uint8_t param0) = 0;
};
class ConformanceTestInterfaceProxy;
template <typename ImplRefTraits>
class ConformanceTestInterfaceStub;
class ConformanceTestInterfaceRequestValidator;
class ConformanceTestInterfaceResponseValidator;
// @generated_from: mojo.test.ConformanceTestInterface
class ConformanceTestInterface
: public ConformanceTestInterfaceInterfaceBase {
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_ = ConformanceTestInterfaceInterfaceBase;
using Proxy_ = ConformanceTestInterfaceProxy;
template <typename ImplRefTraits>
using Stub_ = ConformanceTestInterfaceStub<ImplRefTraits>;
using RequestValidator_ = ConformanceTestInterfaceRequestValidator;
using ResponseValidator_ = ConformanceTestInterfaceResponseValidator;
enum MethodMinVersions : uint32_t {
kMethod0MinVersion = 0,
kMethod1MinVersion = 0,
kMethod2MinVersion = 0,
kMethod3MinVersion = 0,
kMethod4MinVersion = 0,
kMethod5MinVersion = 0,
kMethod6MinVersion = 0,
kMethod7MinVersion = 0,
kMethod8MinVersion = 0,
kMethod9MinVersion = 0,
kMethod10MinVersion = 0,
kMethod11MinVersion = 0,
kMethod12MinVersion = 0,
kMethod13MinVersion = 0,
kMethod14MinVersion = 0,
kMethod15MinVersion = 0,
kMethod16MinVersion = 0,
kMethod17MinVersion = 0,
kMethod18MinVersion = 0,
kMethod19MinVersion = 0,
kMethod20MinVersion = 0,
kMethod21MinVersion = 0,
kMethod22MinVersion = 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 Method0_Sym {
NOINLINE static void IPCSymbol();
};
struct Method1_Sym {
NOINLINE static void IPCSymbol();
};
struct Method2_Sym {
NOINLINE static void IPCSymbol();
};
struct Method3_Sym {
NOINLINE static void IPCSymbol();
};
struct Method4_Sym {
NOINLINE static void IPCSymbol();
};
struct Method5_Sym {
NOINLINE static void IPCSymbol();
};
struct Method6_Sym {
NOINLINE static void IPCSymbol();
};
struct Method7_Sym {
NOINLINE static void IPCSymbol();
};
struct Method8_Sym {
NOINLINE static void IPCSymbol();
};
struct Method9_Sym {
NOINLINE static void IPCSymbol();
};
struct Method10_Sym {
NOINLINE static void IPCSymbol();
};
struct Method11_Sym {
NOINLINE static void IPCSymbol();
};
struct Method12_Sym {
NOINLINE static void IPCSymbol();
};
struct Method13_Sym {
NOINLINE static void IPCSymbol();
};
struct Method14_Sym {
NOINLINE static void IPCSymbol();
};
struct Method15_Sym {
NOINLINE static void IPCSymbol();
};
struct Method16_Sym {
NOINLINE static void IPCSymbol();
};
struct Method17_Sym {
NOINLINE static void IPCSymbol();
};
struct Method18_Sym {
NOINLINE static void IPCSymbol();
};
struct Method19_Sym {
NOINLINE static void IPCSymbol();
};
struct Method20_Sym {
NOINLINE static void IPCSymbol();
};
struct Method21_Sym {
NOINLINE static void IPCSymbol();
};
struct Method22_Sym {
NOINLINE static void IPCSymbol();
};
#endif // !BUILDFLAG(IS_FUCHSIA)
virtual ~ConformanceTestInterface() = default;
// @generated_from: mojo.test.ConformanceTestInterface.Method0
virtual void Method0(float param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method1
virtual void Method1(StructAPtr param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method2
virtual void Method2(StructBPtr param0, StructAPtr param1) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method3
virtual void Method3(const WTF::Vector<bool>& param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method4
virtual void Method4(StructCPtr param0, const WTF::Vector<uint8_t>& param1) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method5
virtual void Method5(StructEPtr param0, ::mojo::ScopedDataPipeProducerHandle param1) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method6
virtual void Method6(const WTF::Vector<WTF::Vector<uint8_t>>& param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method7
virtual void Method7(StructFPtr param0, const WTF::Vector<absl::optional<WTF::Vector<uint8_t>>>& param1) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method8
virtual void Method8(const WTF::Vector<absl::optional<WTF::Vector<WTF::String>>>& param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method9
virtual void Method9(absl::optional<WTF::Vector<WTF::Vector<::mojo::ScopedHandle>>> param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method10
virtual void Method10(const WTF::HashMap<WTF::String, uint8_t>& param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method11
virtual void Method11(StructGPtr param0) = 0;
using Method12Callback = base::OnceCallback<void(float)>;
// @generated_from: mojo.test.ConformanceTestInterface.Method12
virtual void Method12(float param0, Method12Callback callback) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method13
virtual void Method13(::mojo::PendingRemote<InterfaceA> param0, uint32_t param1, ::mojo::PendingRemote<InterfaceA> param2) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method14
virtual void Method14(EnumA param0, EnumB param1) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method15
virtual void Method15(const absl::optional<WTF::Vector<EnumA>>& param0, const absl::optional<WTF::Vector<EnumB>>& param1) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method16
virtual void Method16(const absl::optional<WTF::HashMap<EnumA, EnumA>>& param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method17
virtual void Method17(WTF::Vector<::mojo::PendingRemote<InterfaceA>> param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method18
virtual void Method18(UnionAPtr param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method19
virtual void Method19(RecursivePtr recursive) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method20
virtual void Method20(WTF::HashMap<StructBPtr, uint8_t> param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method21
virtual void Method21(ExtensibleEmptyEnum param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method22
virtual void Method22(EmptyEnum param0) = 0;
};
class IntegrationTestInterfaceProxy;
template <typename ImplRefTraits>
class IntegrationTestInterfaceStub;
class IntegrationTestInterfaceRequestValidator;
class IntegrationTestInterfaceResponseValidator;
// @generated_from: mojo.test.IntegrationTestInterface
class IntegrationTestInterface
: public IntegrationTestInterfaceInterfaceBase {
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_ = IntegrationTestInterfaceInterfaceBase;
using Proxy_ = IntegrationTestInterfaceProxy;
template <typename ImplRefTraits>
using Stub_ = IntegrationTestInterfaceStub<ImplRefTraits>;
using RequestValidator_ = IntegrationTestInterfaceRequestValidator;
using ResponseValidator_ = IntegrationTestInterfaceResponseValidator;
enum MethodMinVersions : uint32_t {
kMethod0MinVersion = 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 Method0_Sym {
NOINLINE static void IPCSymbol();
};
#endif // !BUILDFLAG(IS_FUCHSIA)
virtual ~IntegrationTestInterface() = default;
using Method0Callback = base::OnceCallback<void(const WTF::Vector<uint8_t>&)>;
// @generated_from: mojo.test.IntegrationTestInterface.Method0
virtual void Method0(BasicStructPtr param0, Method0Callback callback) = 0;
};
// @generated_from: mojo.test.InterfaceA
class InterfaceAProxy
: public InterfaceA {
public:
using InterfaceType = InterfaceA;
explicit InterfaceAProxy(mojo::MessageReceiverWithResponder* receiver);
private:
mojo::MessageReceiverWithResponder* receiver_;
};
// @generated_from: mojo.test.BoundsCheckTestInterface
class BoundsCheckTestInterfaceProxy
: public BoundsCheckTestInterface {
public:
using InterfaceType = BoundsCheckTestInterface;
explicit BoundsCheckTestInterfaceProxy(mojo::MessageReceiverWithResponder* receiver);
// @generated_from: mojo.test.BoundsCheckTestInterface.Method0
void Method0(uint8_t param0, Method0Callback callback) final;
// @generated_from: mojo.test.BoundsCheckTestInterface.Method1
void Method1(uint8_t param0) final;
private:
mojo::MessageReceiverWithResponder* receiver_;
};
// @generated_from: mojo.test.ConformanceTestInterface
class ConformanceTestInterfaceProxy
: public ConformanceTestInterface {
public:
using InterfaceType = ConformanceTestInterface;
explicit ConformanceTestInterfaceProxy(mojo::MessageReceiverWithResponder* receiver);
// @generated_from: mojo.test.ConformanceTestInterface.Method0
void Method0(float param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method1
void Method1(StructAPtr param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method2
void Method2(StructBPtr param0, StructAPtr param1) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method3
void Method3(const WTF::Vector<bool>& param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method4
void Method4(StructCPtr param0, const WTF::Vector<uint8_t>& param1) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method5
void Method5(StructEPtr param0, ::mojo::ScopedDataPipeProducerHandle param1) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method6
void Method6(const WTF::Vector<WTF::Vector<uint8_t>>& param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method7
void Method7(StructFPtr param0, const WTF::Vector<absl::optional<WTF::Vector<uint8_t>>>& param1) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method8
void Method8(const WTF::Vector<absl::optional<WTF::Vector<WTF::String>>>& param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method9
void Method9(absl::optional<WTF::Vector<WTF::Vector<::mojo::ScopedHandle>>> param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method10
void Method10(const WTF::HashMap<WTF::String, uint8_t>& param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method11
void Method11(StructGPtr param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method12
void Method12(float param0, Method12Callback callback) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method13
void Method13(::mojo::PendingRemote<InterfaceA> param0, uint32_t param1, ::mojo::PendingRemote<InterfaceA> param2) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method14
void Method14(EnumA param0, EnumB param1) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method15
void Method15(const absl::optional<WTF::Vector<EnumA>>& param0, const absl::optional<WTF::Vector<EnumB>>& param1) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method16
void Method16(const absl::optional<WTF::HashMap<EnumA, EnumA>>& param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method17
void Method17(WTF::Vector<::mojo::PendingRemote<InterfaceA>> param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method18
void Method18(UnionAPtr param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method19
void Method19(RecursivePtr recursive) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method20
void Method20(WTF::HashMap<StructBPtr, uint8_t> param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method21
void Method21(ExtensibleEmptyEnum param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method22
void Method22(EmptyEnum param0) final;
private:
mojo::MessageReceiverWithResponder* receiver_;
};
// @generated_from: mojo.test.IntegrationTestInterface
class IntegrationTestInterfaceProxy
: public IntegrationTestInterface {
public:
using InterfaceType = IntegrationTestInterface;
explicit IntegrationTestInterfaceProxy(mojo::MessageReceiverWithResponder* receiver);
// @generated_from: mojo.test.IntegrationTestInterface.Method0
void Method0(BasicStructPtr param0, Method0Callback callback) final;
private:
mojo::MessageReceiverWithResponder* receiver_;
};
class InterfaceAStubDispatch {
public:
static bool Accept(InterfaceA* impl, mojo::Message* message);
static bool AcceptWithResponder(
InterfaceA* impl,
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};
template <typename ImplRefTraits =
mojo::RawPtrImplRefTraits<InterfaceA>>
class InterfaceAStub
: public mojo::MessageReceiverWithResponderStatus {
public:
using ImplPointerType = typename ImplRefTraits::PointerType;
InterfaceAStub() = default;
~InterfaceAStub() 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 InterfaceAStubDispatch::Accept(
ImplRefTraits::GetRawPointer(&sink_), message);
}
bool AcceptWithResponder(
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
if (ImplRefTraits::IsNull(sink_))
return false;
return InterfaceAStubDispatch::AcceptWithResponder(
ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
}
private:
ImplPointerType sink_;
};
class BoundsCheckTestInterfaceStubDispatch {
public:
static bool Accept(BoundsCheckTestInterface* impl, mojo::Message* message);
static bool AcceptWithResponder(
BoundsCheckTestInterface* impl,
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};
template <typename ImplRefTraits =
mojo::RawPtrImplRefTraits<BoundsCheckTestInterface>>
class BoundsCheckTestInterfaceStub
: public mojo::MessageReceiverWithResponderStatus {
public:
using ImplPointerType = typename ImplRefTraits::PointerType;
BoundsCheckTestInterfaceStub() = default;
~BoundsCheckTestInterfaceStub() 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 BoundsCheckTestInterfaceStubDispatch::Accept(
ImplRefTraits::GetRawPointer(&sink_), message);
}
bool AcceptWithResponder(
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
if (ImplRefTraits::IsNull(sink_))
return false;
return BoundsCheckTestInterfaceStubDispatch::AcceptWithResponder(
ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
}
private:
ImplPointerType sink_;
};
class ConformanceTestInterfaceStubDispatch {
public:
static bool Accept(ConformanceTestInterface* impl, mojo::Message* message);
static bool AcceptWithResponder(
ConformanceTestInterface* impl,
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};
template <typename ImplRefTraits =
mojo::RawPtrImplRefTraits<ConformanceTestInterface>>
class ConformanceTestInterfaceStub
: public mojo::MessageReceiverWithResponderStatus {
public:
using ImplPointerType = typename ImplRefTraits::PointerType;
ConformanceTestInterfaceStub() = default;
~ConformanceTestInterfaceStub() 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 ConformanceTestInterfaceStubDispatch::Accept(
ImplRefTraits::GetRawPointer(&sink_), message);
}
bool AcceptWithResponder(
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
if (ImplRefTraits::IsNull(sink_))
return false;
return ConformanceTestInterfaceStubDispatch::AcceptWithResponder(
ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
}
private:
ImplPointerType sink_;
};
class IntegrationTestInterfaceStubDispatch {
public:
static bool Accept(IntegrationTestInterface* impl, mojo::Message* message);
static bool AcceptWithResponder(
IntegrationTestInterface* impl,
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};
template <typename ImplRefTraits =
mojo::RawPtrImplRefTraits<IntegrationTestInterface>>
class IntegrationTestInterfaceStub
: public mojo::MessageReceiverWithResponderStatus {
public:
using ImplPointerType = typename ImplRefTraits::PointerType;
IntegrationTestInterfaceStub() = default;
~IntegrationTestInterfaceStub() 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 IntegrationTestInterfaceStubDispatch::Accept(
ImplRefTraits::GetRawPointer(&sink_), message);
}
bool AcceptWithResponder(
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
if (ImplRefTraits::IsNull(sink_))
return false;
return IntegrationTestInterfaceStubDispatch::AcceptWithResponder(
ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
}
private:
ImplPointerType sink_;
};
class InterfaceARequestValidator : public mojo::MessageReceiver {
public:
bool Accept(mojo::Message* message) override;
};
class BoundsCheckTestInterfaceRequestValidator : public mojo::MessageReceiver {
public:
bool Accept(mojo::Message* message) override;
};
class ConformanceTestInterfaceRequestValidator : public mojo::MessageReceiver {
public:
bool Accept(mojo::Message* message) override;
};
class IntegrationTestInterfaceRequestValidator : public mojo::MessageReceiver {
public:
bool Accept(mojo::Message* message) override;
};
class BoundsCheckTestInterfaceResponseValidator : public mojo::MessageReceiver {
public:
bool Accept(mojo::Message* message) override;
};
class ConformanceTestInterfaceResponseValidator : public mojo::MessageReceiver {
public:
bool Accept(mojo::Message* message) override;
};
class IntegrationTestInterfaceResponseValidator : public mojo::MessageReceiver {
public:
bool Accept(mojo::Message* message) override;
};
// @generated_from: mojo.test.StructA
class StructA {
public:
template <typename T>
using EnableIfSame = std::enable_if_t<std::is_same<StructA, T>::value>;
using DataView = StructADataView;
using Data_ = internal::StructA_Data;
template <typename... Args>
static StructAPtr New(Args&&... args) {
return StructAPtr(
absl::in_place, std::forward<Args>(args)...);
}
template <typename U>
static StructAPtr From(const U& u) {
return mojo::TypeConverter<StructAPtr, U>::Convert(u);
}
template <typename U>
U To() const {
return mojo::TypeConverter<U, StructA>::Convert(*this);
}
StructA();
explicit StructA(
uint64_t i);
~StructA();
// 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 = StructAPtr>
StructAPtr 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, StructA::EnableIfSame<T>* = nullptr>
bool Equals(const T& other) const;
template <typename T, StructA::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<
StructA::DataView, WTF::Vector<uint8_t>>(input);
}
template <typename UserType>
static mojo::Message SerializeAsMessage(UserType* input) {
return mojo::internal::SerializeAsMessageImpl<
StructA::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::StructA_UnserializedMessageContext<
UserType, StructA::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<StructA::DataView>(
message, data, data_num_bytes, output, Validate);
}
template <typename UserType>
static bool Deserialize(const WTF::Vector<uint8_t>& input,
UserType* output) {
return StructA::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::StructA_UnserializedMessageContext<
UserType, StructA::DataView>>();
if (context) {
*output = std::move(context->TakeData());
return true;
}
input.SerializeIfNecessary();
return mojo::internal::DeserializeImpl<StructA::DataView>(
input, input.payload(), input.payload_num_bytes(), output, Validate);
}
// @generated_from: mojo.test.StructA.i
uint64_t i;
// 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, StructA::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);
template <typename T, StructA::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
return !(rhs < lhs);
}
template <typename T, StructA::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
return rhs < lhs;
}
template <typename T, StructA::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
return !(lhs < rhs);
}
// @generated_from: mojo.test.BasicStruct
class BasicStruct {
public:
template <typename T>
using EnableIfSame = std::enable_if_t<std::is_same<BasicStruct, T>::value>;
using DataView = BasicStructDataView;
using Data_ = internal::BasicStruct_Data;
template <typename... Args>
static BasicStructPtr New(Args&&... args) {
return BasicStructPtr(
absl::in_place, std::forward<Args>(args)...);
}
template <typename U>
static BasicStructPtr From(const U& u) {
return mojo::TypeConverter<BasicStructPtr, U>::Convert(u);
}
template <typename U>
U To() const {
return mojo::TypeConverter<U, BasicStruct>::Convert(*this);
}
BasicStruct();
explicit BasicStruct(
int32_t a);
~BasicStruct();
// 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 = BasicStructPtr>
BasicStructPtr 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, BasicStruct::EnableIfSame<T>* = nullptr>
bool Equals(const T& other) const;
template <typename T, BasicStruct::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<
BasicStruct::DataView, WTF::Vector<uint8_t>>(input);
}
template <typename UserType>
static mojo::Message SerializeAsMessage(UserType* input) {
return mojo::internal::SerializeAsMessageImpl<
BasicStruct::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::BasicStruct_UnserializedMessageContext<
UserType, BasicStruct::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<BasicStruct::DataView>(
message, data, data_num_bytes, output, Validate);
}
template <typename UserType>
static bool Deserialize(const WTF::Vector<uint8_t>& input,
UserType* output) {
return BasicStruct::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::BasicStruct_UnserializedMessageContext<
UserType, BasicStruct::DataView>>();
if (context) {
*output = std::move(context->TakeData());
return true;
}
input.SerializeIfNecessary();
return mojo::internal::DeserializeImpl<BasicStruct::DataView>(
input, input.payload(), input.payload_num_bytes(), output, Validate);
}
// @generated_from: mojo.test.BasicStruct.a
int32_t a;
// 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, BasicStruct::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);
template <typename T, BasicStruct::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
return !(rhs < lhs);
}
template <typename T, BasicStruct::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
return rhs < lhs;
}
template <typename T, BasicStruct::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
return !(lhs < rhs);
}
// @generated_from: mojo.test.StructWithEnum
class StructWithEnum {
public:
template <typename T>
using EnableIfSame = std::enable_if_t<std::is_same<StructWithEnum, T>::value>;
using DataView = StructWithEnumDataView;
using Data_ = internal::StructWithEnum_Data;
// @generated_from: mojo.test.StructWithEnum.EnumWithin
using EnumWithin = StructWithEnum_EnumWithin;
template <typename... Args>
static StructWithEnumPtr New(Args&&... args) {
return StructWithEnumPtr(
absl::in_place, std::forward<Args>(args)...);
}
template <typename U>
static StructWithEnumPtr From(const U& u) {
return mojo::TypeConverter<StructWithEnumPtr, U>::Convert(u);
}
template <typename U>
U To() const {
return mojo::TypeConverter<U, StructWithEnum>::Convert(*this);
}
StructWithEnum();
~StructWithEnum();
// 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 = StructWithEnumPtr>
StructWithEnumPtr 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, StructWithEnum::EnableIfSame<T>* = nullptr>
bool Equals(const T& other) const;
template <typename T, StructWithEnum::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<
StructWithEnum::DataView, WTF::Vector<uint8_t>>(input);
}
template <typename UserType>
static mojo::Message SerializeAsMessage(UserType* input) {
return mojo::internal::SerializeAsMessageImpl<
StructWithEnum::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::StructWithEnum_UnserializedMessageContext<
UserType, StructWithEnum::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<StructWithEnum::DataView>(
message, data, data_num_bytes, output, Validate);
}
template <typename UserType>
static bool Deserialize(const WTF::Vector<uint8_t>& input,
UserType* output) {
return StructWithEnum::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::StructWithEnum_UnserializedMessageContext<
UserType, StructWithEnum::DataView>>();
if (context) {
*output = std::move(context->TakeData());
return true;
}
input.SerializeIfNecessary();
return mojo::internal::DeserializeImpl<StructWithEnum::DataView>(
input, input.payload(), input.payload_num_bytes(), output, Validate);
}
// 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, StructWithEnum::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);
template <typename T, StructWithEnum::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
return !(rhs < lhs);
}
template <typename T, StructWithEnum::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
return rhs < lhs;
}
template <typename T, StructWithEnum::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
return !(lhs < rhs);
}
// @generated_from: mojo.test.UnionA
class UnionA {
public:
using DataView = UnionADataView;
using Data_ = internal::UnionA_Data;
using Tag = Data_::UnionA_Tag;
template <typename... Args>
static UnionAPtr 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 |struct_a|.
static UnionAPtr
NewStructA(
StructAPtr struct_a) {
auto result = UnionAPtr(absl::in_place);
result->set_struct_a(std::move(struct_a));
return result;
}
// Construct an instance holding |b|.
static UnionAPtr
NewB(
bool b) {
auto result = UnionAPtr(absl::in_place);
result->set_b(std::move(b));
return result;
}
template <typename U>
static UnionAPtr From(const U& u) {
return mojo::TypeConverter<UnionAPtr, U>::Convert(u);
}
template <typename U>
U To() const {
return mojo::TypeConverter<U, UnionA>::Convert(*this);
}
UnionA();
~UnionA();
// 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 = UnionAPtr>
UnionAPtr 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, UnionA>::value>::type* = nullptr>
bool Equals(const T& other) const;
template <typename T,
typename std::enable_if<std::is_same<
T, UnionA>::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.UnionA.struct_a
bool is_struct_a() const { return tag_ == Tag::kStructA; }
// @generated_from: mojo.test.UnionA.struct_a
StructAPtr& get_struct_a() const {
CHECK(tag_ == Tag::kStructA);
return *(data_.struct_a);
}
// @generated_from: mojo.test.UnionA.struct_a
void set_struct_a(
StructAPtr struct_a);
// @generated_from: mojo.test.UnionA.b
bool is_b() const { return tag_ == Tag::kB; }
// @generated_from: mojo.test.UnionA.b
bool get_b() const {
CHECK(tag_ == Tag::kB);
return data_.b;
}
// @generated_from: mojo.test.UnionA.b
void set_b(
bool b);
template <typename UserType>
static mojo::Message SerializeAsMessage(UserType* input) {
return mojo::internal::SerializeAsMessageImpl<
UnionA::DataView>(input);
}
template <typename UserType>
static bool DeserializeFromMessage(mojo::Message input,
UserType* output) {
return mojo::internal::DeserializeImpl<UnionA::DataView>(
input, input.payload(), input.payload_num_bytes(), output, Validate);
}
private:
union Union_ {
Union_() = default;
~Union_() = default;
StructAPtr* struct_a;
bool b;
};
static bool Validate(const void* data,
mojo::internal::ValidationContext* validation_context);
void DestroyActive();
Tag tag_;
Union_ data_;
};
// @generated_from: mojo.test.StructB
class StructB {
public:
template <typename T>
using EnableIfSame = std::enable_if_t<std::is_same<StructB, T>::value>;
using DataView = StructBDataView;
using Data_ = internal::StructB_Data;
template <typename... Args>
static StructBPtr New(Args&&... args) {
return StructBPtr(
absl::in_place, std::forward<Args>(args)...);
}
template <typename U>
static StructBPtr From(const U& u) {
return mojo::TypeConverter<StructBPtr, U>::Convert(u);
}
template <typename U>
U To() const {
return mojo::TypeConverter<U, StructB>::Convert(*this);
}
StructB();
explicit StructB(
StructAPtr struct_a);
StructB(const StructB&) = delete;
StructB& operator=(const StructB&) = delete;
~StructB();
// 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 = StructBPtr>
StructBPtr 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, StructB::EnableIfSame<T>* = nullptr>
bool Equals(const T& other) const;
template <typename T, StructB::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<
StructB::DataView, WTF::Vector<uint8_t>>(input);
}
template <typename UserType>
static mojo::Message SerializeAsMessage(UserType* input) {
return mojo::internal::SerializeAsMessageImpl<
StructB::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::StructB_UnserializedMessageContext<
UserType, StructB::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<StructB::DataView>(
message, data, data_num_bytes, output, Validate);
}
template <typename UserType>
static bool Deserialize(const WTF::Vector<uint8_t>& input,
UserType* output) {
return StructB::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::StructB_UnserializedMessageContext<
UserType, StructB::DataView>>();
if (context) {
*output = std::move(context->TakeData());
return true;
}
input.SerializeIfNecessary();
return mojo::internal::DeserializeImpl<StructB::DataView>(
input, input.payload(), input.payload_num_bytes(), output, Validate);
}
// @generated_from: mojo.test.StructB.struct_a
StructAPtr struct_a;
// 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, StructB::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);
template <typename T, StructB::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
return !(rhs < lhs);
}
template <typename T, StructB::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
return rhs < lhs;
}
template <typename T, StructB::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
return !(lhs < rhs);
}
// @generated_from: mojo.test.StructC
class StructC {
public:
template <typename T>
using EnableIfSame = std::enable_if_t<std::is_same<StructC, T>::value>;
using DataView = StructCDataView;
using Data_ = internal::StructC_Data;
template <typename... Args>
static StructCPtr New(Args&&... args) {
return StructCPtr(
absl::in_place, std::forward<Args>(args)...);
}
template <typename U>
static StructCPtr From(const U& u) {
return mojo::TypeConverter<StructCPtr, U>::Convert(u);
}
template <typename U>
U To() const {
return mojo::TypeConverter<U, StructC>::Convert(*this);
}
StructC();
explicit StructC(
WTF::Vector<uint8_t> data);
~StructC();
// 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 = StructCPtr>
StructCPtr 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, StructC::EnableIfSame<T>* = nullptr>
bool Equals(const T& other) const;
template <typename T, StructC::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<
StructC::DataView, WTF::Vector<uint8_t>>(input);
}
template <typename UserType>
static mojo::Message SerializeAsMessage(UserType* input) {
return mojo::internal::SerializeAsMessageImpl<
StructC::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::StructC_UnserializedMessageContext<
UserType, StructC::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<StructC::DataView>(
message, data, data_num_bytes, output, Validate);
}
template <typename UserType>
static bool Deserialize(const WTF::Vector<uint8_t>& input,
UserType* output) {
return StructC::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::StructC_UnserializedMessageContext<
UserType, StructC::DataView>>();
if (context) {
*output = std::move(context->TakeData());
return true;
}
input.SerializeIfNecessary();
return mojo::internal::DeserializeImpl<StructC::DataView>(
input, input.payload(), input.payload_num_bytes(), output, Validate);
}
// @generated_from: mojo.test.StructC.data
WTF::Vector<uint8_t> data;
// 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, StructC::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);
template <typename T, StructC::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
return !(rhs < lhs);
}
template <typename T, StructC::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
return rhs < lhs;
}
template <typename T, StructC::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
return !(lhs < rhs);
}
// @generated_from: mojo.test.StructD
class StructD {
public:
template <typename T>
using EnableIfSame = std::enable_if_t<std::is_same<StructD, T>::value>;
using DataView = StructDDataView;
using Data_ = internal::StructD_Data;
template <typename... Args>
static StructDPtr New(Args&&... args) {
return StructDPtr(
absl::in_place, std::forward<Args>(args)...);
}
template <typename U>
static StructDPtr From(const U& u) {
return mojo::TypeConverter<StructDPtr, U>::Convert(u);
}
template <typename U>
U To() const {
return mojo::TypeConverter<U, StructD>::Convert(*this);
}
StructD();
explicit StructD(
WTF::Vector<::mojo::ScopedMessagePipeHandle> message_pipes);
StructD(const StructD&) = delete;
StructD& operator=(const StructD&) = delete;
~StructD();
// 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 = StructDPtr>
StructDPtr 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, StructD::EnableIfSame<T>* = nullptr>
bool Equals(const T& other) const;
template <typename T, StructD::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<
StructD::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::StructD_UnserializedMessageContext<
UserType, StructD::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<StructD::DataView>(
message, data, data_num_bytes, output, Validate);
}
template <typename UserType>
static bool Deserialize(const WTF::Vector<uint8_t>& input,
UserType* output) {
return StructD::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::StructD_UnserializedMessageContext<
UserType, StructD::DataView>>();
if (context) {
*output = std::move(context->TakeData());
return true;
}
input.SerializeIfNecessary();
return mojo::internal::DeserializeImpl<StructD::DataView>(
input, input.payload(), input.payload_num_bytes(), output, Validate);
}
// @generated_from: mojo.test.StructD.message_pipes
WTF::Vector<::mojo::ScopedMessagePipeHandle> message_pipes;
// 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, StructD::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);
template <typename T, StructD::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
return !(rhs < lhs);
}
template <typename T, StructD::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
return rhs < lhs;
}
template <typename T, StructD::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
return !(lhs < rhs);
}
// @generated_from: mojo.test.StructE
class StructE {
public:
template <typename T>
using EnableIfSame = std::enable_if_t<std::is_same<StructE, T>::value>;
using DataView = StructEDataView;
using Data_ = internal::StructE_Data;
template <typename... Args>
static StructEPtr New(Args&&... args) {
return StructEPtr(
absl::in_place, std::forward<Args>(args)...);
}
template <typename U>
static StructEPtr From(const U& u) {
return mojo::TypeConverter<StructEPtr, U>::Convert(u);
}
template <typename U>
U To() const {
return mojo::TypeConverter<U, StructE>::Convert(*this);
}
StructE();
StructE(
StructDPtr struct_d,
::mojo::ScopedDataPipeConsumerHandle data_pipe_consumer);
StructE(const StructE&) = delete;
StructE& operator=(const StructE&) = delete;
~StructE();
// 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 = StructEPtr>
StructEPtr 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, StructE::EnableIfSame<T>* = nullptr>
bool Equals(const T& other) const;
template <typename T, StructE::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<
StructE::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::StructE_UnserializedMessageContext<
UserType, StructE::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<StructE::DataView>(
message, data, data_num_bytes, output, Validate);
}
template <typename UserType>
static bool Deserialize(const WTF::Vector<uint8_t>& input,
UserType* output) {
return StructE::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::StructE_UnserializedMessageContext<
UserType, StructE::DataView>>();
if (context) {
*output = std::move(context->TakeData());
return true;
}
input.SerializeIfNecessary();
return mojo::internal::DeserializeImpl<StructE::DataView>(
input, input.payload(), input.payload_num_bytes(), output, Validate);
}
// @generated_from: mojo.test.StructE.struct_d
StructDPtr struct_d;
// @generated_from: mojo.test.StructE.data_pipe_consumer
::mojo::ScopedDataPipeConsumerHandle data_pipe_consumer;
// 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, StructE::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);
template <typename T, StructE::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
return !(rhs < lhs);
}
template <typename T, StructE::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
return rhs < lhs;
}
template <typename T, StructE::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
return !(lhs < rhs);
}
// @generated_from: mojo.test.StructF
class StructF {
public:
template <typename T>
using EnableIfSame = std::enable_if_t<std::is_same<StructF, T>::value>;
using DataView = StructFDataView;
using Data_ = internal::StructF_Data;
template <typename... Args>
static StructFPtr New(Args&&... args) {
return StructFPtr(
absl::in_place, std::forward<Args>(args)...);
}
template <typename U>
static StructFPtr From(const U& u) {
return mojo::TypeConverter<StructFPtr, U>::Convert(u);
}
template <typename U>
U To() const {
return mojo::TypeConverter<U, StructF>::Convert(*this);
}
StructF();
explicit StructF(
WTF::Vector<uint8_t> fixed_size_array);
~StructF();
// 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 = StructFPtr>
StructFPtr 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, StructF::EnableIfSame<T>* = nullptr>
bool Equals(const T& other) const;
template <typename T, StructF::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<
StructF::DataView, WTF::Vector<uint8_t>>(input);
}
template <typename UserType>
static mojo::Message SerializeAsMessage(UserType* input) {
return mojo::internal::SerializeAsMessageImpl<
StructF::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::StructF_UnserializedMessageContext<
UserType, StructF::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<StructF::DataView>(
message, data, data_num_bytes, output, Validate);
}
template <typename UserType>
static bool Deserialize(const WTF::Vector<uint8_t>& input,
UserType* output) {
return StructF::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::StructF_UnserializedMessageContext<
UserType, StructF::DataView>>();
if (context) {
*output = std::move(context->TakeData());
return true;
}
input.SerializeIfNecessary();
return mojo::internal::DeserializeImpl<StructF::DataView>(
input, input.payload(), input.payload_num_bytes(), output, Validate);
}
// @generated_from: mojo.test.StructF.fixed_size_array
WTF::Vector<uint8_t> fixed_size_array;
// 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, StructF::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);
template <typename T, StructF::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
return !(rhs < lhs);
}
template <typename T, StructF::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
return rhs < lhs;
}
template <typename T, StructF::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
return !(lhs < rhs);
}
// @generated_from: mojo.test.StructG
class StructG {
public:
template <typename T>
using EnableIfSame = std::enable_if_t<std::is_same<StructG, T>::value>;
using DataView = StructGDataView;
using Data_ = internal::StructG_Data;
template <typename... Args>
static StructGPtr New(Args&&... args) {
return StructGPtr(
absl::in_place, std::forward<Args>(args)...);
}
template <typename U>
static StructGPtr From(const U& u) {
return mojo::TypeConverter<StructGPtr, U>::Convert(u);
}
template <typename U>
U To() const {
return mojo::TypeConverter<U, StructG>::Convert(*this);
}
StructG();
explicit StructG(
int32_t i);
StructG(
int32_t i,
StructAPtr struct_a);
StructG(
int32_t i,
StructAPtr struct_a,
const WTF::String& str,
bool b);
StructG(const StructG&) = delete;
StructG& operator=(const StructG&) = delete;
~StructG();
// 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 = StructGPtr>
StructGPtr 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, StructG::EnableIfSame<T>* = nullptr>
bool Equals(const T& other) const;
template <typename T, StructG::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<
StructG::DataView, WTF::Vector<uint8_t>>(input);
}
template <typename UserType>
static mojo::Message SerializeAsMessage(UserType* input) {
return mojo::internal::SerializeAsMessageImpl<
StructG::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::StructG_UnserializedMessageContext<
UserType, StructG::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<StructG::DataView>(
message, data, data_num_bytes, output, Validate);
}
template <typename UserType>
static bool Deserialize(const WTF::Vector<uint8_t>& input,
UserType* output) {
return StructG::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::StructG_UnserializedMessageContext<
UserType, StructG::DataView>>();
if (context) {
*output = std::move(context->TakeData());
return true;
}
input.SerializeIfNecessary();
return mojo::internal::DeserializeImpl<StructG::DataView>(
input, input.payload(), input.payload_num_bytes(), output, Validate);
}
// @generated_from: mojo.test.StructG.i
int32_t i;
// @generated_from: mojo.test.StructG.struct_a
StructAPtr struct_a;
// @generated_from: mojo.test.StructG.str
WTF::String str;
// @generated_from: mojo.test.StructG.b
bool b;
// 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, StructG::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);
template <typename T, StructG::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
return !(rhs < lhs);
}
template <typename T, StructG::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
return rhs < lhs;
}
template <typename T, StructG::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
return !(lhs < rhs);
}
// @generated_from: mojo.test.Recursive
class Recursive {
public:
template <typename T>
using EnableIfSame = std::enable_if_t<std::is_same<Recursive, T>::value>;
using DataView = RecursiveDataView;
using Data_ = internal::Recursive_Data;
template <typename... Args>
static RecursivePtr New(Args&&... args) {
return RecursivePtr(
absl::in_place, std::forward<Args>(args)...);
}
template <typename U>
static RecursivePtr From(const U& u) {
return mojo::TypeConverter<RecursivePtr, U>::Convert(u);
}
template <typename U>
U To() const {
return mojo::TypeConverter<U, Recursive>::Convert(*this);
}
Recursive();
explicit Recursive(
RecursivePtr recursive);
Recursive(const Recursive&) = delete;
Recursive& operator=(const Recursive&) = delete;
~Recursive();
// 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 = RecursivePtr>
RecursivePtr 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, Recursive::EnableIfSame<T>* = nullptr>
bool Equals(const T& other) const;
template <typename T, Recursive::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<
Recursive::DataView, WTF::Vector<uint8_t>>(input);
}
template <typename UserType>
static mojo::Message SerializeAsMessage(UserType* input) {
return mojo::internal::SerializeAsMessageImpl<
Recursive::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::Recursive_UnserializedMessageContext<
UserType, Recursive::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<Recursive::DataView>(
message, data, data_num_bytes, output, Validate);
}
template <typename UserType>
static bool Deserialize(const WTF::Vector<uint8_t>& input,
UserType* output) {
return Recursive::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::Recursive_UnserializedMessageContext<
UserType, Recursive::DataView>>();
if (context) {
*output = std::move(context->TakeData());
return true;
}
input.SerializeIfNecessary();
return mojo::internal::DeserializeImpl<Recursive::DataView>(
input, input.payload(), input.payload_num_bytes(), output, Validate);
}
// @generated_from: mojo.test.Recursive.recursive
RecursivePtr recursive;
// 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, Recursive::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);
template <typename T, Recursive::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
return !(rhs < lhs);
}
template <typename T, Recursive::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
return rhs < lhs;
}
template <typename T, Recursive::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
return !(lhs < rhs);
}
template <typename UnionPtrType>
UnionAPtr UnionA::Clone() const {
switch (tag_) {
case Tag::kStructA:
return NewStructA(
mojo::Clone(*data_.struct_a));
case Tag::kB:
return NewB(
mojo::Clone(data_.b));
}
return nullptr;
}
template <typename T,
typename std::enable_if<std::is_same<
T, UnionA>::value>::type*>
bool UnionA::Equals(const T& other) const {
if (tag_ != other.which())
return false;
switch (tag_) {
case Tag::kStructA:
return mojo::Equals(*(data_.struct_a), *(other.data_.struct_a));
case Tag::kB:
return mojo::Equals(data_.b, other.data_.b);
}
return false;
}
template <typename StructPtrType>
StructAPtr StructA::Clone() const {
return New(
mojo::Clone(i)
);
}
template <typename T, StructA::EnableIfSame<T>*>
bool StructA::Equals(const T& other_struct) const {
if (!mojo::Equals(this->i, other_struct.i))
return false;
return true;
}
template <typename T, StructA::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
if (lhs.i < rhs.i)
return true;
if (rhs.i < lhs.i)
return false;
return false;
}
template <typename StructPtrType>
StructBPtr StructB::Clone() const {
return New(
mojo::Clone(struct_a)
);
}
template <typename T, StructB::EnableIfSame<T>*>
bool StructB::Equals(const T& other_struct) const {
if (!mojo::Equals(this->struct_a, other_struct.struct_a))
return false;
return true;
}
template <typename T, StructB::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
if (lhs.struct_a < rhs.struct_a)
return true;
if (rhs.struct_a < lhs.struct_a)
return false;
return false;
}
template <typename StructPtrType>
StructCPtr StructC::Clone() const {
return New(
mojo::Clone(data)
);
}
template <typename T, StructC::EnableIfSame<T>*>
bool StructC::Equals(const T& other_struct) const {
if (!mojo::Equals(this->data, other_struct.data))
return false;
return true;
}
template <typename T, StructC::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
if (lhs.data < rhs.data)
return true;
if (rhs.data < lhs.data)
return false;
return false;
}
template <typename StructPtrType>
StructDPtr StructD::Clone() const {
return New(
mojo::Clone(message_pipes)
);
}
template <typename T, StructD::EnableIfSame<T>*>
bool StructD::Equals(const T& other_struct) const {
if (!mojo::Equals(this->message_pipes, other_struct.message_pipes))
return false;
return true;
}
template <typename T, StructD::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
if (lhs.message_pipes < rhs.message_pipes)
return true;
if (rhs.message_pipes < lhs.message_pipes)
return false;
return false;
}
template <typename StructPtrType>
StructEPtr StructE::Clone() const {
return New(
mojo::Clone(struct_d),
mojo::Clone(data_pipe_consumer)
);
}
template <typename T, StructE::EnableIfSame<T>*>
bool StructE::Equals(const T& other_struct) const {
if (!mojo::Equals(this->struct_d, other_struct.struct_d))
return false;
if (!mojo::Equals(this->data_pipe_consumer, other_struct.data_pipe_consumer))
return false;
return true;
}
template <typename T, StructE::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
if (lhs.struct_d < rhs.struct_d)
return true;
if (rhs.struct_d < lhs.struct_d)
return false;
if (lhs.data_pipe_consumer < rhs.data_pipe_consumer)
return true;
if (rhs.data_pipe_consumer < lhs.data_pipe_consumer)
return false;
return false;
}
template <typename StructPtrType>
StructFPtr StructF::Clone() const {
return New(
mojo::Clone(fixed_size_array)
);
}
template <typename T, StructF::EnableIfSame<T>*>
bool StructF::Equals(const T& other_struct) const {
if (!mojo::Equals(this->fixed_size_array, other_struct.fixed_size_array))
return false;
return true;
}
template <typename T, StructF::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
if (lhs.fixed_size_array < rhs.fixed_size_array)
return true;
if (rhs.fixed_size_array < lhs.fixed_size_array)
return false;
return false;
}
template <typename StructPtrType>
StructGPtr StructG::Clone() const {
return New(
mojo::Clone(i),
mojo::Clone(struct_a),
mojo::Clone(str),
mojo::Clone(b)
);
}
template <typename T, StructG::EnableIfSame<T>*>
bool StructG::Equals(const T& other_struct) const {
if (!mojo::Equals(this->i, other_struct.i))
return false;
if (!mojo::Equals(this->struct_a, other_struct.struct_a))
return false;
if (!mojo::Equals(this->str, other_struct.str))
return false;
if (!mojo::Equals(this->b, other_struct.b))
return false;
return true;
}
template <typename T, StructG::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
if (lhs.i < rhs.i)
return true;
if (rhs.i < lhs.i)
return false;
if (lhs.struct_a < rhs.struct_a)
return true;
if (rhs.struct_a < lhs.struct_a)
return false;
if (lhs.str < rhs.str)
return true;
if (rhs.str < lhs.str)
return false;
if (lhs.b < rhs.b)
return true;
if (rhs.b < lhs.b)
return false;
return false;
}
template <typename StructPtrType>
BasicStructPtr BasicStruct::Clone() const {
return New(
mojo::Clone(a)
);
}
template <typename T, BasicStruct::EnableIfSame<T>*>
bool BasicStruct::Equals(const T& other_struct) const {
if (!mojo::Equals(this->a, other_struct.a))
return false;
return true;
}
template <typename T, BasicStruct::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
if (lhs.a < rhs.a)
return true;
if (rhs.a < lhs.a)
return false;
return false;
}
template <typename StructPtrType>
StructWithEnumPtr StructWithEnum::Clone() const {
return New(
);
}
template <typename T, StructWithEnum::EnableIfSame<T>*>
bool StructWithEnum::Equals(const T& other_struct) const {
return true;
}
template <typename T, StructWithEnum::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
return false;
}
template <typename StructPtrType>
RecursivePtr Recursive::Clone() const {
return New(
mojo::Clone(recursive)
);
}
template <typename T, Recursive::EnableIfSame<T>*>
bool Recursive::Equals(const T& other_struct) const {
if (!mojo::Equals(this->recursive, other_struct.recursive))
return false;
return true;
}
template <typename T, Recursive::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
if (lhs.recursive < rhs.recursive)
return true;
if (rhs.recursive < lhs.recursive)
return false;
return false;
}
} // namespace blink
} // namespace test
} // namespace mojo
namespace mojo {
template <>
struct StructTraits<::mojo::test::blink::StructA::DataView,
::mojo::test::blink::StructAPtr> {
static bool IsNull(const ::mojo::test::blink::StructAPtr& input) { return !input; }
static void SetToNull(::mojo::test::blink::StructAPtr* output) { output->reset(); }
static decltype(::mojo::test::blink::StructA::i) i(
const ::mojo::test::blink::StructAPtr& input) {
return input->i;
}
static bool Read(::mojo::test::blink::StructA::DataView input, ::mojo::test::blink::StructAPtr* output);
};
template <>
struct StructTraits<::mojo::test::blink::StructB::DataView,
::mojo::test::blink::StructBPtr> {
static bool IsNull(const ::mojo::test::blink::StructBPtr& input) { return !input; }
static void SetToNull(::mojo::test::blink::StructBPtr* output) { output->reset(); }
static const decltype(::mojo::test::blink::StructB::struct_a)& struct_a(
const ::mojo::test::blink::StructBPtr& input) {
return input->struct_a;
}
static bool Read(::mojo::test::blink::StructB::DataView input, ::mojo::test::blink::StructBPtr* output);
};
template <>
struct StructTraits<::mojo::test::blink::StructC::DataView,
::mojo::test::blink::StructCPtr> {
static bool IsNull(const ::mojo::test::blink::StructCPtr& input) { return !input; }
static void SetToNull(::mojo::test::blink::StructCPtr* output) { output->reset(); }
static const decltype(::mojo::test::blink::StructC::data)& data(
const ::mojo::test::blink::StructCPtr& input) {
return input->data;
}
static bool Read(::mojo::test::blink::StructC::DataView input, ::mojo::test::blink::StructCPtr* output);
};
template <>
struct StructTraits<::mojo::test::blink::StructD::DataView,
::mojo::test::blink::StructDPtr> {
static bool IsNull(const ::mojo::test::blink::StructDPtr& input) { return !input; }
static void SetToNull(::mojo::test::blink::StructDPtr* output) { output->reset(); }
static decltype(::mojo::test::blink::StructD::message_pipes)& message_pipes(
::mojo::test::blink::StructDPtr& input) {
return input->message_pipes;
}
static bool Read(::mojo::test::blink::StructD::DataView input, ::mojo::test::blink::StructDPtr* output);
};
template <>
struct StructTraits<::mojo::test::blink::StructE::DataView,
::mojo::test::blink::StructEPtr> {
static bool IsNull(const ::mojo::test::blink::StructEPtr& input) { return !input; }
static void SetToNull(::mojo::test::blink::StructEPtr* output) { output->reset(); }
static decltype(::mojo::test::blink::StructE::struct_d)& struct_d(
::mojo::test::blink::StructEPtr& input) {
return input->struct_d;
}
static decltype(::mojo::test::blink::StructE::data_pipe_consumer)& data_pipe_consumer(
::mojo::test::blink::StructEPtr& input) {
return input->data_pipe_consumer;
}
static bool Read(::mojo::test::blink::StructE::DataView input, ::mojo::test::blink::StructEPtr* output);
};
template <>
struct StructTraits<::mojo::test::blink::StructF::DataView,
::mojo::test::blink::StructFPtr> {
static bool IsNull(const ::mojo::test::blink::StructFPtr& input) { return !input; }
static void SetToNull(::mojo::test::blink::StructFPtr* output) { output->reset(); }
static const decltype(::mojo::test::blink::StructF::fixed_size_array)& fixed_size_array(
const ::mojo::test::blink::StructFPtr& input) {
return input->fixed_size_array;
}
static bool Read(::mojo::test::blink::StructF::DataView input, ::mojo::test::blink::StructFPtr* output);
};
template <>
struct StructTraits<::mojo::test::blink::StructG::DataView,
::mojo::test::blink::StructGPtr> {
static bool IsNull(const ::mojo::test::blink::StructGPtr& input) { return !input; }
static void SetToNull(::mojo::test::blink::StructGPtr* output) { output->reset(); }
static decltype(::mojo::test::blink::StructG::i) i(
const ::mojo::test::blink::StructGPtr& input) {
return input->i;
}
static const decltype(::mojo::test::blink::StructG::struct_a)& struct_a(
const ::mojo::test::blink::StructGPtr& input) {
return input->struct_a;
}
static const decltype(::mojo::test::blink::StructG::str)& str(
const ::mojo::test::blink::StructGPtr& input) {
return input->str;
}
static decltype(::mojo::test::blink::StructG::b) b(
const ::mojo::test::blink::StructGPtr& input) {
return input->b;
}
static bool Read(::mojo::test::blink::StructG::DataView input, ::mojo::test::blink::StructGPtr* output);
};
template <>
struct StructTraits<::mojo::test::blink::BasicStruct::DataView,
::mojo::test::blink::BasicStructPtr> {
static bool IsNull(const ::mojo::test::blink::BasicStructPtr& input) { return !input; }
static void SetToNull(::mojo::test::blink::BasicStructPtr* output) { output->reset(); }
static decltype(::mojo::test::blink::BasicStruct::a) a(
const ::mojo::test::blink::BasicStructPtr& input) {
return input->a;
}
static bool Read(::mojo::test::blink::BasicStruct::DataView input, ::mojo::test::blink::BasicStructPtr* output);
};
template <>
struct StructTraits<::mojo::test::blink::StructWithEnum::DataView,
::mojo::test::blink::StructWithEnumPtr> {
static bool IsNull(const ::mojo::test::blink::StructWithEnumPtr& input) { return !input; }
static void SetToNull(::mojo::test::blink::StructWithEnumPtr* output) { output->reset(); }
static bool Read(::mojo::test::blink::StructWithEnum::DataView input, ::mojo::test::blink::StructWithEnumPtr* output);
};
template <>
struct StructTraits<::mojo::test::blink::Recursive::DataView,
::mojo::test::blink::RecursivePtr> {
static bool IsNull(const ::mojo::test::blink::RecursivePtr& input) { return !input; }
static void SetToNull(::mojo::test::blink::RecursivePtr* output) { output->reset(); }
static const decltype(::mojo::test::blink::Recursive::recursive)& recursive(
const ::mojo::test::blink::RecursivePtr& input) {
return input->recursive;
}
static bool Read(::mojo::test::blink::Recursive::DataView input, ::mojo::test::blink::RecursivePtr* output);
};
template <>
struct UnionTraits<::mojo::test::blink::UnionA::DataView,
::mojo::test::blink::UnionAPtr> {
static bool IsNull(const ::mojo::test::blink::UnionAPtr& input) { return !input; }
static void SetToNull(::mojo::test::blink::UnionAPtr* output) { output->reset(); }
static ::mojo::test::blink::UnionA::Tag GetTag(const ::mojo::test::blink::UnionAPtr& input) {
return input->which();
}
static const ::mojo::test::blink::StructAPtr& struct_a(const ::mojo::test::blink::UnionAPtr& input) {
return input->get_struct_a();
}
static bool b(const ::mojo::test::blink::UnionAPtr& input) {
return input->get_b();
}
static bool Read(::mojo::test::blink::UnionA::DataView input, ::mojo::test::blink::UnionAPtr* output);
};
} // namespace mojo
#endif // MOJO_PUBLIC_INTERFACES_BINDINGS_TESTS_VALIDATION_TEST_INTERFACES_MOJOM_BLINK_H_
/* Metadata comment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*/