Google Git
Sign in
chromium / chromium / src / out / 4151107ea1613e89152c1a944bd45944683cc1f2 / . / android-Debug / gen / mojo / public / interfaces / bindings / tests / validation_test_interfaces.mojom.h
blob: a5d9265c1d11d29502a26e82e375ca40aebbf03c [file] [log] [blame]
// mojo/public/interfaces/bindings/tests/validation_test_interfaces.mojom.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_H_
#define MOJO_PUBLIC_INTERFACES_BINDINGS_TESTS_VALIDATION_TEST_INTERFACES_MOJOM_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-forward.h"
#include <string>
#include <vector>
#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 mojo {
namespace test {
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 std::vector<bool>& param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method4
virtual void Method4(StructCPtr param0, const std::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 std::vector<std::vector<uint8_t>>& param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method7
virtual void Method7(StructFPtr param0, const std::vector<absl::optional<std::vector<uint8_t>>>& param1) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method8
virtual void Method8(const std::vector<absl::optional<std::vector<std::string>>>& param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method9
virtual void Method9(absl::optional<std::vector<std::vector<::mojo::ScopedHandle>>> param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method10
virtual void Method10(const base::flat_map<std::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<std::vector<EnumA>>& param0, const absl::optional<std::vector<EnumB>>& param1) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method16
virtual void Method16(const absl::optional<base::flat_map<EnumA, EnumA>>& param0) = 0;
// @generated_from: mojo.test.ConformanceTestInterface.Method17
virtual void Method17(std::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(base::flat_map<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 std::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 std::vector<bool>& param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method4
void Method4(StructCPtr param0, const std::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 std::vector<std::vector<uint8_t>>& param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method7
void Method7(StructFPtr param0, const std::vector<absl::optional<std::vector<uint8_t>>>& param1) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method8
void Method8(const std::vector<absl::optional<std::vector<std::string>>>& param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method9
void Method9(absl::optional<std::vector<std::vector<::mojo::ScopedHandle>>> param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method10
void Method10(const base::flat_map<std::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<std::vector<EnumA>>& param0, const absl::optional<std::vector<EnumB>>& param1) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method16
void Method16(const absl::optional<base::flat_map<EnumA, EnumA>>& param0) final;
// @generated_from: mojo.test.ConformanceTestInterface.Method17
void Method17(std::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(base::flat_map<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 std::vector<uint8_t> Serialize(UserType* input) {
return mojo::internal::SerializeImpl<
StructA::DataView, std::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 std::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 std::vector<uint8_t> Serialize(UserType* input) {
return mojo::internal::SerializeImpl<
BasicStruct::DataView, std::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 std::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 std::vector<uint8_t> Serialize(UserType* input) {
return mojo::internal::SerializeImpl<
StructWithEnum::DataView, std::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 std::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 std::vector<uint8_t> Serialize(UserType* input) {
return mojo::internal::SerializeImpl<
StructB::DataView, std::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 std::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(
std::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 std::vector<uint8_t> Serialize(UserType* input) {
return mojo::internal::SerializeImpl<
StructC::DataView, std::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 std::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
std::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(
std::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 std::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
std::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 std::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(
std::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 std::vector<uint8_t> Serialize(UserType* input) {
return mojo::internal::SerializeImpl<
StructF::DataView, std::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 std::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
std::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 absl::optional<std::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 std::vector<uint8_t> Serialize(UserType* input) {
return mojo::internal::SerializeImpl<
StructG::DataView, std::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 std::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
absl::optional<std::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 std::vector<uint8_t> Serialize(UserType* input) {
return mojo::internal::SerializeImpl<
Recursive::DataView, std::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 std::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 test
} // namespace mojo
namespace mojo {
template <>
struct StructTraits<::mojo::test::StructA::DataView,
::mojo::test::StructAPtr> {
static bool IsNull(const ::mojo::test::StructAPtr& input) { return !input; }
static void SetToNull(::mojo::test::StructAPtr* output) { output->reset(); }
static decltype(::mojo::test::StructA::i) i(
const ::mojo::test::StructAPtr& input) {
return input->i;
}
static bool Read(::mojo::test::StructA::DataView input, ::mojo::test::StructAPtr* output);
};
template <>
struct StructTraits<::mojo::test::StructB::DataView,
::mojo::test::StructBPtr> {
static bool IsNull(const ::mojo::test::StructBPtr& input) { return !input; }
static void SetToNull(::mojo::test::StructBPtr* output) { output->reset(); }
static const decltype(::mojo::test::StructB::struct_a)& struct_a(
const ::mojo::test::StructBPtr& input) {
return input->struct_a;
}
static bool Read(::mojo::test::StructB::DataView input, ::mojo::test::StructBPtr* output);
};
template <>
struct StructTraits<::mojo::test::StructC::DataView,
::mojo::test::StructCPtr> {
static bool IsNull(const ::mojo::test::StructCPtr& input) { return !input; }
static void SetToNull(::mojo::test::StructCPtr* output) { output->reset(); }
static const decltype(::mojo::test::StructC::data)& data(
const ::mojo::test::StructCPtr& input) {
return input->data;
}
static bool Read(::mojo::test::StructC::DataView input, ::mojo::test::StructCPtr* output);
};
template <>
struct StructTraits<::mojo::test::StructD::DataView,
::mojo::test::StructDPtr> {
static bool IsNull(const ::mojo::test::StructDPtr& input) { return !input; }
static void SetToNull(::mojo::test::StructDPtr* output) { output->reset(); }
static decltype(::mojo::test::StructD::message_pipes)& message_pipes(
::mojo::test::StructDPtr& input) {
return input->message_pipes;
}
static bool Read(::mojo::test::StructD::DataView input, ::mojo::test::StructDPtr* output);
};
template <>
struct StructTraits<::mojo::test::StructE::DataView,
::mojo::test::StructEPtr> {
static bool IsNull(const ::mojo::test::StructEPtr& input) { return !input; }
static void SetToNull(::mojo::test::StructEPtr* output) { output->reset(); }
static decltype(::mojo::test::StructE::struct_d)& struct_d(
::mojo::test::StructEPtr& input) {
return input->struct_d;
}
static decltype(::mojo::test::StructE::data_pipe_consumer)& data_pipe_consumer(
::mojo::test::StructEPtr& input) {
return input->data_pipe_consumer;
}
static bool Read(::mojo::test::StructE::DataView input, ::mojo::test::StructEPtr* output);
};
template <>
struct StructTraits<::mojo::test::StructF::DataView,
::mojo::test::StructFPtr> {
static bool IsNull(const ::mojo::test::StructFPtr& input) { return !input; }
static void SetToNull(::mojo::test::StructFPtr* output) { output->reset(); }
static const decltype(::mojo::test::StructF::fixed_size_array)& fixed_size_array(
const ::mojo::test::StructFPtr& input) {
return input->fixed_size_array;
}
static bool Read(::mojo::test::StructF::DataView input, ::mojo::test::StructFPtr* output);
};
template <>
struct StructTraits<::mojo::test::StructG::DataView,
::mojo::test::StructGPtr> {
static bool IsNull(const ::mojo::test::StructGPtr& input) { return !input; }
static void SetToNull(::mojo::test::StructGPtr* output) { output->reset(); }
static decltype(::mojo::test::StructG::i) i(
const ::mojo::test::StructGPtr& input) {
return input->i;
}
static const decltype(::mojo::test::StructG::struct_a)& struct_a(
const ::mojo::test::StructGPtr& input) {
return input->struct_a;
}
static const decltype(::mojo::test::StructG::str)& str(
const ::mojo::test::StructGPtr& input) {
return input->str;
}
static decltype(::mojo::test::StructG::b) b(
const ::mojo::test::StructGPtr& input) {
return input->b;
}
static bool Read(::mojo::test::StructG::DataView input, ::mojo::test::StructGPtr* output);
};
template <>
struct StructTraits<::mojo::test::BasicStruct::DataView,
::mojo::test::BasicStructPtr> {
static bool IsNull(const ::mojo::test::BasicStructPtr& input) { return !input; }
static void SetToNull(::mojo::test::BasicStructPtr* output) { output->reset(); }
static decltype(::mojo::test::BasicStruct::a) a(
const ::mojo::test::BasicStructPtr& input) {
return input->a;
}
static bool Read(::mojo::test::BasicStruct::DataView input, ::mojo::test::BasicStructPtr* output);
};
template <>
struct StructTraits<::mojo::test::StructWithEnum::DataView,
::mojo::test::StructWithEnumPtr> {
static bool IsNull(const ::mojo::test::StructWithEnumPtr& input) { return !input; }
static void SetToNull(::mojo::test::StructWithEnumPtr* output) { output->reset(); }
static bool Read(::mojo::test::StructWithEnum::DataView input, ::mojo::test::StructWithEnumPtr* output);
};
template <>
struct StructTraits<::mojo::test::Recursive::DataView,
::mojo::test::RecursivePtr> {
static bool IsNull(const ::mojo::test::RecursivePtr& input) { return !input; }
static void SetToNull(::mojo::test::RecursivePtr* output) { output->reset(); }
static const decltype(::mojo::test::Recursive::recursive)& recursive(
const ::mojo::test::RecursivePtr& input) {
return input->recursive;
}
static bool Read(::mojo::test::Recursive::DataView input, ::mojo::test::RecursivePtr* output);
};
template <>
struct UnionTraits<::mojo::test::UnionA::DataView,
::mojo::test::UnionAPtr> {
static bool IsNull(const ::mojo::test::UnionAPtr& input) { return !input; }
static void SetToNull(::mojo::test::UnionAPtr* output) { output->reset(); }
static ::mojo::test::UnionA::Tag GetTag(const ::mojo::test::UnionAPtr& input) {
return input->which();
}
static const ::mojo::test::StructAPtr& struct_a(const ::mojo::test::UnionAPtr& input) {
return input->get_struct_a();
}
static bool b(const ::mojo::test::UnionAPtr& input) {
return input->get_b();
}
static bool Read(::mojo::test::UnionA::DataView input, ::mojo::test::UnionAPtr* output);
};
} // namespace mojo
#endif // MOJO_PUBLIC_INTERFACES_BINDINGS_TESTS_VALIDATION_TEST_INTERFACES_MOJOM_H_
/* Metadata comment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*/