| // WARNING: This file is machine generated by fidlgen. |
| |
| #pragma once |
| |
| #include "lib/fidl/cpp/internal/header.h" |
| |
| // |
| // Domain objects declarations (i.e. "natural types" in unified bindings). |
| // |
| namespace fidl { |
| namespace test { |
| namespace requestflexibleenvelope { |
| |
| class StrictFoo; |
| class FlexibleFoo; |
| #ifdef __Fuchsia__ |
| class Protocol; |
| using ProtocolHandle = ::fidl::InterfaceHandle<Protocol>; |
| #endif // __Fuchsia__ |
| |
| class StrictFoo final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| StrictFoo(); |
| ~StrictFoo(); |
| |
| StrictFoo(StrictFoo&&); |
| StrictFoo& operator=(StrictFoo&&); |
| |
| static StrictFoo WithS(::std::string&&); |
| static StrictFoo WithI(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kS = 1, // 0x1 |
| kI = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<StrictFoo> New() { |
| return ::std::make_unique<StrictFoo>(); |
| } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset); |
| static void Decode(::fidl::Decoder* decoder, StrictFoo* value, size_t offset); |
| zx_status_t Clone(StrictFoo* result) const; |
| |
| bool has_invalid_tag() const { return tag_ == Invalid; } |
| |
| bool is_s() const { return tag_ == Tag::kS; } |
| |
| ::std::string& s() { |
| EnsureStorageInitialized(Tag::kS); |
| return s_; |
| } |
| |
| const ::std::string& s() const { |
| ZX_ASSERT(is_s()); |
| return s_; |
| } |
| StrictFoo& set_s(::std::string value); |
| |
| bool is_i() const { return tag_ == Tag::kI; } |
| |
| int32_t& i() { |
| EnsureStorageInitialized(Tag::kI); |
| return i_; |
| } |
| |
| const int32_t& i() const { |
| ZX_ASSERT(is_i()); |
| return i_; |
| } |
| StrictFoo& set_i(int32_t value); |
| |
| Tag Which() const { return 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<::fidl::test::requestflexibleenvelope::StrictFoo>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(Tag::Invalid); |
| union { |
| ::std::string s_; |
| int32_t i_; |
| }; |
| }; |
| |
| inline zx_status_t Clone( |
| const ::fidl::test::requestflexibleenvelope::StrictFoo& value, |
| ::fidl::test::requestflexibleenvelope::StrictFoo* result) { |
| return value.Clone(result); |
| } |
| |
| using StrictFooPtr = ::std::unique_ptr<StrictFoo>; |
| |
| class FlexibleFoo final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| FlexibleFoo(); |
| ~FlexibleFoo(); |
| |
| FlexibleFoo(FlexibleFoo&&); |
| FlexibleFoo& operator=(FlexibleFoo&&); |
| |
| static FlexibleFoo WithS(::std::string&&); |
| static FlexibleFoo WithI(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| Empty = kUnknown, // DEPRECATED: use kUnknown instead. |
| |
| kS = 1, // 0x1 |
| kI = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<FlexibleFoo> New() { |
| return ::std::make_unique<FlexibleFoo>(); |
| } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset); |
| static void Decode(::fidl::Decoder* decoder, FlexibleFoo* value, |
| size_t offset); |
| zx_status_t Clone(FlexibleFoo* result) const; |
| |
| bool has_invalid_tag() const { return tag_ == Invalid; } |
| |
| bool is_s() const { return tag_ == Tag::kS; } |
| |
| ::std::string& s() { |
| EnsureStorageInitialized(Tag::kS); |
| return s_; |
| } |
| |
| const ::std::string& s() const { |
| ZX_ASSERT(is_s()); |
| return s_; |
| } |
| FlexibleFoo& set_s(::std::string value); |
| |
| bool is_i() const { return tag_ == Tag::kI; } |
| |
| int32_t& i() { |
| EnsureStorageInitialized(Tag::kI); |
| return i_; |
| } |
| |
| const int32_t& i() const { |
| ZX_ASSERT(is_i()); |
| return i_; |
| } |
| FlexibleFoo& set_i(int32_t value); |
| FlexibleFoo& SetUnknownData(fidl_xunion_tag_t ordinal, |
| std::vector<uint8_t> bytes); |
| |
| Tag Which() const { |
| switch (tag_) { |
| case Tag::Invalid: |
| case Tag::kS: |
| case Tag::kI: |
| return Tag(tag_); |
| default: |
| return Tag::kUnknown; |
| } |
| } |
| |
| // 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_; } |
| const std::vector<uint8_t>* UnknownBytes() const { |
| if (Which() != Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::fidl::test::requestflexibleenvelope::FlexibleFoo>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(Tag::Invalid); |
| union { |
| ::std::string s_; |
| int32_t i_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone( |
| const ::fidl::test::requestflexibleenvelope::FlexibleFoo& value, |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo* result) { |
| return value.Clone(result); |
| } |
| |
| using FlexibleFooPtr = ::std::unique_ptr<FlexibleFoo>; |
| #ifdef __Fuchsia__ |
| |
| namespace _internal { |
| extern "C" const fidl_type_t |
| fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleRequestTable; |
| extern "C" const fidl_type_t |
| fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictRequestTable; |
| } // namespace _internal |
| |
| class Protocol_RequestEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage RequestStrictResponseFlexible( |
| ::fidl::Encoder* _encoder, |
| ::fidl::test::requestflexibleenvelope::StrictFoo* s) { |
| fidl_trace(WillHLCPPEncode); |
| _encoder->Alloc(40 - sizeof(fidl_message_header_t)); |
| ::fidl::Encode(_encoder, s, 16); |
| |
| fidl_trace( |
| DidHLCPPEncode, |
| &_internal:: |
| fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleRequestTable, |
| _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), |
| _encoder->CurrentHandleCount()); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage RequestFlexibleResponseStrict( |
| ::fidl::Encoder* _encoder, |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo* s) { |
| fidl_trace(WillHLCPPEncode); |
| _encoder->Alloc(40 - sizeof(fidl_message_header_t)); |
| ::fidl::Encode(_encoder, s, 16); |
| |
| fidl_trace( |
| DidHLCPPEncode, |
| &_internal:: |
| fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictRequestTable, |
| _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), |
| _encoder->CurrentHandleCount()); |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| namespace _internal { |
| extern "C" const fidl_type_t |
| fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleResponseTable; |
| extern "C" const fidl_type_t |
| fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictResponseTable; |
| } // namespace _internal |
| |
| class Protocol_ResponseEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage RequestStrictResponseFlexible( |
| ::fidl::Encoder* _encoder, |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo* f) { |
| fidl_trace(WillHLCPPEncode); |
| _encoder->Alloc(40 - sizeof(fidl_message_header_t)); |
| ::fidl::Encode(_encoder, f, 16); |
| |
| fidl_trace( |
| DidHLCPPEncode, |
| &_internal:: |
| fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleResponseTable, |
| _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), |
| _encoder->CurrentHandleCount()); |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage RequestFlexibleResponseStrict( |
| ::fidl::Encoder* _encoder, |
| ::fidl::test::requestflexibleenvelope::StrictFoo* f) { |
| fidl_trace(WillHLCPPEncode); |
| _encoder->Alloc(40 - sizeof(fidl_message_header_t)); |
| ::fidl::Encode(_encoder, f, 16); |
| |
| fidl_trace( |
| DidHLCPPEncode, |
| &_internal:: |
| fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictResponseTable, |
| _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), |
| _encoder->CurrentHandleCount()); |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| #endif // __Fuchsia__ |
| } // namespace requestflexibleenvelope |
| } // namespace test |
| } // namespace fidl |
| namespace fidl { |
| |
| template <> |
| struct IsFidlXUnion<::fidl::test::requestflexibleenvelope::StrictFoo> |
| : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::fidl::test::requestflexibleenvelope::StrictFoo> |
| : public EncodableCodingTraits< |
| ::fidl::test::requestflexibleenvelope::StrictFoo, 24> {}; |
| |
| template <> |
| struct CodingTraits< |
| std::unique_ptr<::fidl::test::requestflexibleenvelope::StrictFoo>> { |
| static constexpr size_t inline_size_v1_no_ee = 24; |
| |
| static void Encode( |
| Encoder* encoder, |
| std::unique_ptr<::fidl::test::requestflexibleenvelope::StrictFoo>* value, |
| size_t offset) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode( |
| Decoder* decoder, |
| std::unique_ptr<::fidl::test::requestflexibleenvelope::StrictFoo>* value, |
| size_t offset) { |
| fidl_xunion_t* encoded = decoder->GetPtr<fidl_xunion_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::fidl::test::requestflexibleenvelope::StrictFoo); |
| |
| ::fidl::test::requestflexibleenvelope::StrictFoo::Decode( |
| decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone( |
| const ::fidl::test::requestflexibleenvelope::StrictFoo& value, |
| ::fidl::test::requestflexibleenvelope::StrictFoo* result) { |
| return ::fidl::test::requestflexibleenvelope::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::fidl::test::requestflexibleenvelope::StrictFoo> { |
| bool operator()( |
| const ::fidl::test::requestflexibleenvelope::StrictFoo& _lhs, |
| const ::fidl::test::requestflexibleenvelope::StrictFoo& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>( |
| ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::Invalid): |
| return true; |
| case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kS: |
| return ::fidl::Equals(_lhs.s_, _rhs.s_); |
| case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kI: |
| return ::fidl::Equals(_lhs.i_, _rhs.i_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::fidl::test::requestflexibleenvelope::FlexibleFoo> |
| : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::fidl::test::requestflexibleenvelope::FlexibleFoo> |
| : public EncodableCodingTraits< |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo, 24> {}; |
| |
| template <> |
| struct CodingTraits< |
| std::unique_ptr<::fidl::test::requestflexibleenvelope::FlexibleFoo>> { |
| static constexpr size_t inline_size_v1_no_ee = 24; |
| |
| static void Encode( |
| Encoder* encoder, |
| std::unique_ptr<::fidl::test::requestflexibleenvelope::FlexibleFoo>* |
| value, |
| size_t offset) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode( |
| Decoder* decoder, |
| std::unique_ptr<::fidl::test::requestflexibleenvelope::FlexibleFoo>* |
| value, |
| size_t offset) { |
| fidl_xunion_t* encoded = decoder->GetPtr<fidl_xunion_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::fidl::test::requestflexibleenvelope::FlexibleFoo); |
| |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo::Decode( |
| decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone( |
| const ::fidl::test::requestflexibleenvelope::FlexibleFoo& value, |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo* result) { |
| return ::fidl::test::requestflexibleenvelope::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::fidl::test::requestflexibleenvelope::FlexibleFoo> { |
| bool operator()( |
| const ::fidl::test::requestflexibleenvelope::FlexibleFoo& _lhs, |
| const ::fidl::test::requestflexibleenvelope::FlexibleFoo& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>( |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::Invalid): |
| return true; |
| case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kS: |
| return ::fidl::Equals(_lhs.s_, _rhs.s_); |
| case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kI: |
| return ::fidl::Equals(_lhs.i_, _rhs.i_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| } // namespace fidl |
| |
| // |
| // Proxies and stubs declarations |
| // |
| namespace fidl { |
| namespace test { |
| namespace requestflexibleenvelope { |
| |
| #ifdef __Fuchsia__ |
| using ProtocolPtr = ::fidl::InterfacePtr<Protocol>; |
| class Protocol_Proxy; |
| class Protocol_Stub; |
| class Protocol_EventSender; |
| class Protocol_Sync; |
| using ProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<Protocol>; |
| class Protocol_SyncProxy; |
| |
| namespace internal { |
| constexpr uint64_t kProtocol_RequestStrictResponseFlexible_Ordinal = |
| 0x3c5330c58686011alu; |
| constexpr uint64_t kProtocol_RequestFlexibleResponseStrict_Ordinal = |
| 0x3cb49d8f6e204f76lu; |
| |
| } // namespace internal |
| #endif // __Fuchsia__ |
| #ifdef __Fuchsia__ |
| class Protocol { |
| public: |
| using Proxy_ = Protocol_Proxy; |
| using Stub_ = Protocol_Stub; |
| using EventSender_ = Protocol_EventSender; |
| using Sync_ = Protocol_Sync; |
| virtual ~Protocol(); |
| using RequestStrictResponseFlexibleCallback = |
| fit::function<void(::fidl::test::requestflexibleenvelope::FlexibleFoo)>; |
| |
| virtual void RequestStrictResponseFlexible( |
| ::fidl::test::requestflexibleenvelope::StrictFoo s, |
| RequestStrictResponseFlexibleCallback callback) = 0; |
| using RequestFlexibleResponseStrictCallback = |
| fit::function<void(::fidl::test::requestflexibleenvelope::StrictFoo)>; |
| |
| virtual void RequestFlexibleResponseStrict( |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo s, |
| RequestFlexibleResponseStrictCallback callback) = 0; |
| }; |
| |
| class Protocol_RequestDecoder { |
| public: |
| Protocol_RequestDecoder() = default; |
| virtual ~Protocol_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response); |
| virtual void RequestStrictResponseFlexible( |
| ::fidl::test::requestflexibleenvelope::StrictFoo s) = 0; |
| virtual void RequestFlexibleResponseStrict( |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo s) = 0; |
| }; |
| |
| class Protocol_ResponseDecoder { |
| public: |
| Protocol_ResponseDecoder() = default; |
| virtual ~Protocol_ResponseDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal); |
| virtual void RequestStrictResponseFlexible( |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo f) = 0; |
| virtual void RequestFlexibleResponseStrict( |
| ::fidl::test::requestflexibleenvelope::StrictFoo f) = 0; |
| }; |
| |
| class Protocol_EventSender { |
| public: |
| virtual ~Protocol_EventSender(); |
| }; |
| |
| class Protocol_Sync { |
| public: |
| using Proxy_ = Protocol_SyncProxy; |
| virtual ~Protocol_Sync(); |
| virtual zx_status_t RequestStrictResponseFlexible( |
| ::fidl::test::requestflexibleenvelope::StrictFoo s, |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo* out_f) = 0; |
| virtual zx_status_t RequestFlexibleResponseStrict( |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo s, |
| ::fidl::test::requestflexibleenvelope::StrictFoo* out_f) = 0; |
| }; |
| |
| class Protocol_Proxy final : public ::fidl::internal::Proxy, public Protocol { |
| public: |
| explicit Protocol_Proxy(::fidl::internal::ProxyController* controller); |
| ~Protocol_Proxy() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override; |
| void RequestStrictResponseFlexible( |
| ::fidl::test::requestflexibleenvelope::StrictFoo s, |
| RequestStrictResponseFlexibleCallback callback) override; |
| void RequestFlexibleResponseStrict( |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo s, |
| RequestFlexibleResponseStrictCallback callback) override; |
| |
| private: |
| Protocol_Proxy(const Protocol_Proxy&) = delete; |
| Protocol_Proxy& operator=(const Protocol_Proxy&) = delete; |
| |
| ::fidl::internal::ProxyController* controller_; |
| }; |
| |
| class Protocol_Stub final : public ::fidl::internal::Stub, |
| public Protocol_EventSender { |
| public: |
| typedef class ::fidl::test::requestflexibleenvelope::Protocol Protocol_clazz; |
| explicit Protocol_Stub(Protocol_clazz* impl); |
| ~Protocol_Stub() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message, |
| ::fidl::internal::PendingResponse response) override; |
| |
| private: |
| Protocol_clazz* impl_; |
| }; |
| |
| class Protocol_SyncProxy : public Protocol_Sync { |
| public: |
| explicit Protocol_SyncProxy(::zx::channel channel); |
| ~Protocol_SyncProxy() override; |
| zx_status_t RequestStrictResponseFlexible( |
| ::fidl::test::requestflexibleenvelope::StrictFoo s, |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo* out_f) override; |
| zx_status_t RequestFlexibleResponseStrict( |
| ::fidl::test::requestflexibleenvelope::FlexibleFoo s, |
| ::fidl::test::requestflexibleenvelope::StrictFoo* out_f) override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<Protocol>; |
| }; |
| |
| #endif // __Fuchsia__ |
| } // namespace requestflexibleenvelope |
| } // namespace test |
| } // namespace fidl |