| // WARNING: This file is machine generated by fidlgen. |
| |
| #pragma once |
| |
| #include <lib/fidl/internal.h> |
| #include <lib/fidl/txn_header.h> |
| #include <lib/fidl/llcpp/array.h> |
| #include <lib/fidl/llcpp/coding.h> |
| #include <lib/fidl/llcpp/connect_service.h> |
| #include <lib/fidl/llcpp/service_handler_interface.h> |
| #include <lib/fidl/llcpp/string_view.h> |
| #include <lib/fidl/llcpp/sync_call.h> |
| #include <lib/fidl/llcpp/traits.h> |
| #include <lib/fidl/llcpp/transaction.h> |
| #include <lib/fidl/llcpp/vector_view.h> |
| #include <lib/fit/function.h> |
| #include <lib/zx/channel.h> |
| #include <lib/zx/fifo.h> |
| #include <lib/zx/vmo.h> |
| #include <zircon/fidl.h> |
| |
| #include <fuchsia/hardware/block/llcpp/fidl.h> |
| #include <fuchsia/hardware/block/partition/llcpp/fidl.h> |
| |
| namespace llcpp { |
| |
| namespace fuchsia { |
| namespace hardware { |
| namespace block { |
| namespace volume { |
| |
| struct VsliceRange; |
| struct VolumeManagerInfo; |
| struct VolumeInfo; |
| class Volume; |
| class VolumeManager; |
| |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VsliceRangeTable; |
| |
| struct VsliceRange { |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VsliceRangeTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| bool allocated = {}; |
| |
| uint64_t count = {}; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerInfoTable; |
| |
| struct VolumeManagerInfo { |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeManagerInfoTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint64_t slice_size = {}; |
| |
| uint64_t current_slice_count = {}; |
| |
| uint64_t maximum_slice_count = {}; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeInfoTable; |
| |
| struct VolumeInfo { |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeInfoTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint64_t slice_size = {}; |
| |
| uint64_t vslice_count = {}; |
| |
| uint64_t pslice_total_count = {}; |
| |
| uint64_t pslice_allocated_count = {}; |
| }; |
| |
| constexpr uint32_t MAX_SLICE_REQUESTS = 16u; |
| |
| constexpr uint32_t ALLOCATE_PARTITION_FLAG_INACTIVE = 1u; |
| |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetInfoRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetInfoResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetStatsRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetStatsResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetFifoRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetFifoResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeAttachVmoRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeAttachVmoResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeCloseFifoRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeCloseFifoResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeRebindDeviceRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeRebindDeviceResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetTypeGuidRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetTypeGuidResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetInstanceGuidRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetInstanceGuidResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetNameRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetNameResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeQueryRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeQueryResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeQuerySlicesRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeQuerySlicesResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeExtendRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeExtendResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeShrinkRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeShrinkResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeDestroyRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeDestroyResponseTable; |
| |
| class Volume final { |
| Volume() = delete; |
| public: |
| |
| struct GetInfoResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| ::llcpp::fuchsia::hardware::block::BlockInfo* info; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeGetInfoResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| static constexpr uint32_t MaxOutOfLine = 24; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| using GetInfoRequest = ::fidl::AnyZeroArgMessage; |
| |
| struct GetStatsResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| ::llcpp::fuchsia::hardware::block::BlockStats* stats; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeGetStatsResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| static constexpr uint32_t MaxOutOfLine = 480; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| struct GetStatsRequest final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| bool clear; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeGetStatsRequestTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr uint32_t AltPrimarySize = 24; |
| static constexpr uint32_t AltMaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| using ResponseType = GetStatsResponse; |
| }; |
| |
| struct GetFifoResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| ::zx::fifo fifo; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeGetFifoResponseTable; |
| static constexpr uint32_t MaxNumHandles = 1; |
| static constexpr uint32_t PrimarySize = 24; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| using GetFifoRequest = ::fidl::AnyZeroArgMessage; |
| |
| struct AttachVmoResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| ::llcpp::fuchsia::hardware::block::VmoID* vmoid; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeAttachVmoResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| static constexpr uint32_t MaxOutOfLine = 8; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| struct AttachVmoRequest final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| ::zx::vmo vmo; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeAttachVmoRequestTable; |
| static constexpr uint32_t MaxNumHandles = 1; |
| static constexpr uint32_t PrimarySize = 24; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr uint32_t AltPrimarySize = 24; |
| static constexpr uint32_t AltMaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| using ResponseType = AttachVmoResponse; |
| }; |
| |
| struct CloseFifoResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeCloseFifoResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| using CloseFifoRequest = ::fidl::AnyZeroArgMessage; |
| |
| struct RebindDeviceResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeRebindDeviceResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| using RebindDeviceRequest = ::fidl::AnyZeroArgMessage; |
| |
| struct GetTypeGuidResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| ::llcpp::fuchsia::hardware::block::partition::GUID* guid; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeGetTypeGuidResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| static constexpr uint32_t MaxOutOfLine = 16; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| using GetTypeGuidRequest = ::fidl::AnyZeroArgMessage; |
| |
| struct GetInstanceGuidResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| ::llcpp::fuchsia::hardware::block::partition::GUID* guid; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeGetInstanceGuidResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| static constexpr uint32_t MaxOutOfLine = 16; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| using GetInstanceGuidRequest = ::fidl::AnyZeroArgMessage; |
| |
| struct GetNameResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| ::fidl::StringView name; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeGetNameResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 40; |
| static constexpr uint32_t MaxOutOfLine = 128; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| using GetNameRequest = ::fidl::AnyZeroArgMessage; |
| |
| struct QueryResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| ::llcpp::fuchsia::hardware::block::volume::VolumeInfo* info; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeQueryResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| static constexpr uint32_t MaxOutOfLine = 32; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| using QueryRequest = ::fidl::AnyZeroArgMessage; |
| |
| struct QuerySlicesResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| ::fidl::Array<::llcpp::fuchsia::hardware::block::volume::VsliceRange, 16> response; |
| uint64_t response_count; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeQuerySlicesResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 288; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| struct QuerySlicesRequest final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| ::fidl::VectorView<uint64_t> start_slices; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeQuerySlicesRequestTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| static constexpr uint32_t MaxOutOfLine = 128; |
| static constexpr uint32_t AltPrimarySize = 32; |
| static constexpr uint32_t AltMaxOutOfLine = 128; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| using ResponseType = QuerySlicesResponse; |
| }; |
| |
| struct ExtendResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeExtendResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| struct ExtendRequest final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| uint64_t start_slice; |
| uint64_t slice_count; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeExtendRequestTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr uint32_t AltPrimarySize = 32; |
| static constexpr uint32_t AltMaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| using ResponseType = ExtendResponse; |
| }; |
| |
| struct ShrinkResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeShrinkResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| struct ShrinkRequest final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| uint64_t start_slice; |
| uint64_t slice_count; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeShrinkRequestTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr uint32_t AltPrimarySize = 32; |
| static constexpr uint32_t AltMaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| using ResponseType = ShrinkResponse; |
| }; |
| |
| struct DestroyResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeDestroyResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| using DestroyRequest = ::fidl::AnyZeroArgMessage; |
| |
| |
| // Collection of return types of FIDL calls in this interface. |
| class ResultOf final { |
| ResultOf() = delete; |
| private: |
| template <typename ResponseType> |
| class GetInfo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| GetInfo_Impl(::zx::unowned_channel _client_end); |
| ~GetInfo_Impl() = default; |
| GetInfo_Impl(GetInfo_Impl&& other) = default; |
| GetInfo_Impl& operator=(GetInfo_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class GetStats_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| GetStats_Impl(::zx::unowned_channel _client_end, bool clear); |
| ~GetStats_Impl() = default; |
| GetStats_Impl(GetStats_Impl&& other) = default; |
| GetStats_Impl& operator=(GetStats_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class GetFifo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| GetFifo_Impl(::zx::unowned_channel _client_end); |
| ~GetFifo_Impl() = default; |
| GetFifo_Impl(GetFifo_Impl&& other) = default; |
| GetFifo_Impl& operator=(GetFifo_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class AttachVmo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| AttachVmo_Impl(::zx::unowned_channel _client_end, ::zx::vmo vmo); |
| ~AttachVmo_Impl() = default; |
| AttachVmo_Impl(AttachVmo_Impl&& other) = default; |
| AttachVmo_Impl& operator=(AttachVmo_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class CloseFifo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| CloseFifo_Impl(::zx::unowned_channel _client_end); |
| ~CloseFifo_Impl() = default; |
| CloseFifo_Impl(CloseFifo_Impl&& other) = default; |
| CloseFifo_Impl& operator=(CloseFifo_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class RebindDevice_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| RebindDevice_Impl(::zx::unowned_channel _client_end); |
| ~RebindDevice_Impl() = default; |
| RebindDevice_Impl(RebindDevice_Impl&& other) = default; |
| RebindDevice_Impl& operator=(RebindDevice_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class GetTypeGuid_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| GetTypeGuid_Impl(::zx::unowned_channel _client_end); |
| ~GetTypeGuid_Impl() = default; |
| GetTypeGuid_Impl(GetTypeGuid_Impl&& other) = default; |
| GetTypeGuid_Impl& operator=(GetTypeGuid_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class GetInstanceGuid_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| GetInstanceGuid_Impl(::zx::unowned_channel _client_end); |
| ~GetInstanceGuid_Impl() = default; |
| GetInstanceGuid_Impl(GetInstanceGuid_Impl&& other) = default; |
| GetInstanceGuid_Impl& operator=(GetInstanceGuid_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class GetName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| GetName_Impl(::zx::unowned_channel _client_end); |
| ~GetName_Impl() = default; |
| GetName_Impl(GetName_Impl&& other) = default; |
| GetName_Impl& operator=(GetName_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class Query_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| Query_Impl(::zx::unowned_channel _client_end); |
| ~Query_Impl() = default; |
| Query_Impl(Query_Impl&& other) = default; |
| Query_Impl& operator=(Query_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class QuerySlices_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| QuerySlices_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint64_t> start_slices); |
| ~QuerySlices_Impl() = default; |
| QuerySlices_Impl(QuerySlices_Impl&& other) = default; |
| QuerySlices_Impl& operator=(QuerySlices_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class Extend_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| Extend_Impl(::zx::unowned_channel _client_end, uint64_t start_slice, uint64_t slice_count); |
| ~Extend_Impl() = default; |
| Extend_Impl(Extend_Impl&& other) = default; |
| Extend_Impl& operator=(Extend_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class Shrink_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| Shrink_Impl(::zx::unowned_channel _client_end, uint64_t start_slice, uint64_t slice_count); |
| ~Shrink_Impl() = default; |
| Shrink_Impl(Shrink_Impl&& other) = default; |
| Shrink_Impl& operator=(Shrink_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class Destroy_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| Destroy_Impl(::zx::unowned_channel _client_end); |
| ~Destroy_Impl() = default; |
| Destroy_Impl(Destroy_Impl&& other) = default; |
| Destroy_Impl& operator=(Destroy_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| |
| public: |
| using GetInfo = GetInfo_Impl<GetInfoResponse>; |
| using GetStats = GetStats_Impl<GetStatsResponse>; |
| using GetFifo = GetFifo_Impl<GetFifoResponse>; |
| using AttachVmo = AttachVmo_Impl<AttachVmoResponse>; |
| using CloseFifo = CloseFifo_Impl<CloseFifoResponse>; |
| using RebindDevice = RebindDevice_Impl<RebindDeviceResponse>; |
| using GetTypeGuid = GetTypeGuid_Impl<GetTypeGuidResponse>; |
| using GetInstanceGuid = GetInstanceGuid_Impl<GetInstanceGuidResponse>; |
| using GetName = GetName_Impl<GetNameResponse>; |
| using Query = Query_Impl<QueryResponse>; |
| using QuerySlices = QuerySlices_Impl<QuerySlicesResponse>; |
| using Extend = Extend_Impl<ExtendResponse>; |
| using Shrink = Shrink_Impl<ShrinkResponse>; |
| using Destroy = Destroy_Impl<DestroyResponse>; |
| }; |
| |
| // Collection of return types of FIDL calls in this interface, |
| // when the caller-allocate flavor or in-place call is used. |
| class UnownedResultOf final { |
| UnownedResultOf() = delete; |
| private: |
| template <typename ResponseType> |
| class GetInfo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| GetInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| ~GetInfo_Impl() = default; |
| GetInfo_Impl(GetInfo_Impl&& other) = default; |
| GetInfo_Impl& operator=(GetInfo_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class GetStats_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| GetStats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer); |
| ~GetStats_Impl() = default; |
| GetStats_Impl(GetStats_Impl&& other) = default; |
| GetStats_Impl& operator=(GetStats_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class GetFifo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| GetFifo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| ~GetFifo_Impl() = default; |
| GetFifo_Impl(GetFifo_Impl&& other) = default; |
| GetFifo_Impl& operator=(GetFifo_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class AttachVmo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| AttachVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer); |
| ~AttachVmo_Impl() = default; |
| AttachVmo_Impl(AttachVmo_Impl&& other) = default; |
| AttachVmo_Impl& operator=(AttachVmo_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class CloseFifo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| CloseFifo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| ~CloseFifo_Impl() = default; |
| CloseFifo_Impl(CloseFifo_Impl&& other) = default; |
| CloseFifo_Impl& operator=(CloseFifo_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class RebindDevice_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| RebindDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| ~RebindDevice_Impl() = default; |
| RebindDevice_Impl(RebindDevice_Impl&& other) = default; |
| RebindDevice_Impl& operator=(RebindDevice_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class GetTypeGuid_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| GetTypeGuid_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| ~GetTypeGuid_Impl() = default; |
| GetTypeGuid_Impl(GetTypeGuid_Impl&& other) = default; |
| GetTypeGuid_Impl& operator=(GetTypeGuid_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class GetInstanceGuid_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| GetInstanceGuid_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| ~GetInstanceGuid_Impl() = default; |
| GetInstanceGuid_Impl(GetInstanceGuid_Impl&& other) = default; |
| GetInstanceGuid_Impl& operator=(GetInstanceGuid_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class GetName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| GetName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| ~GetName_Impl() = default; |
| GetName_Impl(GetName_Impl&& other) = default; |
| GetName_Impl& operator=(GetName_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class Query_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| Query_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| ~Query_Impl() = default; |
| Query_Impl(Query_Impl&& other) = default; |
| Query_Impl& operator=(Query_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class QuerySlices_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| QuerySlices_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint64_t> start_slices, ::fidl::BytePart _response_buffer); |
| ~QuerySlices_Impl() = default; |
| QuerySlices_Impl(QuerySlices_Impl&& other) = default; |
| QuerySlices_Impl& operator=(QuerySlices_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class Extend_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| Extend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer); |
| ~Extend_Impl() = default; |
| Extend_Impl(Extend_Impl&& other) = default; |
| Extend_Impl& operator=(Extend_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class Shrink_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| Shrink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer); |
| ~Shrink_Impl() = default; |
| Shrink_Impl(Shrink_Impl&& other) = default; |
| Shrink_Impl& operator=(Shrink_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class Destroy_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| Destroy_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| ~Destroy_Impl() = default; |
| Destroy_Impl(Destroy_Impl&& other) = default; |
| Destroy_Impl& operator=(Destroy_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| |
| public: |
| using GetInfo = GetInfo_Impl<GetInfoResponse>; |
| using GetStats = GetStats_Impl<GetStatsResponse>; |
| using GetFifo = GetFifo_Impl<GetFifoResponse>; |
| using AttachVmo = AttachVmo_Impl<AttachVmoResponse>; |
| using CloseFifo = CloseFifo_Impl<CloseFifoResponse>; |
| using RebindDevice = RebindDevice_Impl<RebindDeviceResponse>; |
| using GetTypeGuid = GetTypeGuid_Impl<GetTypeGuidResponse>; |
| using GetInstanceGuid = GetInstanceGuid_Impl<GetInstanceGuidResponse>; |
| using GetName = GetName_Impl<GetNameResponse>; |
| using Query = Query_Impl<QueryResponse>; |
| using QuerySlices = QuerySlices_Impl<QuerySlicesResponse>; |
| using Extend = Extend_Impl<ExtendResponse>; |
| using Shrink = Shrink_Impl<ShrinkResponse>; |
| using Destroy = Destroy_Impl<DestroyResponse>; |
| }; |
| |
| class SyncClient final { |
| public: |
| explicit SyncClient(::zx::channel channel) : channel_(std::move(channel)) {} |
| ~SyncClient() = default; |
| SyncClient(SyncClient&&) = default; |
| SyncClient& operator=(SyncClient&&) = default; |
| |
| const ::zx::channel& channel() const { return channel_; } |
| |
| ::zx::channel* mutable_channel() { return &channel_; } |
| |
| // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::GetInfo GetInfo(); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::GetInfo GetInfo(::fidl::BytePart _response_buffer); |
| |
| // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated. |
| ResultOf::GetStats GetStats(bool clear); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::GetStats GetStats(::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::GetFifo GetFifo(); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::GetFifo GetFifo(::fidl::BytePart _response_buffer); |
| |
| // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::AttachVmo AttachVmo(::zx::vmo vmo); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::AttachVmo AttachVmo(::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::CloseFifo CloseFifo(); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::CloseFifo CloseFifo(::fidl::BytePart _response_buffer); |
| |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::RebindDevice RebindDevice(); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::RebindDevice RebindDevice(::fidl::BytePart _response_buffer); |
| |
| // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::GetTypeGuid GetTypeGuid(); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::GetTypeGuid GetTypeGuid(::fidl::BytePart _response_buffer); |
| |
| // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::GetInstanceGuid GetInstanceGuid(); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::GetInstanceGuid GetInstanceGuid(::fidl::BytePart _response_buffer); |
| |
| // Allocates 184 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::GetName GetName(); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::GetName GetName(::fidl::BytePart _response_buffer); |
| |
| // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::Query Query(); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::Query Query(::fidl::BytePart _response_buffer); |
| |
| // Allocates 448 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::QuerySlices QuerySlices(::fidl::VectorView<uint64_t> start_slices); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::QuerySlices QuerySlices(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint64_t> start_slices, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::Extend Extend(uint64_t start_slice, uint64_t slice_count); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::Extend Extend(::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::Shrink Shrink(uint64_t start_slice, uint64_t slice_count); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::Shrink Shrink(::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::Destroy Destroy(); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::Destroy Destroy(::fidl::BytePart _response_buffer); |
| |
| private: |
| ::zx::channel channel_; |
| }; |
| |
| // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client. |
| class Call final { |
| Call() = delete; |
| public: |
| |
| // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::GetInfo GetInfo(::zx::unowned_channel _client_end); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::GetInfo GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated. |
| static ResultOf::GetStats GetStats(::zx::unowned_channel _client_end, bool clear); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::GetStats GetStats(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::GetFifo GetFifo(::zx::unowned_channel _client_end); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::GetFifo GetFifo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::AttachVmo AttachVmo(::zx::unowned_channel _client_end, ::zx::vmo vmo); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::AttachVmo AttachVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::CloseFifo CloseFifo(::zx::unowned_channel _client_end); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::CloseFifo CloseFifo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::RebindDevice RebindDevice(::zx::unowned_channel _client_end); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::RebindDevice RebindDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::GetTypeGuid GetTypeGuid(::zx::unowned_channel _client_end); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::GetTypeGuid GetTypeGuid(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::GetInstanceGuid GetInstanceGuid(::zx::unowned_channel _client_end); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::GetInstanceGuid GetInstanceGuid(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 184 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::GetName GetName(::zx::unowned_channel _client_end); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::GetName GetName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::Query Query(::zx::unowned_channel _client_end); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::Query Query(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 448 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::QuerySlices QuerySlices(::zx::unowned_channel _client_end, ::fidl::VectorView<uint64_t> start_slices); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::QuerySlices QuerySlices(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint64_t> start_slices, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::Extend Extend(::zx::unowned_channel _client_end, uint64_t start_slice, uint64_t slice_count); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::Extend Extend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::Shrink Shrink(::zx::unowned_channel _client_end, uint64_t start_slice, uint64_t slice_count); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::Shrink Shrink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::Destroy Destroy(::zx::unowned_channel _client_end); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::Destroy Destroy(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| |
| }; |
| |
| // Messages are encoded and decoded in-place when these methods are used. |
| // Additionally, requests must be already laid-out according to the FIDL wire-format. |
| class InPlace final { |
| InPlace() = delete; |
| public: |
| |
| static ::fidl::DecodeResult<GetInfoResponse> GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<GetStatsResponse> GetStats(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetStatsRequest> params, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<GetFifoResponse> GetFifo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<AttachVmoResponse> AttachVmo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AttachVmoRequest> params, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<CloseFifoResponse> CloseFifo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<RebindDeviceResponse> RebindDevice(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<GetTypeGuidResponse> GetTypeGuid(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<GetInstanceGuidResponse> GetInstanceGuid(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<GetNameResponse> GetName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<QueryResponse> Query(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<QuerySlicesResponse> QuerySlices(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<QuerySlicesRequest> params, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<ExtendResponse> Extend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ExtendRequest> params, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<ShrinkResponse> Shrink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ShrinkRequest> params, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<DestroyResponse> Destroy(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer); |
| |
| }; |
| |
| // Pure-virtual interface to be implemented by a server. |
| class Interface { |
| public: |
| Interface() = default; |
| virtual ~Interface() = default; |
| using _Outer = Volume; |
| using _Base = ::fidl::CompleterBase; |
| |
| class GetInfoCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status, ::llcpp::fuchsia::hardware::block::BlockInfo* info); |
| void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::BlockInfo* info); |
| void Reply(::fidl::DecodedMessage<GetInfoResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using GetInfoCompleter = ::fidl::Completer<GetInfoCompleterBase>; |
| |
| virtual void GetInfo(GetInfoCompleter::Sync _completer) = 0; |
| |
| class GetStatsCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status, ::llcpp::fuchsia::hardware::block::BlockStats* stats); |
| void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::BlockStats* stats); |
| void Reply(::fidl::DecodedMessage<GetStatsResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using GetStatsCompleter = ::fidl::Completer<GetStatsCompleterBase>; |
| |
| virtual void GetStats(bool clear, GetStatsCompleter::Sync _completer) = 0; |
| |
| class GetFifoCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status, ::zx::fifo fifo); |
| void Reply(::fidl::BytePart _buffer, int32_t status, ::zx::fifo fifo); |
| void Reply(::fidl::DecodedMessage<GetFifoResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using GetFifoCompleter = ::fidl::Completer<GetFifoCompleterBase>; |
| |
| virtual void GetFifo(GetFifoCompleter::Sync _completer) = 0; |
| |
| class AttachVmoCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status, ::llcpp::fuchsia::hardware::block::VmoID* vmoid); |
| void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::VmoID* vmoid); |
| void Reply(::fidl::DecodedMessage<AttachVmoResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using AttachVmoCompleter = ::fidl::Completer<AttachVmoCompleterBase>; |
| |
| virtual void AttachVmo(::zx::vmo vmo, AttachVmoCompleter::Sync _completer) = 0; |
| |
| class CloseFifoCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status); |
| void Reply(::fidl::BytePart _buffer, int32_t status); |
| void Reply(::fidl::DecodedMessage<CloseFifoResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using CloseFifoCompleter = ::fidl::Completer<CloseFifoCompleterBase>; |
| |
| virtual void CloseFifo(CloseFifoCompleter::Sync _completer) = 0; |
| |
| class RebindDeviceCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status); |
| void Reply(::fidl::BytePart _buffer, int32_t status); |
| void Reply(::fidl::DecodedMessage<RebindDeviceResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using RebindDeviceCompleter = ::fidl::Completer<RebindDeviceCompleterBase>; |
| |
| virtual void RebindDevice(RebindDeviceCompleter::Sync _completer) = 0; |
| |
| class GetTypeGuidCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid); |
| void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid); |
| void Reply(::fidl::DecodedMessage<GetTypeGuidResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using GetTypeGuidCompleter = ::fidl::Completer<GetTypeGuidCompleterBase>; |
| |
| virtual void GetTypeGuid(GetTypeGuidCompleter::Sync _completer) = 0; |
| |
| class GetInstanceGuidCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid); |
| void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid); |
| void Reply(::fidl::DecodedMessage<GetInstanceGuidResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using GetInstanceGuidCompleter = ::fidl::Completer<GetInstanceGuidCompleterBase>; |
| |
| virtual void GetInstanceGuid(GetInstanceGuidCompleter::Sync _completer) = 0; |
| |
| class GetNameCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status, ::fidl::StringView name); |
| void Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::StringView name); |
| void Reply(::fidl::DecodedMessage<GetNameResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using GetNameCompleter = ::fidl::Completer<GetNameCompleterBase>; |
| |
| virtual void GetName(GetNameCompleter::Sync _completer) = 0; |
| |
| class QueryCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeInfo* info); |
| void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeInfo* info); |
| void Reply(::fidl::DecodedMessage<QueryResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using QueryCompleter = ::fidl::Completer<QueryCompleterBase>; |
| |
| virtual void Query(QueryCompleter::Sync _completer) = 0; |
| |
| class QuerySlicesCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status, ::fidl::Array<::llcpp::fuchsia::hardware::block::volume::VsliceRange, 16> response, uint64_t response_count); |
| void Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::Array<::llcpp::fuchsia::hardware::block::volume::VsliceRange, 16> response, uint64_t response_count); |
| void Reply(::fidl::DecodedMessage<QuerySlicesResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using QuerySlicesCompleter = ::fidl::Completer<QuerySlicesCompleterBase>; |
| |
| virtual void QuerySlices(::fidl::VectorView<uint64_t> start_slices, QuerySlicesCompleter::Sync _completer) = 0; |
| |
| class ExtendCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status); |
| void Reply(::fidl::BytePart _buffer, int32_t status); |
| void Reply(::fidl::DecodedMessage<ExtendResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using ExtendCompleter = ::fidl::Completer<ExtendCompleterBase>; |
| |
| virtual void Extend(uint64_t start_slice, uint64_t slice_count, ExtendCompleter::Sync _completer) = 0; |
| |
| class ShrinkCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status); |
| void Reply(::fidl::BytePart _buffer, int32_t status); |
| void Reply(::fidl::DecodedMessage<ShrinkResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using ShrinkCompleter = ::fidl::Completer<ShrinkCompleterBase>; |
| |
| virtual void Shrink(uint64_t start_slice, uint64_t slice_count, ShrinkCompleter::Sync _completer) = 0; |
| |
| class DestroyCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status); |
| void Reply(::fidl::BytePart _buffer, int32_t status); |
| void Reply(::fidl::DecodedMessage<DestroyResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using DestroyCompleter = ::fidl::Completer<DestroyCompleterBase>; |
| |
| virtual void Destroy(DestroyCompleter::Sync _completer) = 0; |
| |
| }; |
| |
| // Attempts to dispatch the incoming message to a handler function in the server implementation. |
| // If there is no matching handler, it returns false, leaving the message and transaction intact. |
| // In all other cases, it consumes the message and returns true. |
| // It is possible to chain multiple TryDispatch functions in this manner. |
| static bool TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn); |
| |
| // Dispatches the incoming message to one of the handlers functions in the interface. |
| // If there is no matching handler, it closes all the handles in |msg| and closes the channel with |
| // a |ZX_ERR_NOT_SUPPORTED| epitaph, before returning false. The message should then be discarded. |
| static bool Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn); |
| |
| // Same as |Dispatch|, but takes a |void*| instead of |Interface*|. Only used with |fidl::Bind| |
| // to reduce template expansion. |
| // Do not call this method manually. Use |Dispatch| instead. |
| static bool TypeErasedDispatch(void* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) { |
| return Dispatch(static_cast<Interface*>(impl), msg, txn); |
| } |
| |
| |
| // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|. |
| class SetTransactionHeaderFor final { |
| SetTransactionHeaderFor() = delete; |
| public: |
| static void GetInfoRequest(const ::fidl::DecodedMessage<Volume::GetInfoRequest>& _msg); |
| static void GetInfoResponse(const ::fidl::DecodedMessage<Volume::GetInfoResponse>& _msg); |
| static void GetStatsRequest(const ::fidl::DecodedMessage<Volume::GetStatsRequest>& _msg); |
| static void GetStatsResponse(const ::fidl::DecodedMessage<Volume::GetStatsResponse>& _msg); |
| static void GetFifoRequest(const ::fidl::DecodedMessage<Volume::GetFifoRequest>& _msg); |
| static void GetFifoResponse(const ::fidl::DecodedMessage<Volume::GetFifoResponse>& _msg); |
| static void AttachVmoRequest(const ::fidl::DecodedMessage<Volume::AttachVmoRequest>& _msg); |
| static void AttachVmoResponse(const ::fidl::DecodedMessage<Volume::AttachVmoResponse>& _msg); |
| static void CloseFifoRequest(const ::fidl::DecodedMessage<Volume::CloseFifoRequest>& _msg); |
| static void CloseFifoResponse(const ::fidl::DecodedMessage<Volume::CloseFifoResponse>& _msg); |
| static void RebindDeviceRequest(const ::fidl::DecodedMessage<Volume::RebindDeviceRequest>& _msg); |
| static void RebindDeviceResponse(const ::fidl::DecodedMessage<Volume::RebindDeviceResponse>& _msg); |
| static void GetTypeGuidRequest(const ::fidl::DecodedMessage<Volume::GetTypeGuidRequest>& _msg); |
| static void GetTypeGuidResponse(const ::fidl::DecodedMessage<Volume::GetTypeGuidResponse>& _msg); |
| static void GetInstanceGuidRequest(const ::fidl::DecodedMessage<Volume::GetInstanceGuidRequest>& _msg); |
| static void GetInstanceGuidResponse(const ::fidl::DecodedMessage<Volume::GetInstanceGuidResponse>& _msg); |
| static void GetNameRequest(const ::fidl::DecodedMessage<Volume::GetNameRequest>& _msg); |
| static void GetNameResponse(const ::fidl::DecodedMessage<Volume::GetNameResponse>& _msg); |
| static void QueryRequest(const ::fidl::DecodedMessage<Volume::QueryRequest>& _msg); |
| static void QueryResponse(const ::fidl::DecodedMessage<Volume::QueryResponse>& _msg); |
| static void QuerySlicesRequest(const ::fidl::DecodedMessage<Volume::QuerySlicesRequest>& _msg); |
| static void QuerySlicesResponse(const ::fidl::DecodedMessage<Volume::QuerySlicesResponse>& _msg); |
| static void ExtendRequest(const ::fidl::DecodedMessage<Volume::ExtendRequest>& _msg); |
| static void ExtendResponse(const ::fidl::DecodedMessage<Volume::ExtendResponse>& _msg); |
| static void ShrinkRequest(const ::fidl::DecodedMessage<Volume::ShrinkRequest>& _msg); |
| static void ShrinkResponse(const ::fidl::DecodedMessage<Volume::ShrinkResponse>& _msg); |
| static void DestroyRequest(const ::fidl::DecodedMessage<Volume::DestroyRequest>& _msg); |
| static void DestroyResponse(const ::fidl::DecodedMessage<Volume::DestroyResponse>& _msg); |
| }; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerAllocatePartitionRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerAllocatePartitionResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerQueryRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerQueryResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerGetInfoRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerGetInfoResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerActivateRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerActivateResponseTable; |
| |
| class VolumeManager final { |
| VolumeManager() = delete; |
| public: |
| |
| struct AllocatePartitionResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeManagerAllocatePartitionResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| struct AllocatePartitionRequest final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| uint64_t slice_count; |
| ::llcpp::fuchsia::hardware::block::partition::GUID type; |
| ::llcpp::fuchsia::hardware::block::partition::GUID instance; |
| ::fidl::StringView name; |
| uint32_t flags; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeManagerAllocatePartitionRequestTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 80; |
| static constexpr uint32_t MaxOutOfLine = 128; |
| static constexpr uint32_t AltPrimarySize = 80; |
| static constexpr uint32_t AltMaxOutOfLine = 128; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| using ResponseType = AllocatePartitionResponse; |
| }; |
| |
| struct QueryResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| ::llcpp::fuchsia::hardware::block::volume::VolumeInfo* info; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeManagerQueryResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| static constexpr uint32_t MaxOutOfLine = 32; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| using QueryRequest = ::fidl::AnyZeroArgMessage; |
| |
| struct GetInfoResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| ::llcpp::fuchsia::hardware::block::volume::VolumeManagerInfo* info; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeManagerGetInfoResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| static constexpr uint32_t MaxOutOfLine = 24; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| using GetInfoRequest = ::fidl::AnyZeroArgMessage; |
| |
| struct ActivateResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| int32_t status; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeManagerActivateResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| struct ActivateRequest final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| ::llcpp::fuchsia::hardware::block::partition::GUID old_guid; |
| ::llcpp::fuchsia::hardware::block::partition::GUID new_guid; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_volume_VolumeManagerActivateRequestTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 48; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr uint32_t AltPrimarySize = 48; |
| static constexpr uint32_t AltMaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| using ResponseType = ActivateResponse; |
| }; |
| |
| |
| // Collection of return types of FIDL calls in this interface. |
| class ResultOf final { |
| ResultOf() = delete; |
| private: |
| template <typename ResponseType> |
| class AllocatePartition_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| AllocatePartition_Impl(::zx::unowned_channel _client_end, uint64_t slice_count, ::llcpp::fuchsia::hardware::block::partition::GUID type, ::llcpp::fuchsia::hardware::block::partition::GUID instance, ::fidl::StringView name, uint32_t flags); |
| ~AllocatePartition_Impl() = default; |
| AllocatePartition_Impl(AllocatePartition_Impl&& other) = default; |
| AllocatePartition_Impl& operator=(AllocatePartition_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class Query_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| Query_Impl(::zx::unowned_channel _client_end); |
| ~Query_Impl() = default; |
| Query_Impl(Query_Impl&& other) = default; |
| Query_Impl& operator=(Query_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class GetInfo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| GetInfo_Impl(::zx::unowned_channel _client_end); |
| ~GetInfo_Impl() = default; |
| GetInfo_Impl(GetInfo_Impl&& other) = default; |
| GetInfo_Impl& operator=(GetInfo_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class Activate_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| Activate_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid); |
| ~Activate_Impl() = default; |
| Activate_Impl(Activate_Impl&& other) = default; |
| Activate_Impl& operator=(Activate_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| |
| public: |
| using AllocatePartition = AllocatePartition_Impl<AllocatePartitionResponse>; |
| using Query = Query_Impl<QueryResponse>; |
| using GetInfo = GetInfo_Impl<GetInfoResponse>; |
| using Activate = Activate_Impl<ActivateResponse>; |
| }; |
| |
| // Collection of return types of FIDL calls in this interface, |
| // when the caller-allocate flavor or in-place call is used. |
| class UnownedResultOf final { |
| UnownedResultOf() = delete; |
| private: |
| template <typename ResponseType> |
| class AllocatePartition_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| AllocatePartition_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t slice_count, ::llcpp::fuchsia::hardware::block::partition::GUID type, ::llcpp::fuchsia::hardware::block::partition::GUID instance, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer); |
| ~AllocatePartition_Impl() = default; |
| AllocatePartition_Impl(AllocatePartition_Impl&& other) = default; |
| AllocatePartition_Impl& operator=(AllocatePartition_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class Query_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| Query_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| ~Query_Impl() = default; |
| Query_Impl(Query_Impl&& other) = default; |
| Query_Impl& operator=(Query_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class GetInfo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| GetInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| ~GetInfo_Impl() = default; |
| GetInfo_Impl(GetInfo_Impl&& other) = default; |
| GetInfo_Impl& operator=(GetInfo_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class Activate_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| Activate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid, ::fidl::BytePart _response_buffer); |
| ~Activate_Impl() = default; |
| Activate_Impl(Activate_Impl&& other) = default; |
| Activate_Impl& operator=(Activate_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| |
| public: |
| using AllocatePartition = AllocatePartition_Impl<AllocatePartitionResponse>; |
| using Query = Query_Impl<QueryResponse>; |
| using GetInfo = GetInfo_Impl<GetInfoResponse>; |
| using Activate = Activate_Impl<ActivateResponse>; |
| }; |
| |
| class SyncClient final { |
| public: |
| explicit SyncClient(::zx::channel channel) : channel_(std::move(channel)) {} |
| ~SyncClient() = default; |
| SyncClient(SyncClient&&) = default; |
| SyncClient& operator=(SyncClient&&) = default; |
| |
| const ::zx::channel& channel() const { return channel_; } |
| |
| ::zx::channel* mutable_channel() { return &channel_; } |
| |
| // Allocates 232 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::AllocatePartition AllocatePartition(uint64_t slice_count, ::llcpp::fuchsia::hardware::block::partition::GUID type, ::llcpp::fuchsia::hardware::block::partition::GUID instance, ::fidl::StringView name, uint32_t flags); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::AllocatePartition AllocatePartition(::fidl::BytePart _request_buffer, uint64_t slice_count, ::llcpp::fuchsia::hardware::block::partition::GUID type, ::llcpp::fuchsia::hardware::block::partition::GUID instance, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::Query Query(); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::Query Query(::fidl::BytePart _response_buffer); |
| |
| // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::GetInfo GetInfo(); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::GetInfo GetInfo(::fidl::BytePart _response_buffer); |
| |
| // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::Activate Activate(::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::Activate Activate(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid, ::fidl::BytePart _response_buffer); |
| |
| private: |
| ::zx::channel channel_; |
| }; |
| |
| // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client. |
| class Call final { |
| Call() = delete; |
| public: |
| |
| // Allocates 232 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::AllocatePartition AllocatePartition(::zx::unowned_channel _client_end, uint64_t slice_count, ::llcpp::fuchsia::hardware::block::partition::GUID type, ::llcpp::fuchsia::hardware::block::partition::GUID instance, ::fidl::StringView name, uint32_t flags); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::AllocatePartition AllocatePartition(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t slice_count, ::llcpp::fuchsia::hardware::block::partition::GUID type, ::llcpp::fuchsia::hardware::block::partition::GUID instance, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::Query Query(::zx::unowned_channel _client_end); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::Query Query(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::GetInfo GetInfo(::zx::unowned_channel _client_end); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::GetInfo GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| |
| // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::Activate Activate(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid); |
| |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::Activate Activate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid, ::fidl::BytePart _response_buffer); |
| |
| }; |
| |
| // Messages are encoded and decoded in-place when these methods are used. |
| // Additionally, requests must be already laid-out according to the FIDL wire-format. |
| class InPlace final { |
| InPlace() = delete; |
| public: |
| |
| static ::fidl::DecodeResult<AllocatePartitionResponse> AllocatePartition(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AllocatePartitionRequest> params, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<QueryResponse> Query(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<GetInfoResponse> GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer); |
| |
| static ::fidl::DecodeResult<ActivateResponse> Activate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ActivateRequest> params, ::fidl::BytePart response_buffer); |
| |
| }; |
| |
| // Pure-virtual interface to be implemented by a server. |
| class Interface { |
| public: |
| Interface() = default; |
| virtual ~Interface() = default; |
| using _Outer = VolumeManager; |
| using _Base = ::fidl::CompleterBase; |
| |
| class AllocatePartitionCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status); |
| void Reply(::fidl::BytePart _buffer, int32_t status); |
| void Reply(::fidl::DecodedMessage<AllocatePartitionResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using AllocatePartitionCompleter = ::fidl::Completer<AllocatePartitionCompleterBase>; |
| |
| virtual void AllocatePartition(uint64_t slice_count, ::llcpp::fuchsia::hardware::block::partition::GUID type, ::llcpp::fuchsia::hardware::block::partition::GUID instance, ::fidl::StringView name, uint32_t flags, AllocatePartitionCompleter::Sync _completer) = 0; |
| |
| class QueryCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeInfo* info); |
| void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeInfo* info); |
| void Reply(::fidl::DecodedMessage<QueryResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using QueryCompleter = ::fidl::Completer<QueryCompleterBase>; |
| |
| virtual void Query(QueryCompleter::Sync _completer) = 0; |
| |
| class GetInfoCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeManagerInfo* info); |
| void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeManagerInfo* info); |
| void Reply(::fidl::DecodedMessage<GetInfoResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using GetInfoCompleter = ::fidl::Completer<GetInfoCompleterBase>; |
| |
| virtual void GetInfo(GetInfoCompleter::Sync _completer) = 0; |
| |
| class ActivateCompleterBase : public _Base { |
| public: |
| void Reply(int32_t status); |
| void Reply(::fidl::BytePart _buffer, int32_t status); |
| void Reply(::fidl::DecodedMessage<ActivateResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using ActivateCompleter = ::fidl::Completer<ActivateCompleterBase>; |
| |
| virtual void Activate(::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid, ActivateCompleter::Sync _completer) = 0; |
| |
| }; |
| |
| // Attempts to dispatch the incoming message to a handler function in the server implementation. |
| // If there is no matching handler, it returns false, leaving the message and transaction intact. |
| // In all other cases, it consumes the message and returns true. |
| // It is possible to chain multiple TryDispatch functions in this manner. |
| static bool TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn); |
| |
| // Dispatches the incoming message to one of the handlers functions in the interface. |
| // If there is no matching handler, it closes all the handles in |msg| and closes the channel with |
| // a |ZX_ERR_NOT_SUPPORTED| epitaph, before returning false. The message should then be discarded. |
| static bool Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn); |
| |
| // Same as |Dispatch|, but takes a |void*| instead of |Interface*|. Only used with |fidl::Bind| |
| // to reduce template expansion. |
| // Do not call this method manually. Use |Dispatch| instead. |
| static bool TypeErasedDispatch(void* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) { |
| return Dispatch(static_cast<Interface*>(impl), msg, txn); |
| } |
| |
| |
| // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|. |
| class SetTransactionHeaderFor final { |
| SetTransactionHeaderFor() = delete; |
| public: |
| static void AllocatePartitionRequest(const ::fidl::DecodedMessage<VolumeManager::AllocatePartitionRequest>& _msg); |
| static void AllocatePartitionResponse(const ::fidl::DecodedMessage<VolumeManager::AllocatePartitionResponse>& _msg); |
| static void QueryRequest(const ::fidl::DecodedMessage<VolumeManager::QueryRequest>& _msg); |
| static void QueryResponse(const ::fidl::DecodedMessage<VolumeManager::QueryResponse>& _msg); |
| static void GetInfoRequest(const ::fidl::DecodedMessage<VolumeManager::GetInfoRequest>& _msg); |
| static void GetInfoResponse(const ::fidl::DecodedMessage<VolumeManager::GetInfoResponse>& _msg); |
| static void ActivateRequest(const ::fidl::DecodedMessage<VolumeManager::ActivateRequest>& _msg); |
| static void ActivateResponse(const ::fidl::DecodedMessage<VolumeManager::ActivateResponse>& _msg); |
| }; |
| }; |
| |
| } // namespace volume |
| } // namespace block |
| } // namespace hardware |
| } // namespace fuchsia |
| } // namespace llcpp |
| |
| namespace fidl { |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::VsliceRange> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::block::volume::VsliceRange>); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VsliceRange, allocated) == 0); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VsliceRange, count) == 8); |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::VsliceRange) == ::llcpp::fuchsia::hardware::block::volume::VsliceRange::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::VolumeManagerInfo> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::block::volume::VolumeManagerInfo>); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManagerInfo, slice_size) == 0); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManagerInfo, current_slice_count) == 8); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManagerInfo, maximum_slice_count) == 16); |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::VolumeManagerInfo) == ::llcpp::fuchsia::hardware::block::volume::VolumeManagerInfo::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::VolumeInfo> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::block::volume::VolumeInfo>); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeInfo, slice_size) == 0); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeInfo, vslice_count) == 8); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeInfo, pslice_total_count) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeInfo, pslice_allocated_count) == 24); |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::VolumeInfo) == ::llcpp::fuchsia::hardware::block::volume::VolumeInfo::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::GetInfoResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::GetInfoResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::GetInfoResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::GetInfoResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::GetInfoResponse, status) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::GetInfoResponse, info) == 24); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::GetStatsRequest> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::GetStatsRequest> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::GetStatsRequest) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::GetStatsRequest::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::GetStatsRequest, clear) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::GetStatsResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::GetStatsResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::GetStatsResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::GetStatsResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::GetStatsResponse, status) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::GetStatsResponse, stats) == 24); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::GetFifoResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::GetFifoResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::GetFifoResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::GetFifoResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::GetFifoResponse, status) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::GetFifoResponse, fifo) == 20); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::AttachVmoRequest> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::AttachVmoRequest> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::AttachVmoRequest) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::AttachVmoRequest::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::AttachVmoRequest, vmo) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::AttachVmoResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::AttachVmoResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::AttachVmoResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::AttachVmoResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::AttachVmoResponse, status) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::AttachVmoResponse, vmoid) == 24); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::CloseFifoResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::CloseFifoResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::CloseFifoResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::CloseFifoResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::CloseFifoResponse, status) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::RebindDeviceResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::RebindDeviceResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::RebindDeviceResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::RebindDeviceResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::RebindDeviceResponse, status) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::GetTypeGuidResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::GetTypeGuidResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::GetTypeGuidResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::GetTypeGuidResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::GetTypeGuidResponse, status) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::GetTypeGuidResponse, guid) == 24); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::GetInstanceGuidResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::GetInstanceGuidResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::GetInstanceGuidResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::GetInstanceGuidResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::GetInstanceGuidResponse, status) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::GetInstanceGuidResponse, guid) == 24); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::GetNameResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::GetNameResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::GetNameResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::GetNameResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::GetNameResponse, status) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::GetNameResponse, name) == 24); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::QueryResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::QueryResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::QueryResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::QueryResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::QueryResponse, status) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::QueryResponse, info) == 24); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::QuerySlicesRequest> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::QuerySlicesRequest> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::QuerySlicesRequest) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::QuerySlicesRequest::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::QuerySlicesRequest, start_slices) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::QuerySlicesResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::QuerySlicesResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::QuerySlicesResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::QuerySlicesResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::QuerySlicesResponse, status) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::QuerySlicesResponse, response) == 24); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::QuerySlicesResponse, response_count) == 280); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::ExtendRequest> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::ExtendRequest> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::ExtendRequest) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::ExtendRequest::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::ExtendRequest, start_slice) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::ExtendRequest, slice_count) == 24); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::ExtendResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::ExtendResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::ExtendResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::ExtendResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::ExtendResponse, status) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::ShrinkRequest> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::ShrinkRequest> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::ShrinkRequest) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::ShrinkRequest::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::ShrinkRequest, start_slice) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::ShrinkRequest, slice_count) == 24); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::ShrinkResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::ShrinkResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::ShrinkResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::ShrinkResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::ShrinkResponse, status) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::Volume::DestroyResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::Volume::DestroyResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::Volume::DestroyResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::Volume::DestroyResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::Volume::DestroyResponse, status) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::VolumeManager::AllocatePartitionRequest> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::VolumeManager::AllocatePartitionRequest> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::AllocatePartitionRequest) |
| == ::llcpp::fuchsia::hardware::block::volume::VolumeManager::AllocatePartitionRequest::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::AllocatePartitionRequest, slice_count) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::AllocatePartitionRequest, type) == 24); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::AllocatePartitionRequest, instance) == 40); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::AllocatePartitionRequest, name) == 56); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::AllocatePartitionRequest, flags) == 72); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::VolumeManager::AllocatePartitionResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::VolumeManager::AllocatePartitionResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::AllocatePartitionResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::VolumeManager::AllocatePartitionResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::AllocatePartitionResponse, status) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::VolumeManager::QueryResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::VolumeManager::QueryResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::QueryResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::VolumeManager::QueryResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::QueryResponse, status) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::QueryResponse, info) == 24); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::VolumeManager::GetInfoResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::VolumeManager::GetInfoResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::GetInfoResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::VolumeManager::GetInfoResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::GetInfoResponse, status) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::GetInfoResponse, info) == 24); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::VolumeManager::ActivateRequest> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::VolumeManager::ActivateRequest> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::ActivateRequest) |
| == ::llcpp::fuchsia::hardware::block::volume::VolumeManager::ActivateRequest::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::ActivateRequest, old_guid) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::ActivateRequest, new_guid) == 32); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::hardware::block::volume::VolumeManager::ActivateResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::hardware::block::volume::VolumeManager::ActivateResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::ActivateResponse) |
| == ::llcpp::fuchsia::hardware::block::volume::VolumeManager::ActivateResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::hardware::block::volume::VolumeManager::ActivateResponse, status) == 16); |
| |
| } // namespace fidl |