| // WARNING: This file is machine generated by fidlgen. |
| |
| // fidl_experiment = output_index_json |
| |
| #pragma once |
| |
| #include <test/dependent/cpp/fidl.h> |
| |
| #include "lib/fidl/cpp/internal/header.h" |
| namespace test { |
| namespace bindingsdenylist { |
| |
| // |
| // Domain objects declarations |
| // |
| |
| #ifdef __Fuchsia__ |
| |
| class OnlyLibfuzzerAndDeps; |
| using OnlyLibfuzzerAndDepsHandle = ::fidl::InterfaceHandle<OnlyLibfuzzerAndDeps>; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class OnlyCppAndDeps; |
| using OnlyCppAndDepsHandle = ::fidl::InterfaceHandle<OnlyCppAndDeps>; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| class OnlyHlcpp; |
| |
| #endif // __Fuchsia__ |
| |
| class DenyEachBindingOnlyDenyDartRequest; |
| |
| class DenyEachBinding_OnlyDenyDart_Response; |
| |
| class DenyEachBinding_OnlyDenyDart_Result; |
| |
| class DenyEachBindingOnlyDenyGoRequest; |
| |
| class DenyEachBinding_OnlyDenyGo_Response; |
| |
| class DenyEachBinding_OnlyDenyGo_Result; |
| |
| class DenyEachBindingOnlyDenyLibfuzzerRequest; |
| |
| class DenyEachBinding_OnlyDenyLibfuzzer_Response; |
| |
| class DenyEachBinding_OnlyDenyLibfuzzer_Result; |
| |
| class DenyEachBindingOnlyDenyRustRequest; |
| |
| class DenyEachBinding_OnlyDenyRust_Response; |
| |
| class DenyEachBinding_OnlyDenyRust_Result; |
| |
| class DenyEachBindingOnlyDenySyzkallerRequest; |
| |
| class DenyEachBinding_OnlyDenySyzkaller_Response; |
| |
| class DenyEachBinding_OnlyDenySyzkaller_Result; |
| |
| #ifdef __Fuchsia__ |
| |
| class DenyEachBinding; |
| using DenyEachBindingHandle = ::fidl::InterfaceHandle<DenyEachBinding>; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class Allowed; |
| using AllowedHandle = ::fidl::InterfaceHandle<Allowed>; |
| |
| #endif // __Fuchsia__ |
| |
| class MemberOnlyAppearsInImportingLibrary; |
| |
| class OnlyAppearsInImportingLibrary; |
| |
| #ifdef __Fuchsia__ |
| |
| class ImportsSameNameContext; |
| using ImportsSameNameContextHandle = ::fidl::InterfaceHandle<ImportsSameNameContext>; |
| |
| #endif // __Fuchsia__ |
| |
| constexpr uint32_t AllBindings = 0u; |
| |
| #ifdef __Fuchsia__ |
| |
| class OnlyLibfuzzerAndDeps_RequestEncoder { |
| public: |
| }; |
| |
| class OnlyLibfuzzerAndDeps_ResponseEncoder { |
| public: |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class OnlyCppAndDeps_RequestEncoder { |
| public: |
| }; |
| |
| class OnlyCppAndDeps_ResponseEncoder { |
| public: |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| class DenyEachBindingOnlyDenyDartRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| bool a{}; |
| |
| static inline ::std::unique_ptr<DenyEachBindingOnlyDenyDartRequest> New() { return ::std::make_unique<DenyEachBindingOnlyDenyDartRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBindingOnlyDenyDartRequest* value, size_t _offset); |
| zx_status_t Clone(DenyEachBindingOnlyDenyDartRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBindingOnlyDenyDartRequest& _value, |
| ::test::bindingsdenylist::DenyEachBindingOnlyDenyDartRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using DenyEachBindingOnlyDenyDartRequestPtr = ::std::unique_ptr<DenyEachBindingOnlyDenyDartRequest>; |
| |
| class DenyEachBinding_OnlyDenyDart_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| DenyEachBinding_OnlyDenyDart_Response() = default; |
| explicit DenyEachBinding_OnlyDenyDart_Response(int32_t v) : b(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(b); } |
| explicit DenyEachBinding_OnlyDenyDart_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(b) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(b)); |
| } |
| |
| int32_t b{}; |
| |
| static inline ::std::unique_ptr<DenyEachBinding_OnlyDenyDart_Response> New() { return ::std::make_unique<DenyEachBinding_OnlyDenyDart_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBinding_OnlyDenyDart_Response* value, size_t _offset); |
| zx_status_t Clone(DenyEachBinding_OnlyDenyDart_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response& _value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using DenyEachBinding_OnlyDenyDart_ResponsePtr = ::std::unique_ptr<DenyEachBinding_OnlyDenyDart_Response>; |
| |
| class DenyEachBinding_OnlyDenyDart_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| DenyEachBinding_OnlyDenyDart_Result(); |
| ~DenyEachBinding_OnlyDenyDart_Result(); |
| |
| DenyEachBinding_OnlyDenyDart_Result(DenyEachBinding_OnlyDenyDart_Result&&); |
| DenyEachBinding_OnlyDenyDart_Result& operator=(DenyEachBinding_OnlyDenyDart_Result&&); |
| |
| static DenyEachBinding_OnlyDenyDart_Result WithResponse(::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response&&); |
| static DenyEachBinding_OnlyDenyDart_Result WithErr(uint32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<DenyEachBinding_OnlyDenyDart_Result> New() { return ::std::make_unique<DenyEachBinding_OnlyDenyDart_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBinding_OnlyDenyDart_Result* value, size_t offset); |
| zx_status_t Clone(DenyEachBinding_OnlyDenyDart_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result::Tag::kResponse; } |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response& response() { |
| EnsureStorageInitialized(::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| DenyEachBinding_OnlyDenyDart_Result& set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response value); |
| |
| bool is_err() const { return tag_ == ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result::Tag::kErr; } |
| |
| uint32_t& err() { |
| EnsureStorageInitialized(::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const uint32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| DenyEachBinding_OnlyDenyDart_Result& set_err(uint32_t value); |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result::Tag Which() const { |
| return ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result::Tag(tag_); |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result>; |
| DenyEachBinding_OnlyDenyDart_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response{std::move(result.value)}); |
| } |
| DenyEachBinding_OnlyDenyDart_Result(fpromise::error_result<uint32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| DenyEachBinding_OnlyDenyDart_Result(fpromise::result<int32_t, uint32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<int32_t, uint32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<int32_t> value_tuple = std::move(response()); |
| return fpromise::ok(std::move(std::get<0>(value_tuple))); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result::Tag::Invalid); |
| union { |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response response_; |
| uint32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using DenyEachBinding_OnlyDenyDart_ResultPtr = ::std::unique_ptr<DenyEachBinding_OnlyDenyDart_Result>; |
| |
| class DenyEachBindingOnlyDenyGoRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| bool a{}; |
| |
| static inline ::std::unique_ptr<DenyEachBindingOnlyDenyGoRequest> New() { return ::std::make_unique<DenyEachBindingOnlyDenyGoRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBindingOnlyDenyGoRequest* value, size_t _offset); |
| zx_status_t Clone(DenyEachBindingOnlyDenyGoRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBindingOnlyDenyGoRequest& _value, |
| ::test::bindingsdenylist::DenyEachBindingOnlyDenyGoRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using DenyEachBindingOnlyDenyGoRequestPtr = ::std::unique_ptr<DenyEachBindingOnlyDenyGoRequest>; |
| |
| class DenyEachBinding_OnlyDenyGo_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| DenyEachBinding_OnlyDenyGo_Response() = default; |
| explicit DenyEachBinding_OnlyDenyGo_Response(int32_t v) : b(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(b); } |
| explicit DenyEachBinding_OnlyDenyGo_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(b) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(b)); |
| } |
| |
| int32_t b{}; |
| |
| static inline ::std::unique_ptr<DenyEachBinding_OnlyDenyGo_Response> New() { return ::std::make_unique<DenyEachBinding_OnlyDenyGo_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBinding_OnlyDenyGo_Response* value, size_t _offset); |
| zx_status_t Clone(DenyEachBinding_OnlyDenyGo_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response& _value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using DenyEachBinding_OnlyDenyGo_ResponsePtr = ::std::unique_ptr<DenyEachBinding_OnlyDenyGo_Response>; |
| |
| class DenyEachBinding_OnlyDenyGo_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| DenyEachBinding_OnlyDenyGo_Result(); |
| ~DenyEachBinding_OnlyDenyGo_Result(); |
| |
| DenyEachBinding_OnlyDenyGo_Result(DenyEachBinding_OnlyDenyGo_Result&&); |
| DenyEachBinding_OnlyDenyGo_Result& operator=(DenyEachBinding_OnlyDenyGo_Result&&); |
| |
| static DenyEachBinding_OnlyDenyGo_Result WithResponse(::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response&&); |
| static DenyEachBinding_OnlyDenyGo_Result WithErr(uint32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<DenyEachBinding_OnlyDenyGo_Result> New() { return ::std::make_unique<DenyEachBinding_OnlyDenyGo_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBinding_OnlyDenyGo_Result* value, size_t offset); |
| zx_status_t Clone(DenyEachBinding_OnlyDenyGo_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result::Tag::kResponse; } |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response& response() { |
| EnsureStorageInitialized(::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| DenyEachBinding_OnlyDenyGo_Result& set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response value); |
| |
| bool is_err() const { return tag_ == ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result::Tag::kErr; } |
| |
| uint32_t& err() { |
| EnsureStorageInitialized(::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const uint32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| DenyEachBinding_OnlyDenyGo_Result& set_err(uint32_t value); |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result::Tag Which() const { |
| return ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result::Tag(tag_); |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result>; |
| DenyEachBinding_OnlyDenyGo_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response{std::move(result.value)}); |
| } |
| DenyEachBinding_OnlyDenyGo_Result(fpromise::error_result<uint32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| DenyEachBinding_OnlyDenyGo_Result(fpromise::result<int32_t, uint32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<int32_t, uint32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<int32_t> value_tuple = std::move(response()); |
| return fpromise::ok(std::move(std::get<0>(value_tuple))); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result::Tag::Invalid); |
| union { |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response response_; |
| uint32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using DenyEachBinding_OnlyDenyGo_ResultPtr = ::std::unique_ptr<DenyEachBinding_OnlyDenyGo_Result>; |
| |
| class DenyEachBindingOnlyDenyLibfuzzerRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| bool a{}; |
| |
| static inline ::std::unique_ptr<DenyEachBindingOnlyDenyLibfuzzerRequest> New() { return ::std::make_unique<DenyEachBindingOnlyDenyLibfuzzerRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBindingOnlyDenyLibfuzzerRequest* value, size_t _offset); |
| zx_status_t Clone(DenyEachBindingOnlyDenyLibfuzzerRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBindingOnlyDenyLibfuzzerRequest& _value, |
| ::test::bindingsdenylist::DenyEachBindingOnlyDenyLibfuzzerRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using DenyEachBindingOnlyDenyLibfuzzerRequestPtr = ::std::unique_ptr<DenyEachBindingOnlyDenyLibfuzzerRequest>; |
| |
| class DenyEachBinding_OnlyDenyLibfuzzer_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| DenyEachBinding_OnlyDenyLibfuzzer_Response() = default; |
| explicit DenyEachBinding_OnlyDenyLibfuzzer_Response(int32_t v) : b(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(b); } |
| explicit DenyEachBinding_OnlyDenyLibfuzzer_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(b) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(b)); |
| } |
| |
| int32_t b{}; |
| |
| static inline ::std::unique_ptr<DenyEachBinding_OnlyDenyLibfuzzer_Response> New() { return ::std::make_unique<DenyEachBinding_OnlyDenyLibfuzzer_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBinding_OnlyDenyLibfuzzer_Response* value, size_t _offset); |
| zx_status_t Clone(DenyEachBinding_OnlyDenyLibfuzzer_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response& _value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using DenyEachBinding_OnlyDenyLibfuzzer_ResponsePtr = ::std::unique_ptr<DenyEachBinding_OnlyDenyLibfuzzer_Response>; |
| |
| class DenyEachBinding_OnlyDenyLibfuzzer_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| DenyEachBinding_OnlyDenyLibfuzzer_Result(); |
| ~DenyEachBinding_OnlyDenyLibfuzzer_Result(); |
| |
| DenyEachBinding_OnlyDenyLibfuzzer_Result(DenyEachBinding_OnlyDenyLibfuzzer_Result&&); |
| DenyEachBinding_OnlyDenyLibfuzzer_Result& operator=(DenyEachBinding_OnlyDenyLibfuzzer_Result&&); |
| |
| static DenyEachBinding_OnlyDenyLibfuzzer_Result WithResponse(::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response&&); |
| static DenyEachBinding_OnlyDenyLibfuzzer_Result WithErr(uint32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<DenyEachBinding_OnlyDenyLibfuzzer_Result> New() { return ::std::make_unique<DenyEachBinding_OnlyDenyLibfuzzer_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBinding_OnlyDenyLibfuzzer_Result* value, size_t offset); |
| zx_status_t Clone(DenyEachBinding_OnlyDenyLibfuzzer_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result::Tag::kResponse; } |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response& response() { |
| EnsureStorageInitialized(::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| DenyEachBinding_OnlyDenyLibfuzzer_Result& set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response value); |
| |
| bool is_err() const { return tag_ == ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result::Tag::kErr; } |
| |
| uint32_t& err() { |
| EnsureStorageInitialized(::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const uint32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| DenyEachBinding_OnlyDenyLibfuzzer_Result& set_err(uint32_t value); |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result::Tag Which() const { |
| return ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result::Tag(tag_); |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result>; |
| DenyEachBinding_OnlyDenyLibfuzzer_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response{std::move(result.value)}); |
| } |
| DenyEachBinding_OnlyDenyLibfuzzer_Result(fpromise::error_result<uint32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| DenyEachBinding_OnlyDenyLibfuzzer_Result(fpromise::result<int32_t, uint32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<int32_t, uint32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<int32_t> value_tuple = std::move(response()); |
| return fpromise::ok(std::move(std::get<0>(value_tuple))); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result::Tag::Invalid); |
| union { |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response response_; |
| uint32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using DenyEachBinding_OnlyDenyLibfuzzer_ResultPtr = ::std::unique_ptr<DenyEachBinding_OnlyDenyLibfuzzer_Result>; |
| |
| class DenyEachBindingOnlyDenyRustRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| bool a{}; |
| |
| static inline ::std::unique_ptr<DenyEachBindingOnlyDenyRustRequest> New() { return ::std::make_unique<DenyEachBindingOnlyDenyRustRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBindingOnlyDenyRustRequest* value, size_t _offset); |
| zx_status_t Clone(DenyEachBindingOnlyDenyRustRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBindingOnlyDenyRustRequest& _value, |
| ::test::bindingsdenylist::DenyEachBindingOnlyDenyRustRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using DenyEachBindingOnlyDenyRustRequestPtr = ::std::unique_ptr<DenyEachBindingOnlyDenyRustRequest>; |
| |
| class DenyEachBinding_OnlyDenyRust_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| DenyEachBinding_OnlyDenyRust_Response() = default; |
| explicit DenyEachBinding_OnlyDenyRust_Response(int32_t v) : b(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(b); } |
| explicit DenyEachBinding_OnlyDenyRust_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(b) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(b)); |
| } |
| |
| int32_t b{}; |
| |
| static inline ::std::unique_ptr<DenyEachBinding_OnlyDenyRust_Response> New() { return ::std::make_unique<DenyEachBinding_OnlyDenyRust_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBinding_OnlyDenyRust_Response* value, size_t _offset); |
| zx_status_t Clone(DenyEachBinding_OnlyDenyRust_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response& _value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using DenyEachBinding_OnlyDenyRust_ResponsePtr = ::std::unique_ptr<DenyEachBinding_OnlyDenyRust_Response>; |
| |
| class DenyEachBinding_OnlyDenyRust_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| DenyEachBinding_OnlyDenyRust_Result(); |
| ~DenyEachBinding_OnlyDenyRust_Result(); |
| |
| DenyEachBinding_OnlyDenyRust_Result(DenyEachBinding_OnlyDenyRust_Result&&); |
| DenyEachBinding_OnlyDenyRust_Result& operator=(DenyEachBinding_OnlyDenyRust_Result&&); |
| |
| static DenyEachBinding_OnlyDenyRust_Result WithResponse(::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response&&); |
| static DenyEachBinding_OnlyDenyRust_Result WithErr(uint32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<DenyEachBinding_OnlyDenyRust_Result> New() { return ::std::make_unique<DenyEachBinding_OnlyDenyRust_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBinding_OnlyDenyRust_Result* value, size_t offset); |
| zx_status_t Clone(DenyEachBinding_OnlyDenyRust_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result::Tag::kResponse; } |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response& response() { |
| EnsureStorageInitialized(::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| DenyEachBinding_OnlyDenyRust_Result& set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response value); |
| |
| bool is_err() const { return tag_ == ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result::Tag::kErr; } |
| |
| uint32_t& err() { |
| EnsureStorageInitialized(::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const uint32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| DenyEachBinding_OnlyDenyRust_Result& set_err(uint32_t value); |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result::Tag Which() const { |
| return ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result::Tag(tag_); |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result>; |
| DenyEachBinding_OnlyDenyRust_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response{std::move(result.value)}); |
| } |
| DenyEachBinding_OnlyDenyRust_Result(fpromise::error_result<uint32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| DenyEachBinding_OnlyDenyRust_Result(fpromise::result<int32_t, uint32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<int32_t, uint32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<int32_t> value_tuple = std::move(response()); |
| return fpromise::ok(std::move(std::get<0>(value_tuple))); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result::Tag::Invalid); |
| union { |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response response_; |
| uint32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using DenyEachBinding_OnlyDenyRust_ResultPtr = ::std::unique_ptr<DenyEachBinding_OnlyDenyRust_Result>; |
| |
| class DenyEachBindingOnlyDenySyzkallerRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| bool a{}; |
| |
| static inline ::std::unique_ptr<DenyEachBindingOnlyDenySyzkallerRequest> New() { return ::std::make_unique<DenyEachBindingOnlyDenySyzkallerRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBindingOnlyDenySyzkallerRequest* value, size_t _offset); |
| zx_status_t Clone(DenyEachBindingOnlyDenySyzkallerRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBindingOnlyDenySyzkallerRequest& _value, |
| ::test::bindingsdenylist::DenyEachBindingOnlyDenySyzkallerRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using DenyEachBindingOnlyDenySyzkallerRequestPtr = ::std::unique_ptr<DenyEachBindingOnlyDenySyzkallerRequest>; |
| |
| class DenyEachBinding_OnlyDenySyzkaller_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| DenyEachBinding_OnlyDenySyzkaller_Response() = default; |
| explicit DenyEachBinding_OnlyDenySyzkaller_Response(int32_t v) : b(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(b); } |
| explicit DenyEachBinding_OnlyDenySyzkaller_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(b) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(b)); |
| } |
| |
| int32_t b{}; |
| |
| static inline ::std::unique_ptr<DenyEachBinding_OnlyDenySyzkaller_Response> New() { return ::std::make_unique<DenyEachBinding_OnlyDenySyzkaller_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBinding_OnlyDenySyzkaller_Response* value, size_t _offset); |
| zx_status_t Clone(DenyEachBinding_OnlyDenySyzkaller_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response& _value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using DenyEachBinding_OnlyDenySyzkaller_ResponsePtr = ::std::unique_ptr<DenyEachBinding_OnlyDenySyzkaller_Response>; |
| |
| class DenyEachBinding_OnlyDenySyzkaller_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| DenyEachBinding_OnlyDenySyzkaller_Result(); |
| ~DenyEachBinding_OnlyDenySyzkaller_Result(); |
| |
| DenyEachBinding_OnlyDenySyzkaller_Result(DenyEachBinding_OnlyDenySyzkaller_Result&&); |
| DenyEachBinding_OnlyDenySyzkaller_Result& operator=(DenyEachBinding_OnlyDenySyzkaller_Result&&); |
| |
| static DenyEachBinding_OnlyDenySyzkaller_Result WithResponse(::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response&&); |
| static DenyEachBinding_OnlyDenySyzkaller_Result WithErr(uint32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<DenyEachBinding_OnlyDenySyzkaller_Result> New() { return ::std::make_unique<DenyEachBinding_OnlyDenySyzkaller_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, DenyEachBinding_OnlyDenySyzkaller_Result* value, size_t offset); |
| zx_status_t Clone(DenyEachBinding_OnlyDenySyzkaller_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result::Tag::kResponse; } |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response& response() { |
| EnsureStorageInitialized(::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| DenyEachBinding_OnlyDenySyzkaller_Result& set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response value); |
| |
| bool is_err() const { return tag_ == ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result::Tag::kErr; } |
| |
| uint32_t& err() { |
| EnsureStorageInitialized(::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const uint32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| DenyEachBinding_OnlyDenySyzkaller_Result& set_err(uint32_t value); |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result::Tag Which() const { |
| return ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result::Tag(tag_); |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result>; |
| DenyEachBinding_OnlyDenySyzkaller_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response{std::move(result.value)}); |
| } |
| DenyEachBinding_OnlyDenySyzkaller_Result(fpromise::error_result<uint32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| DenyEachBinding_OnlyDenySyzkaller_Result(fpromise::result<int32_t, uint32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<int32_t, uint32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<int32_t> value_tuple = std::move(response()); |
| return fpromise::ok(std::move(std::get<0>(value_tuple))); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result::Tag::Invalid); |
| union { |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response response_; |
| uint32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using DenyEachBinding_OnlyDenySyzkaller_ResultPtr = ::std::unique_ptr<DenyEachBinding_OnlyDenySyzkaller_Result>; |
| |
| #ifdef __Fuchsia__ |
| |
| namespace _internal { |
| __LOCAL extern "C" const fidl_type_t test_bindingsdenylist_DenyEachBindingOnlyDenyDartRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_bindingsdenylist_DenyEachBindingOnlyDenyGoRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_bindingsdenylist_DenyEachBindingOnlyDenyLibfuzzerRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_bindingsdenylist_DenyEachBindingOnlyDenyRustRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_bindingsdenylist_DenyEachBindingOnlyDenySyzkallerRequestTable; |
| |
| } // namespace _internal |
| |
| class DenyEachBinding_RequestEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage OnlyDenyDart(::fidl::MessageEncoder* _encoder, bool* a) { |
| _encoder->Alloc(1); |
| ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t)); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OnlyDenyGo(::fidl::MessageEncoder* _encoder, bool* a) { |
| _encoder->Alloc(1); |
| ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t)); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OnlyDenyLibfuzzer(::fidl::MessageEncoder* _encoder, bool* a) { |
| _encoder->Alloc(1); |
| ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t)); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OnlyDenyRust(::fidl::MessageEncoder* _encoder, bool* a) { |
| _encoder->Alloc(1); |
| ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t)); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OnlyDenySyzkaller(::fidl::MessageEncoder* _encoder, bool* a) { |
| _encoder->Alloc(1); |
| ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t)); |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| namespace _internal { |
| __LOCAL extern "C" const fidl_type_t test_bindingsdenylist_DenyEachBinding_OnlyDenyDart_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_bindingsdenylist_DenyEachBinding_OnlyDenyGo_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_bindingsdenylist_DenyEachBinding_OnlyDenyLibfuzzer_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_bindingsdenylist_DenyEachBinding_OnlyDenyRust_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_bindingsdenylist_DenyEachBinding_OnlyDenySyzkaller_ResultTable; |
| |
| } // namespace _internal |
| |
| class DenyEachBinding_ResponseEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage OnlyDenyDart(::fidl::MessageEncoder* _encoder, ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result* DenyEachBinding_OnlyDenyDart_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, DenyEachBinding_OnlyDenyDart_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OnlyDenyGo(::fidl::MessageEncoder* _encoder, ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result* DenyEachBinding_OnlyDenyGo_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, DenyEachBinding_OnlyDenyGo_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OnlyDenyLibfuzzer(::fidl::MessageEncoder* _encoder, ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result* DenyEachBinding_OnlyDenyLibfuzzer_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, DenyEachBinding_OnlyDenyLibfuzzer_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OnlyDenyRust(::fidl::MessageEncoder* _encoder, ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result* DenyEachBinding_OnlyDenyRust_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, DenyEachBinding_OnlyDenyRust_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OnlyDenySyzkaller(::fidl::MessageEncoder* _encoder, ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result* DenyEachBinding_OnlyDenySyzkaller_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, DenyEachBinding_OnlyDenySyzkaller_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class Allowed_RequestEncoder { |
| public: |
| }; |
| |
| class Allowed_ResponseEncoder { |
| public: |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| class MemberOnlyAppearsInImportingLibrary final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| bool a{}; |
| |
| static inline ::std::unique_ptr<MemberOnlyAppearsInImportingLibrary> New() { return ::std::make_unique<MemberOnlyAppearsInImportingLibrary>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, MemberOnlyAppearsInImportingLibrary* value, size_t _offset); |
| zx_status_t Clone(MemberOnlyAppearsInImportingLibrary* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::MemberOnlyAppearsInImportingLibrary& _value, |
| ::test::bindingsdenylist::MemberOnlyAppearsInImportingLibrary* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using MemberOnlyAppearsInImportingLibraryPtr = ::std::unique_ptr<MemberOnlyAppearsInImportingLibrary>; |
| |
| class OnlyAppearsInImportingLibrary final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::bindingsdenylist::MemberOnlyAppearsInImportingLibrary member_only_appears_in_importing_library; |
| |
| static inline ::std::unique_ptr<OnlyAppearsInImportingLibrary> New() { return ::std::make_unique<OnlyAppearsInImportingLibrary>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, OnlyAppearsInImportingLibrary* value, size_t _offset); |
| zx_status_t Clone(OnlyAppearsInImportingLibrary* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::OnlyAppearsInImportingLibrary& _value, |
| ::test::bindingsdenylist::OnlyAppearsInImportingLibrary* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using OnlyAppearsInImportingLibraryPtr = ::std::unique_ptr<OnlyAppearsInImportingLibrary>; |
| |
| #ifdef __Fuchsia__ |
| |
| class ImportsSameNameContext_RequestEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage Unattributed(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage AlwaysAppearsInImportingLibrary(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| class ImportsSameNameContext_ResponseEncoder { |
| public: |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| } // namespace bindingsdenylist |
| } // namespace test |
| namespace fidl { |
| |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBindingOnlyDenyDartRequest> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBindingOnlyDenyDartRequest, 1> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::bindingsdenylist::DenyEachBindingOnlyDenyDartRequest> : public internal::BoolConstant< |
| !HasPadding<::test::bindingsdenylist::DenyEachBindingOnlyDenyDartRequest>::value && IsMemcpyCompatible<bool>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBindingOnlyDenyDartRequest& value, |
| ::test::bindingsdenylist::DenyEachBindingOnlyDenyDartRequest* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBindingOnlyDenyDartRequest> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBindingOnlyDenyDartRequest& _lhs, const ::test::bindingsdenylist::DenyEachBindingOnlyDenyDartRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.a, _rhs.a)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response, 4> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response> : public internal::BoolConstant< |
| !HasPadding<::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response>::value && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response& _lhs, const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.b, _rhs.b)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result); |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result& _lhs, const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result::Tag::Invalid): |
| return true; |
| case ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBindingOnlyDenyGoRequest> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBindingOnlyDenyGoRequest, 1> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::bindingsdenylist::DenyEachBindingOnlyDenyGoRequest> : public internal::BoolConstant< |
| !HasPadding<::test::bindingsdenylist::DenyEachBindingOnlyDenyGoRequest>::value && IsMemcpyCompatible<bool>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBindingOnlyDenyGoRequest& value, |
| ::test::bindingsdenylist::DenyEachBindingOnlyDenyGoRequest* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBindingOnlyDenyGoRequest> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBindingOnlyDenyGoRequest& _lhs, const ::test::bindingsdenylist::DenyEachBindingOnlyDenyGoRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.a, _rhs.a)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response, 4> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response> : public internal::BoolConstant< |
| !HasPadding<::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response>::value && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response& _lhs, const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.b, _rhs.b)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result); |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result& _lhs, const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result::Tag::Invalid): |
| return true; |
| case ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBindingOnlyDenyLibfuzzerRequest> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBindingOnlyDenyLibfuzzerRequest, 1> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::bindingsdenylist::DenyEachBindingOnlyDenyLibfuzzerRequest> : public internal::BoolConstant< |
| !HasPadding<::test::bindingsdenylist::DenyEachBindingOnlyDenyLibfuzzerRequest>::value && IsMemcpyCompatible<bool>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBindingOnlyDenyLibfuzzerRequest& value, |
| ::test::bindingsdenylist::DenyEachBindingOnlyDenyLibfuzzerRequest* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBindingOnlyDenyLibfuzzerRequest> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBindingOnlyDenyLibfuzzerRequest& _lhs, const ::test::bindingsdenylist::DenyEachBindingOnlyDenyLibfuzzerRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.a, _rhs.a)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response, 4> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response> : public internal::BoolConstant< |
| !HasPadding<::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response>::value && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response& _lhs, const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.b, _rhs.b)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result); |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result& _lhs, const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result::Tag::Invalid): |
| return true; |
| case ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBindingOnlyDenyRustRequest> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBindingOnlyDenyRustRequest, 1> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::bindingsdenylist::DenyEachBindingOnlyDenyRustRequest> : public internal::BoolConstant< |
| !HasPadding<::test::bindingsdenylist::DenyEachBindingOnlyDenyRustRequest>::value && IsMemcpyCompatible<bool>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBindingOnlyDenyRustRequest& value, |
| ::test::bindingsdenylist::DenyEachBindingOnlyDenyRustRequest* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBindingOnlyDenyRustRequest> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBindingOnlyDenyRustRequest& _lhs, const ::test::bindingsdenylist::DenyEachBindingOnlyDenyRustRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.a, _rhs.a)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response, 4> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response> : public internal::BoolConstant< |
| !HasPadding<::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response>::value && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response& _lhs, const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.b, _rhs.b)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result); |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result& _lhs, const ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result::Tag::Invalid): |
| return true; |
| case ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBindingOnlyDenySyzkallerRequest> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBindingOnlyDenySyzkallerRequest, 1> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::bindingsdenylist::DenyEachBindingOnlyDenySyzkallerRequest> : public internal::BoolConstant< |
| !HasPadding<::test::bindingsdenylist::DenyEachBindingOnlyDenySyzkallerRequest>::value && IsMemcpyCompatible<bool>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBindingOnlyDenySyzkallerRequest& value, |
| ::test::bindingsdenylist::DenyEachBindingOnlyDenySyzkallerRequest* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBindingOnlyDenySyzkallerRequest> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBindingOnlyDenySyzkallerRequest& _lhs, const ::test::bindingsdenylist::DenyEachBindingOnlyDenySyzkallerRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.a, _rhs.a)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response, 4> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response> : public internal::BoolConstant< |
| !HasPadding<::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response>::value && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response& _lhs, const ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.b, _rhs.b)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result> |
| : public EncodableCodingTraits<::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result); |
| |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result& value, |
| ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result> { |
| bool operator()(const ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result& _lhs, const ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result::Tag::Invalid): |
| return true; |
| case ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::MemberOnlyAppearsInImportingLibrary> |
| : public EncodableCodingTraits<::test::bindingsdenylist::MemberOnlyAppearsInImportingLibrary, 1> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::bindingsdenylist::MemberOnlyAppearsInImportingLibrary> : public internal::BoolConstant< |
| !HasPadding<::test::bindingsdenylist::MemberOnlyAppearsInImportingLibrary>::value && IsMemcpyCompatible<bool>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::MemberOnlyAppearsInImportingLibrary& value, |
| ::test::bindingsdenylist::MemberOnlyAppearsInImportingLibrary* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::MemberOnlyAppearsInImportingLibrary> { |
| bool operator()(const ::test::bindingsdenylist::MemberOnlyAppearsInImportingLibrary& _lhs, const ::test::bindingsdenylist::MemberOnlyAppearsInImportingLibrary& _rhs) const { |
| if (!::fidl::Equals(_lhs.a, _rhs.a)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::bindingsdenylist::OnlyAppearsInImportingLibrary> |
| : public EncodableCodingTraits<::test::bindingsdenylist::OnlyAppearsInImportingLibrary, 1> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::bindingsdenylist::OnlyAppearsInImportingLibrary> : public internal::BoolConstant< |
| !HasPadding<::test::bindingsdenylist::OnlyAppearsInImportingLibrary>::value && IsMemcpyCompatible<::test::bindingsdenylist::MemberOnlyAppearsInImportingLibrary>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::bindingsdenylist::OnlyAppearsInImportingLibrary& value, |
| ::test::bindingsdenylist::OnlyAppearsInImportingLibrary* result) { |
| return ::test::bindingsdenylist::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::bindingsdenylist::OnlyAppearsInImportingLibrary> { |
| bool operator()(const ::test::bindingsdenylist::OnlyAppearsInImportingLibrary& _lhs, const ::test::bindingsdenylist::OnlyAppearsInImportingLibrary& _rhs) const { |
| if (!::fidl::Equals(_lhs.member_only_appears_in_importing_library, _rhs.member_only_appears_in_importing_library)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| |
| // |
| // Proxies and stubs declarations |
| // |
| } // namespace fidl |
| namespace test { |
| namespace bindingsdenylist { |
| |
| #ifdef __Fuchsia__ |
| |
| using OnlyLibfuzzerAndDepsPtr = ::fidl::InterfacePtr<OnlyLibfuzzerAndDeps>; |
| class OnlyLibfuzzerAndDeps_Proxy; |
| class OnlyLibfuzzerAndDeps_Stub; |
| class OnlyLibfuzzerAndDeps_EventSender; |
| class OnlyLibfuzzerAndDeps_Sync; |
| using OnlyLibfuzzerAndDepsSyncPtr = ::fidl::SynchronousInterfacePtr<OnlyLibfuzzerAndDeps>; |
| class OnlyLibfuzzerAndDeps_SyncProxy; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| using OnlyCppAndDepsPtr = ::fidl::InterfacePtr<OnlyCppAndDeps>; |
| class OnlyCppAndDeps_Proxy; |
| class OnlyCppAndDeps_Stub; |
| class OnlyCppAndDeps_EventSender; |
| class OnlyCppAndDeps_Sync; |
| using OnlyCppAndDepsSyncPtr = ::fidl::SynchronousInterfacePtr<OnlyCppAndDeps>; |
| class OnlyCppAndDeps_SyncProxy; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| class OnlyHlcpp; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| using DenyEachBindingPtr = ::fidl::InterfacePtr<DenyEachBinding>; |
| class DenyEachBinding_Proxy; |
| class DenyEachBinding_Stub; |
| class DenyEachBinding_EventSender; |
| class DenyEachBinding_Sync; |
| using DenyEachBindingSyncPtr = ::fidl::SynchronousInterfacePtr<DenyEachBinding>; |
| class DenyEachBinding_SyncProxy; |
| |
| namespace internal { |
| |
| constexpr uint64_t kDenyEachBinding_OnlyDenyDart_Ordinal = 0x75384066a26d87d7lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kDenyEachBinding_OnlyDenyDart_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kDenyEachBinding_OnlyDenyGo_Ordinal = 0x657655b981478d99lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kDenyEachBinding_OnlyDenyGo_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kDenyEachBinding_OnlyDenyLibfuzzer_Ordinal = 0x1e4f89c329617b1elu; |
| |
| constexpr ::fidl::MessageDynamicFlags kDenyEachBinding_OnlyDenyLibfuzzer_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kDenyEachBinding_OnlyDenyRust_Ordinal = 0x339f67244edd5cb6lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kDenyEachBinding_OnlyDenyRust_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kDenyEachBinding_OnlyDenySyzkaller_Ordinal = 0x202ee614a749e98alu; |
| |
| constexpr ::fidl::MessageDynamicFlags kDenyEachBinding_OnlyDenySyzkaller_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| } // namespace internal |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| using AllowedPtr = ::fidl::InterfacePtr<Allowed>; |
| class Allowed_Proxy; |
| class Allowed_Stub; |
| class Allowed_EventSender; |
| class Allowed_Sync; |
| using AllowedSyncPtr = ::fidl::SynchronousInterfacePtr<Allowed>; |
| class Allowed_SyncProxy; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| using ImportsSameNameContextPtr = ::fidl::InterfacePtr<ImportsSameNameContext>; |
| class ImportsSameNameContext_Proxy; |
| class ImportsSameNameContext_Stub; |
| class ImportsSameNameContext_EventSender; |
| class ImportsSameNameContext_Sync; |
| using ImportsSameNameContextSyncPtr = ::fidl::SynchronousInterfacePtr<ImportsSameNameContext>; |
| class ImportsSameNameContext_SyncProxy; |
| |
| namespace internal { |
| |
| constexpr uint64_t kImportsSameNameContext_Unattributed_Ordinal = 0x698380acfd29e8flu; |
| |
| constexpr ::fidl::MessageDynamicFlags kImportsSameNameContext_Unattributed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kImportsSameNameContext_AlwaysAppearsInImportingLibrary_Ordinal = 0x2874096c521236f8lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kImportsSameNameContext_AlwaysAppearsInImportingLibrary_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| } // namespace internal |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class OnlyLibfuzzerAndDeps { |
| public: |
| using Proxy_ = ::test::bindingsdenylist::OnlyLibfuzzerAndDeps_Proxy; |
| using Stub_ = ::test::bindingsdenylist::OnlyLibfuzzerAndDeps_Stub; |
| using EventSender_ = ::test::bindingsdenylist::OnlyLibfuzzerAndDeps_EventSender; |
| using Sync_ = ::test::bindingsdenylist::OnlyLibfuzzerAndDeps_Sync; |
| virtual ~OnlyLibfuzzerAndDeps(); |
| }; |
| |
| class OnlyLibfuzzerAndDeps_RequestDecoder { |
| public: |
| OnlyLibfuzzerAndDeps_RequestDecoder() = default; |
| virtual ~OnlyLibfuzzerAndDeps_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known); |
| }; |
| |
| class OnlyLibfuzzerAndDeps_ResponseDecoder { |
| public: |
| OnlyLibfuzzerAndDeps_ResponseDecoder() = default; |
| virtual ~OnlyLibfuzzerAndDeps_ResponseDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal); |
| }; |
| |
| class OnlyLibfuzzerAndDeps_EventSender { |
| public: |
| virtual ~OnlyLibfuzzerAndDeps_EventSender(); |
| }; |
| |
| class OnlyLibfuzzerAndDeps_Sync { |
| public: |
| using Proxy_ = ::test::bindingsdenylist::OnlyLibfuzzerAndDeps_SyncProxy; |
| virtual ~OnlyLibfuzzerAndDeps_Sync(); |
| }; |
| |
| class OnlyLibfuzzerAndDeps_Proxy final : public ::fidl::internal::Proxy, public OnlyLibfuzzerAndDeps { |
| public: |
| explicit OnlyLibfuzzerAndDeps_Proxy(::fidl::internal::ProxyController* controller); |
| ~OnlyLibfuzzerAndDeps_Proxy() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override; |
| |
| private: |
| OnlyLibfuzzerAndDeps_Proxy(const ::test::bindingsdenylist::OnlyLibfuzzerAndDeps_Proxy&) = delete; |
| OnlyLibfuzzerAndDeps_Proxy& operator=(const ::test::bindingsdenylist::OnlyLibfuzzerAndDeps_Proxy&) = delete; |
| |
| ::fidl::internal::ProxyController* controller_; |
| }; |
| |
| class OnlyLibfuzzerAndDeps_Stub final : public ::fidl::internal::Stub, public ::test::bindingsdenylist::OnlyLibfuzzerAndDeps_EventSender { |
| public: |
| typedef class ::test::bindingsdenylist::OnlyLibfuzzerAndDeps OnlyLibfuzzerAndDeps_clazz; |
| explicit OnlyLibfuzzerAndDeps_Stub(::test::bindingsdenylist::OnlyLibfuzzerAndDeps_Stub::OnlyLibfuzzerAndDeps_clazz* impl); |
| ~OnlyLibfuzzerAndDeps_Stub() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message, |
| ::fidl::internal::PendingResponse response) override; |
| |
| private: |
| ::test::bindingsdenylist::OnlyLibfuzzerAndDeps_Stub::OnlyLibfuzzerAndDeps_clazz* impl_; |
| }; |
| |
| class OnlyLibfuzzerAndDeps_SyncProxy : public ::test::bindingsdenylist::OnlyLibfuzzerAndDeps_Sync { |
| public: |
| explicit OnlyLibfuzzerAndDeps_SyncProxy(::zx::channel channel); |
| ~OnlyLibfuzzerAndDeps_SyncProxy() override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<OnlyLibfuzzerAndDeps>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class OnlyCppAndDeps { |
| public: |
| using Proxy_ = ::test::bindingsdenylist::OnlyCppAndDeps_Proxy; |
| using Stub_ = ::test::bindingsdenylist::OnlyCppAndDeps_Stub; |
| using EventSender_ = ::test::bindingsdenylist::OnlyCppAndDeps_EventSender; |
| using Sync_ = ::test::bindingsdenylist::OnlyCppAndDeps_Sync; |
| virtual ~OnlyCppAndDeps(); |
| }; |
| |
| class OnlyCppAndDeps_RequestDecoder { |
| public: |
| OnlyCppAndDeps_RequestDecoder() = default; |
| virtual ~OnlyCppAndDeps_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known); |
| }; |
| |
| class OnlyCppAndDeps_ResponseDecoder { |
| public: |
| OnlyCppAndDeps_ResponseDecoder() = default; |
| virtual ~OnlyCppAndDeps_ResponseDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal); |
| }; |
| |
| class OnlyCppAndDeps_EventSender { |
| public: |
| virtual ~OnlyCppAndDeps_EventSender(); |
| }; |
| |
| class OnlyCppAndDeps_Sync { |
| public: |
| using Proxy_ = ::test::bindingsdenylist::OnlyCppAndDeps_SyncProxy; |
| virtual ~OnlyCppAndDeps_Sync(); |
| }; |
| |
| class OnlyCppAndDeps_Proxy final : public ::fidl::internal::Proxy, public OnlyCppAndDeps { |
| public: |
| explicit OnlyCppAndDeps_Proxy(::fidl::internal::ProxyController* controller); |
| ~OnlyCppAndDeps_Proxy() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override; |
| |
| private: |
| OnlyCppAndDeps_Proxy(const ::test::bindingsdenylist::OnlyCppAndDeps_Proxy&) = delete; |
| OnlyCppAndDeps_Proxy& operator=(const ::test::bindingsdenylist::OnlyCppAndDeps_Proxy&) = delete; |
| |
| ::fidl::internal::ProxyController* controller_; |
| }; |
| |
| class OnlyCppAndDeps_Stub final : public ::fidl::internal::Stub, public ::test::bindingsdenylist::OnlyCppAndDeps_EventSender { |
| public: |
| typedef class ::test::bindingsdenylist::OnlyCppAndDeps OnlyCppAndDeps_clazz; |
| explicit OnlyCppAndDeps_Stub(::test::bindingsdenylist::OnlyCppAndDeps_Stub::OnlyCppAndDeps_clazz* impl); |
| ~OnlyCppAndDeps_Stub() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message, |
| ::fidl::internal::PendingResponse response) override; |
| |
| private: |
| ::test::bindingsdenylist::OnlyCppAndDeps_Stub::OnlyCppAndDeps_clazz* impl_; |
| }; |
| |
| class OnlyCppAndDeps_SyncProxy : public ::test::bindingsdenylist::OnlyCppAndDeps_Sync { |
| public: |
| explicit OnlyCppAndDeps_SyncProxy(::zx::channel channel); |
| ~OnlyCppAndDeps_SyncProxy() override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<OnlyCppAndDeps>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class OnlyHlcpp final { |
| public: |
| class Handler; |
| |
| static constexpr char Name[] = "test.bindingsdenylist.OnlyHlcpp"; |
| |
| explicit OnlyHlcpp(std::unique_ptr<::fidl::ServiceConnector> service) |
| : service_(std::move(service)) {} |
| |
| explicit operator bool() const { return !!service_; } |
| |
| private: |
| std::unique_ptr<::fidl::ServiceConnector> service_; |
| }; |
| |
| /// Facilitates member protocol registration for servers. |
| class OnlyHlcpp::Handler final { |
| public: |
| /// Constructs a new |Handler|. Does not take ownership of |service|. |
| explicit Handler(::fidl::ServiceHandlerBase* service) { (void)service; } |
| |
| private: |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class DenyEachBinding { |
| public: |
| using Proxy_ = ::test::bindingsdenylist::DenyEachBinding_Proxy; |
| using Stub_ = ::test::bindingsdenylist::DenyEachBinding_Stub; |
| using EventSender_ = ::test::bindingsdenylist::DenyEachBinding_EventSender; |
| using Sync_ = ::test::bindingsdenylist::DenyEachBinding_Sync; |
| virtual ~DenyEachBinding(); |
| using OnlyDenyDartCallback = |
| fit::function<void(::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result)>; |
| |
| virtual void OnlyDenyDart(bool a, OnlyDenyDartCallback callback) = 0; |
| using OnlyDenyGoCallback = |
| fit::function<void(::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result)>; |
| |
| virtual void OnlyDenyGo(bool a, OnlyDenyGoCallback callback) = 0; |
| using OnlyDenyLibfuzzerCallback = |
| fit::function<void(::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result)>; |
| |
| virtual void OnlyDenyLibfuzzer(bool a, OnlyDenyLibfuzzerCallback callback) = 0; |
| using OnlyDenyRustCallback = |
| fit::function<void(::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result)>; |
| |
| virtual void OnlyDenyRust(bool a, OnlyDenyRustCallback callback) = 0; |
| using OnlyDenySyzkallerCallback = |
| fit::function<void(::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result)>; |
| |
| virtual void OnlyDenySyzkaller(bool a, OnlyDenySyzkallerCallback callback) = 0; |
| }; |
| |
| class DenyEachBinding_RequestDecoder { |
| public: |
| DenyEachBinding_RequestDecoder() = default; |
| virtual ~DenyEachBinding_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known); |
| virtual void OnlyDenyDart(bool a) = 0; |
| virtual void OnlyDenyGo(bool a) = 0; |
| virtual void OnlyDenyLibfuzzer(bool a) = 0; |
| virtual void OnlyDenyRust(bool a) = 0; |
| virtual void OnlyDenySyzkaller(bool a) = 0; |
| }; |
| |
| class DenyEachBinding_ResponseDecoder { |
| public: |
| DenyEachBinding_ResponseDecoder() = default; |
| virtual ~DenyEachBinding_ResponseDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal); |
| virtual void OnlyDenyDart(::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result DenyEachBinding_OnlyDenyDart_Result) = 0; |
| virtual void OnlyDenyGo(::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result DenyEachBinding_OnlyDenyGo_Result) = 0; |
| virtual void OnlyDenyLibfuzzer(::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result DenyEachBinding_OnlyDenyLibfuzzer_Result) = 0; |
| virtual void OnlyDenyRust(::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result DenyEachBinding_OnlyDenyRust_Result) = 0; |
| virtual void OnlyDenySyzkaller(::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result DenyEachBinding_OnlyDenySyzkaller_Result) = 0; |
| }; |
| |
| class DenyEachBinding_EventSender { |
| public: |
| virtual ~DenyEachBinding_EventSender(); |
| }; |
| |
| class DenyEachBinding_Sync { |
| public: |
| using Proxy_ = ::test::bindingsdenylist::DenyEachBinding_SyncProxy; |
| virtual ~DenyEachBinding_Sync(); |
| virtual zx_status_t OnlyDenyDart(bool a, ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result* out_DenyEachBinding_OnlyDenyDart_Result) = 0; |
| virtual zx_status_t OnlyDenyGo(bool a, ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result* out_DenyEachBinding_OnlyDenyGo_Result) = 0; |
| virtual zx_status_t OnlyDenyLibfuzzer(bool a, ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result* out_DenyEachBinding_OnlyDenyLibfuzzer_Result) = 0; |
| virtual zx_status_t OnlyDenyRust(bool a, ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result* out_DenyEachBinding_OnlyDenyRust_Result) = 0; |
| virtual zx_status_t OnlyDenySyzkaller(bool a, ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result* out_DenyEachBinding_OnlyDenySyzkaller_Result) = 0; |
| }; |
| |
| class DenyEachBinding_Proxy final : public ::fidl::internal::Proxy, public DenyEachBinding { |
| public: |
| explicit DenyEachBinding_Proxy(::fidl::internal::ProxyController* controller); |
| ~DenyEachBinding_Proxy() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override; |
| // cts-coverage-fidl-name:test.bindingsdenylist/DenyEachBinding.OnlyDenyDart |
| void OnlyDenyDart(bool a, OnlyDenyDartCallback callback) override; |
| // cts-coverage-fidl-name:test.bindingsdenylist/DenyEachBinding.OnlyDenyGo |
| void OnlyDenyGo(bool a, OnlyDenyGoCallback callback) override; |
| // cts-coverage-fidl-name:test.bindingsdenylist/DenyEachBinding.OnlyDenyLibfuzzer |
| void OnlyDenyLibfuzzer(bool a, OnlyDenyLibfuzzerCallback callback) override; |
| // cts-coverage-fidl-name:test.bindingsdenylist/DenyEachBinding.OnlyDenyRust |
| void OnlyDenyRust(bool a, OnlyDenyRustCallback callback) override; |
| // cts-coverage-fidl-name:test.bindingsdenylist/DenyEachBinding.OnlyDenySyzkaller |
| void OnlyDenySyzkaller(bool a, OnlyDenySyzkallerCallback callback) override; |
| |
| private: |
| DenyEachBinding_Proxy(const ::test::bindingsdenylist::DenyEachBinding_Proxy&) = delete; |
| DenyEachBinding_Proxy& operator=(const ::test::bindingsdenylist::DenyEachBinding_Proxy&) = delete; |
| |
| ::fidl::internal::ProxyController* controller_; |
| }; |
| |
| class DenyEachBinding_Stub final : public ::fidl::internal::Stub, public ::test::bindingsdenylist::DenyEachBinding_EventSender { |
| public: |
| typedef class ::test::bindingsdenylist::DenyEachBinding DenyEachBinding_clazz; |
| explicit DenyEachBinding_Stub(::test::bindingsdenylist::DenyEachBinding_Stub::DenyEachBinding_clazz* impl); |
| ~DenyEachBinding_Stub() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message, |
| ::fidl::internal::PendingResponse response) override; |
| |
| private: |
| ::test::bindingsdenylist::DenyEachBinding_Stub::DenyEachBinding_clazz* impl_; |
| }; |
| |
| class DenyEachBinding_SyncProxy : public ::test::bindingsdenylist::DenyEachBinding_Sync { |
| public: |
| explicit DenyEachBinding_SyncProxy(::zx::channel channel); |
| ~DenyEachBinding_SyncProxy() override; |
| // cts-coverage-fidl-name:test.bindingsdenylist/DenyEachBinding.OnlyDenyDart |
| zx_status_t OnlyDenyDart(bool a, ::test::bindingsdenylist::DenyEachBinding_OnlyDenyDart_Result* out_DenyEachBinding_OnlyDenyDart_Result) override; |
| // cts-coverage-fidl-name:test.bindingsdenylist/DenyEachBinding.OnlyDenyGo |
| zx_status_t OnlyDenyGo(bool a, ::test::bindingsdenylist::DenyEachBinding_OnlyDenyGo_Result* out_DenyEachBinding_OnlyDenyGo_Result) override; |
| // cts-coverage-fidl-name:test.bindingsdenylist/DenyEachBinding.OnlyDenyLibfuzzer |
| zx_status_t OnlyDenyLibfuzzer(bool a, ::test::bindingsdenylist::DenyEachBinding_OnlyDenyLibfuzzer_Result* out_DenyEachBinding_OnlyDenyLibfuzzer_Result) override; |
| // cts-coverage-fidl-name:test.bindingsdenylist/DenyEachBinding.OnlyDenyRust |
| zx_status_t OnlyDenyRust(bool a, ::test::bindingsdenylist::DenyEachBinding_OnlyDenyRust_Result* out_DenyEachBinding_OnlyDenyRust_Result) override; |
| // cts-coverage-fidl-name:test.bindingsdenylist/DenyEachBinding.OnlyDenySyzkaller |
| zx_status_t OnlyDenySyzkaller(bool a, ::test::bindingsdenylist::DenyEachBinding_OnlyDenySyzkaller_Result* out_DenyEachBinding_OnlyDenySyzkaller_Result) override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<DenyEachBinding>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class Allowed { |
| public: |
| using Proxy_ = ::test::bindingsdenylist::Allowed_Proxy; |
| using Stub_ = ::test::bindingsdenylist::Allowed_Stub; |
| using EventSender_ = ::test::bindingsdenylist::Allowed_EventSender; |
| using Sync_ = ::test::bindingsdenylist::Allowed_Sync; |
| virtual ~Allowed(); |
| }; |
| |
| class Allowed_RequestDecoder { |
| public: |
| Allowed_RequestDecoder() = default; |
| virtual ~Allowed_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known); |
| }; |
| |
| class Allowed_ResponseDecoder { |
| public: |
| Allowed_ResponseDecoder() = default; |
| virtual ~Allowed_ResponseDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal); |
| }; |
| |
| class Allowed_EventSender { |
| public: |
| virtual ~Allowed_EventSender(); |
| }; |
| |
| class Allowed_Sync { |
| public: |
| using Proxy_ = ::test::bindingsdenylist::Allowed_SyncProxy; |
| virtual ~Allowed_Sync(); |
| }; |
| |
| class Allowed_Proxy final : public ::fidl::internal::Proxy, public Allowed { |
| public: |
| explicit Allowed_Proxy(::fidl::internal::ProxyController* controller); |
| ~Allowed_Proxy() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override; |
| |
| private: |
| Allowed_Proxy(const ::test::bindingsdenylist::Allowed_Proxy&) = delete; |
| Allowed_Proxy& operator=(const ::test::bindingsdenylist::Allowed_Proxy&) = delete; |
| |
| ::fidl::internal::ProxyController* controller_; |
| }; |
| |
| class Allowed_Stub final : public ::fidl::internal::Stub, public ::test::bindingsdenylist::Allowed_EventSender { |
| public: |
| typedef class ::test::bindingsdenylist::Allowed Allowed_clazz; |
| explicit Allowed_Stub(::test::bindingsdenylist::Allowed_Stub::Allowed_clazz* impl); |
| ~Allowed_Stub() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message, |
| ::fidl::internal::PendingResponse response) override; |
| |
| private: |
| ::test::bindingsdenylist::Allowed_Stub::Allowed_clazz* impl_; |
| }; |
| |
| class Allowed_SyncProxy : public ::test::bindingsdenylist::Allowed_Sync { |
| public: |
| explicit Allowed_SyncProxy(::zx::channel channel); |
| ~Allowed_SyncProxy() override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<Allowed>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class ImportsSameNameContext { |
| public: |
| using Proxy_ = ::test::bindingsdenylist::ImportsSameNameContext_Proxy; |
| using Stub_ = ::test::bindingsdenylist::ImportsSameNameContext_Stub; |
| using EventSender_ = ::test::bindingsdenylist::ImportsSameNameContext_EventSender; |
| using Sync_ = ::test::bindingsdenylist::ImportsSameNameContext_Sync; |
| virtual ~ImportsSameNameContext(); |
| |
| virtual void Unattributed() = 0; |
| |
| virtual void AlwaysAppearsInImportingLibrary() = 0; |
| }; |
| |
| class ImportsSameNameContext_RequestDecoder { |
| public: |
| ImportsSameNameContext_RequestDecoder() = default; |
| virtual ~ImportsSameNameContext_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known); |
| virtual void Unattributed() = 0; |
| virtual void AlwaysAppearsInImportingLibrary() = 0; |
| }; |
| |
| class ImportsSameNameContext_ResponseDecoder { |
| public: |
| ImportsSameNameContext_ResponseDecoder() = default; |
| virtual ~ImportsSameNameContext_ResponseDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal); |
| }; |
| |
| class ImportsSameNameContext_EventSender { |
| public: |
| virtual ~ImportsSameNameContext_EventSender(); |
| }; |
| |
| class ImportsSameNameContext_Sync { |
| public: |
| using Proxy_ = ::test::bindingsdenylist::ImportsSameNameContext_SyncProxy; |
| virtual ~ImportsSameNameContext_Sync(); |
| virtual zx_status_t Unattributed() = 0; |
| virtual zx_status_t AlwaysAppearsInImportingLibrary() = 0; |
| }; |
| |
| class ImportsSameNameContext_Proxy final : public ::fidl::internal::Proxy, public ImportsSameNameContext { |
| public: |
| explicit ImportsSameNameContext_Proxy(::fidl::internal::ProxyController* controller); |
| ~ImportsSameNameContext_Proxy() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override; |
| // cts-coverage-fidl-name:test.bindingsdenylist/ImportsSameNameContext.Unattributed |
| void Unattributed() override; |
| // cts-coverage-fidl-name:test.bindingsdenylist/ImportsSameNameContext.AlwaysAppearsInImportingLibrary |
| void AlwaysAppearsInImportingLibrary() override; |
| |
| private: |
| ImportsSameNameContext_Proxy(const ::test::bindingsdenylist::ImportsSameNameContext_Proxy&) = delete; |
| ImportsSameNameContext_Proxy& operator=(const ::test::bindingsdenylist::ImportsSameNameContext_Proxy&) = delete; |
| |
| ::fidl::internal::ProxyController* controller_; |
| }; |
| |
| class ImportsSameNameContext_Stub final : public ::fidl::internal::Stub, public ::test::bindingsdenylist::ImportsSameNameContext_EventSender { |
| public: |
| typedef class ::test::bindingsdenylist::ImportsSameNameContext ImportsSameNameContext_clazz; |
| explicit ImportsSameNameContext_Stub(::test::bindingsdenylist::ImportsSameNameContext_Stub::ImportsSameNameContext_clazz* impl); |
| ~ImportsSameNameContext_Stub() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message, |
| ::fidl::internal::PendingResponse response) override; |
| |
| private: |
| ::test::bindingsdenylist::ImportsSameNameContext_Stub::ImportsSameNameContext_clazz* impl_; |
| }; |
| |
| class ImportsSameNameContext_SyncProxy : public ::test::bindingsdenylist::ImportsSameNameContext_Sync { |
| public: |
| explicit ImportsSameNameContext_SyncProxy(::zx::channel channel); |
| ~ImportsSameNameContext_SyncProxy() override; |
| // cts-coverage-fidl-name:test.bindingsdenylist/ImportsSameNameContext.Unattributed |
| zx_status_t Unattributed() override; |
| // cts-coverage-fidl-name:test.bindingsdenylist/ImportsSameNameContext.AlwaysAppearsInImportingLibrary |
| zx_status_t AlwaysAppearsInImportingLibrary() override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<ImportsSameNameContext>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| } // namespace bindingsdenylist |
| } // namespace test |