fidl

Summary

Enumerations
`ErrorOrigin{ kReceive, kSend }`	enum
`MessageDirection{ kReceiving, kSending }`	enum
`Reason{ __DoNotUse = 0, kUnbind = 1, kClose, kPendingTwoWayCallPreventsUnbind, kCanceledDueToOtherError, kPeerClosedWhileReading, kDispatcherError, kTransportError, kEncodeError, kDecodeError, kUnexpectedMessage, kUnknownMethod, kAbandonedAsyncReply }`	enum
`UnknownMethodType{ kOneWay, kTwoWay }`	enum

Typedefs
`AnyMemoryResource`	using `fit::inline_any< MemoryResource, 24, 8 >`
`AsyncClientBuffer`	using `internal::InlineMessageBuffer< AsyncClientMethodBufferSizeInChannel< FidlMethod >()>`
`BytePart`	using `MessagePart< uint8_t >`
`ClientCallback`	using `typename internal::NaturalMethodTypes< Method >::ResultCallback`
`Error`	typedef `Status`
`Event`	using `std::enable_if_t< Method::kHasServerToClient &&!Method::kHasClientToServer, typename fidl::internal::NaturalMethodTypes< Method >::Request >`
`EventBuffer`	using `internal::InlineMessageBuffer< EventReplyBufferSizeInChannel< FidlMethod >()>`
`FrameworkErr`	using `::fidl::internal::FrameworkErr`
`HandleDispositionPart`	using `MessagePart< zx_handle_disposition_t >`
`HandleInfoPart`	using `MessagePart< zx_handle_info_t >`
`HandlePart`	using `MessagePart< zx_handle_t >`
`InterfaceRequestHandler`	using `fit::function< void(fidl::InterfaceRequest< Interface > request)>`
`OnUnboundFn`	using `fit::callback< void(ServerImpl *, UnbindInfo, internal::ServerEndType< Protocol >)>`
`OneWayError`	using `OneWayStatus`
`Request`	using `std::enable_if_t< Method::kHasClientToServer, typename fidl::internal::NaturalMethodTypes< Method >::Request >`
`ServerBuffer`	using `internal::InlineMessageBuffer< ServerReplyBufferSizeInChannel< FidlMethod >()>`
`SyncClientBuffer`	using `internal::InlineMessageBuffer< SyncClientMethodBufferSizeInChannel< FidlMethod >()>`
`UnknownMethodCompleter`	using `::fidl::Completer<>`
`WireResultUnwrapType`	using `typename::fidl::internal::WireResultUnwrap< FidlMethod >::Type`

Functions
`Arena() -> Arena< initial_capacity >`
`AsyncClientMethodBufferSizeInChannel()`	`constexpr uint32_t`
`BindServer(async_dispatcher_t dispatcher, fidl::ServerEnd< Protocol > server_end, ServerImpl impl, OnUnbound && on_unbound)`	`ServerBindingRef< Protocol >`
`BindServer(async_dispatcher_t *dispatcher, fidl::ServerEnd< Protocol > server_end, std::unique_ptr< ServerImpl > && impl, OnUnbound && on_unbound)`	`ServerBindingRef< Protocol >`
`BindServer(async_dispatcher_t *dispatcher, fidl::ServerEnd< Protocol > server_end, std::shared_ptr< ServerImpl > impl, OnUnbound && on_unbound)`	`ServerBindingRef< Protocol >`
`Call(const fidl::ClientEnd< FidlProtocol > & client_end)`	`internal::SyncEndpointManagedVeneer< internal::NaturalSyncClientImpl< FidlProtocol > >`
`Call(const fidl::UnownedClientEnd< FidlProtocol > & client_end)`	`internal::SyncEndpointManagedVeneer< internal::NaturalSyncClientImpl< FidlProtocol > >`
`Client(fidl::ClientEnd< Protocol >, async_dispatcher_t *, AsyncEventHandlerReference &&) -> Client< Protocol >`
`Client(fidl::ClientEnd< Protocol >, async_dispatcher_t *) -> Client< Protocol >`
`Clone(::fidl::internal::FrameworkErr value, ::fidl::internal::FrameworkErr *result)`	`zx_status_t`
`Clone(const T & value, T *result)`	`std::enable_if< IsPrimitive< T >::value, zx_status_t >::type`
`Clone(const std::array< T, N > & value, std::array< T, N > *result)`	`std::enable_if< IsPrimitive< T >::value\|\|IsStdString< T >::value, zx_status_t >::type`
`Clone(const std::array< T, N > & value, std::array< T, N > *result)`	`std::enable_ifIsPrimitive< T >::value &&!IsStdString< T >::value, zx_status_t >::type`
`Clone(const T & value, T *result)`	`std::enable_ifIsPrimitive< T >::value &&!IsStdVector< T >::value &&!IsStdArray< T >::value, zx_status_t >::type`
`Clone(const StringPtr & value, StringPtr *result)`	`zx_status_t`
`Clone(const ::std::string & value, std::string *result)`	`zx_status_t`
`Clone(const std::unique_ptr< T > & value, std::unique_ptr< T > *result)`	`zx_status_t`
`Clone(const VectorPtr< T > & value, VectorPtr< T > *result)`	`std::enable_if< IsPrimitive< T >::value\|\|IsStdString< T >::value, zx_status_t >::type`
`Clone(const ::std::vector< T > & value, ::std::vector< T > *result)`	`std::enable_if< IsPrimitive< T >::value\|\|IsStdString< T >::value, zx_status_t >::type`
`Clone(const ::std::vector< T > & value, ::std::vector< T > *result)`	`std::enable_ifIsPrimitive< T >::value &&!IsStdString< T >::value, zx_status_t >::type`
`Clone(const VectorPtr< T > & value, VectorPtr< T > *result)`	`std::enable_ifIsPrimitive< T >::value &&!IsStdString< T >::value, zx_status_t >::type`
`Clone(const ::std::array< T, N > & value, ::std::array< T, N > *result)`	`std::enable_if< IsPrimitive< T >::value\|\|IsStdString< T >::value, zx_status_t >::type`
`Clone(const UnknownBytes & value, UnknownBytes *result)`	`zx_status_t`
`Clone(const ::std::map< uint64_t,::std::vector< uint8_t >> & value, ::std::map< uint64_t,::std::vector< uint8_t >> *result)`	`zx_status_t`
`Clone(const T & value)`	`T`
`Clone(const InterfaceHandle< T > & value, InterfaceHandle< T > *result)`	`zx_status_t`
`Clone(const InterfaceRequest< T > & value, InterfaceRequest< T > *result)`	`zx_status_t`
`CreateEndpoints()`	`zx::result< Endpoints< Protocol > >`
`CreateEndpoints(fidl::ClientEnd< Protocol > *out_client)`	`zx::result< fidl::ServerEnd< Protocol > >`
`CreateEndpoints(fidl::ServerEnd< Protocol > *out_server)`	`zx::result< fidl::ClientEnd< Protocol > >`
`Decode(DecoderImpl decoder, T value, size_t offset)`	`void`
`DecodeAs(DecoderImpl *decoder, size_t offset)`	`T`
`DecodeUnknownBytesContents(DecoderImpl decoder, std::vector< uint8_t > value, size_t offset)`	`void`
`DecodingInlineSize(DecoderImpl *decoder)`	`size_t`
`Encode(EncoderImpl encoder, T value, size_t offset, cpp17::optional< HandleInformation > maybe_handle_info)`	`void`
`EncodeNullVector(EncoderImpl *encoder, size_t offset)`	`void`
`EncodeUnknownBytes(EncoderImpl encoder, std::vector< uint8_t > value, size_t envelope_offset)`	`void`
`EncodeUnknownBytesContents(EncoderImpl encoder, std::vector< uint8_t > value, size_t offset)`	`void`
`EncodeVectorPointer(EncoderImpl *encoder, size_t count, size_t offset)`	`void`
`EncodingInlineSize(EncoderImpl *encoder)`	`size_t`
`Equals(const T & lhs, const T & rhs)`	`bool`
`EventReplyBufferSizeInChannel()`	`constexpr uint32_t`
`HLCPPToNatural(HLCPP && value)`	`auto`
`InitTxnHeader(fidl_message_header_t *out_hdr, zx_txid_t txid, uint64_t ordinal, MessageDynamicFlags dynamic_flags)`	`void`
`InplaceUnpersist(cpp20::span< uint8_t > data)`	`fit::result< fidl::Error, fidl::ObjectView< FidlType > >`
`IsByteOverflow(const fidl_message_header_t *hdr)`	`bool`
`IsFlexibleInteraction(const fidl_message_header_t *hdr)`	`bool`
`MaxSizeInChannel()`	`constexpr uint32_t`
`MessageRead(TransportObject && transport, typename internal::AssociatedTransport< TransportObject >::MessageStorageView storage, const ReadOptions & options)`	`IncomingHeaderAndMessage`
`MessageRead(TransportObject && transport, typename internal::AssociatedTransport< TransportObject >::MessageStorageView storage)`	`IncomingHeaderAndMessage`
`MethodHasResultUnion()`	`constexpr bool`
`MethodHasUnwrapAccessors()`	`constexpr bool`
`NaturalToHLCPP(Natural && value)`	`auto`
`ObserveTeardown(Callable && callback)`	`fidl::AnyTeardownObserver`
`Persist(const FidlType & value)`	`fit::result< fidl::Error, std::vector< uint8_t > >`
`PrimaryObjectSize(const fidl_type_t type, uint32_t buffer_size, uint32_t out_primary_size, uint32_t out_first_out_of_line, const char *out_error)`	`zx_status_t`
`SendEvent(const ServerBindingRef< FidlProtocol > & binding_ref)`	`auto`
`SendEvent(const ServerBinding< FidlProtocol > & binding)`	`auto`
`SendEvent(const ServerEnd< FidlProtocol > & server_end)`	`auto`
`ServerReplyBufferSizeInChannel()`	`constexpr uint32_t`
`ShareUntilTeardown(std::shared_ptr< T > object)`	`fidl::AnyTeardownObserver`
`SharedClient(fidl::ClientEnd< Protocol >, async_dispatcher_t *, AsyncEventHandlerReference &&, fidl::AnyTeardownObserver) -> SharedClient< Protocol >`
`SharedClient(fidl::ClientEnd< Protocol >, async_dispatcher_t *, AsyncEventHandlerReference &&) -> SharedClient< Protocol >`
`SharedClient(fidl::ClientEnd< Protocol >, async_dispatcher_t *) -> SharedClient< Protocol >`
`StandaloneDecode(::fidl::EncodedMessage message, ::fidl::WireFormatMetadata metadata)`	`::fit::result<::fidl::Error, FidlType >`
`StandaloneEncode(FidlType value)`	`OwnedEncodeResult`
`StandaloneEncode(FidlType & value)`	`OwnedEncodeResult`
`StandaloneInplaceDecode(EncodedMessage message, WireFormatMetadata metadata)`	`::fit::result<::fidl::Error,::fidl::DecodedValue< FidlType > >`
`SyncClient(fidl::ClientEnd< FidlProtocol >) -> SyncClient< FidlProtocol >`
`SyncClientMethodBufferSizeInChannel()`	`constexpr uint32_t`
`To(const U & obj)`	`T`
`ToNatural(WireType value)`	`auto`
`ToUnderlying(TEnum value) -> typename std::underlying_type< TEnum >::type`	`constexpr auto`
`ToWire(fidl::AnyArena & arena, NaturalType value)`	`auto`
`Unpersist(cpp20::span< const uint8_t > data)`	`fit::result< fidl::Error, FidlType >`
`VectorView(fidl::AnyArena &, cpp20::span< T >) -> VectorView< T >`
`VectorView(fidl::AnyArena &, const std::vector< T > &) -> VectorView< T >`
`Walk(VisitorImpl & visitor, const fidl_type_t *type, typename VisitorImpl::Position start)`	`void`
`WireCall(const fidl::ClientEnd< FidlProtocol > & client_end)`	`internal::SyncEndpointVeneer< internal::WireSyncClientImpl, FidlProtocol >`
`WireCall(const fidl::UnownedClientEnd< FidlProtocol > & client_end)`	`internal::SyncEndpointVeneer< internal::WireSyncClientImpl, FidlProtocol >`
`WireClient(fidl::ClientEnd< Protocol >, async_dispatcher_t *, AsyncEventHandlerReference &&) -> WireClient< Protocol >`
`WireClient(fidl::ClientEnd< Protocol >, async_dispatcher_t *) -> WireClient< Protocol >`
`WireSendEvent(const ServerBindingRef< FidlProtocol > & binding_ref)`	`internal::WeakEventSenderVeneer< internal::WireWeakEventSender, FidlProtocol >`
`WireSendEvent(const ServerBinding< FidlProtocol > & binding)`	`internal::WeakEventSenderVeneer< internal::WireWeakEventSender, FidlProtocol >`
`WireSendEvent(const ServerEnd< FidlProtocol > & server_end)`	`internal::SyncEndpointVeneer< internal::WireEventSender, FidlProtocol >`
`WireSendEvent(UnownedServerEnd< FidlProtocol > server_end)`	`internal::SyncEndpointVeneer< internal::WireEventSender, FidlProtocol >`
`WireSharedClient(fidl::ClientEnd< Protocol >, async_dispatcher_t *, AsyncEventHandlerReference &&, fidl::AnyTeardownObserver) -> WireSharedClient< Protocol >`
`WireSharedClient(fidl::ClientEnd< Protocol >, async_dispatcher_t *, AsyncEventHandlerReference &&) -> WireSharedClient< Protocol >`
`WireSharedClient(fidl::ClientEnd< Protocol >, async_dispatcher_t *) -> WireSharedClient< Protocol >`
`WireSyncClient(fidl::ClientEnd< FidlProtocol >) -> WireSyncClient< FidlProtocol >`
`__attribute__((enum_extensibility(closed)))[[nodiscard]] DispatchResult`	`enum`
`operator!=(const StringPtr & lhs, const StringPtr & rhs)`	`bool`
`operator!=(const char *lhs, const StringPtr & rhs)`	`bool`
`operator!=(const StringPtr & lhs, const char *rhs)`	`bool`
`operator!=(const Box< T > & lhs, const Box< T > & rhs) noexcept`	`constexpr bool`
`operator!=(const std::nullptr_t & lhs, const Box< T > & rhs) noexcept`	`constexpr bool`
`operator!=(const Box< T > & lhs, const std::nullptr_t & rhs) noexcept`	`constexpr bool`
`operator!=(const Box< T > & lhs, const std::unique_ptr< T > & rhs) noexcept`	`constexpr bool`
`operator!=(const std::unique_ptr< T > & lhs, const Box< T > & rhs) noexcept`	`constexpr bool`
`operator!=(const fidl::Array< T, N > & lhs, const fidl::Array< T, N > & rhs)`	`bool`
`operator!=(std::nullptr_t, ObjectView< T > p)`	`bool`
`operator<(const StringPtr & lhs, const StringPtr & rhs)`	`bool`
`operator<(const char *lhs, const StringPtr & rhs)`	`bool`
`operator<(const StringPtr & lhs, const char *rhs)`	`bool`
`operator<<(std::ostream & out, const StringPtr & str)`	`std::ostream &`
`operator<<(std::ostream & ostream, const Status & result)`	`std::ostream &`
`operator<<(std::ostream & ostream, const UnbindInfo & info)`	`std::ostream &`
`operator<=(const StringPtr & lhs, const StringPtr & rhs)`	`bool`
`operator<=(const char *lhs, const StringPtr & rhs)`	`bool`
`operator<=(const StringPtr & lhs, const char *rhs)`	`bool`
`operator==(const StringPtr & lhs, const StringPtr & rhs)`	`bool`
`operator==(const char *lhs, const StringPtr & rhs)`	`bool`
`operator==(const StringPtr & lhs, const char *rhs)`	`bool`
`operator==(const Box< T > & lhs, const Box< T > & rhs) noexcept`	`constexpr bool`
`operator==(const std::nullptr_t & lhs, const Box< T > & rhs) noexcept`	`constexpr bool`
`operator==(const Box< T > & lhs, const std::nullptr_t & rhs) noexcept`	`constexpr bool`
`operator==(const Box< T > & lhs, const std::unique_ptr< T > & rhs) noexcept`	`constexpr bool`
`operator==(const std::unique_ptr< T > & lhs, const Box< T > & rhs) noexcept`	`constexpr bool`
`operator==(const fidl::Array< T, N > & lhs, const fidl::Array< T, N > & rhs)`	`bool`
`operator==(std::nullptr_t, ObjectView< T > p)`	`bool`
`operator>(const StringPtr & lhs, const StringPtr & rhs)`	`bool`
`operator>(const char *lhs, const StringPtr & rhs)`	`bool`
`operator>(const StringPtr & lhs, const char *rhs)`	`bool`
`operator>=(const StringPtr & lhs, const StringPtr & rhs)`	`bool`
`operator>=(const char *lhs, const StringPtr & rhs)`	`bool`
`operator>=(const StringPtr & lhs, const char *rhs)`	`bool`
`operator\|(MessageDynamicFlags lhs, MessageDynamicFlags rhs)`	`MessageDynamicFlags`

Classes
fidl::AnyArena
fidl::AnyTeardownObserver
fidl::Arena
fidl::ArenaBase
fidl::BaseWireResult< FidlMethod, std::enable_if_t< FidlMethod::kHasServerToClient &&!FidlMethod::kHasServerToClientBody, void > >
fidl::BaseWireResult< FidlMethod, std::enable_if_t< FidlMethod::kHasServerToClient &&FidlMethod::kHasServerToClientBody &&!MethodHasUnwrapAccessors< FidlMethod >(), void > >
fidl::BaseWireResult< FidlMethod, std::enable_if_t< FidlMethod::kHasServerToClient &&MethodHasUnwrapAccessors< FidlMethod >(), void > >
fidl::BaseWireResult< FidlMethod, std::enable_if_tkHasServerToClient, void > >
fidl::Binding
fidl::BindingSet
fidl::BodyEncoder
fidl::Box
fidl::Client
fidl::CompleterBase
fidl::DecodedValue
fidl::Decoder
fidl::EncodedMessage
fidl::Encoder
fidl::Envelope
fidl::ErrorsIn
fidl::EventSender
fidl::HLCPPIncomingBody
fidl::HLCPPIncomingMessage
fidl::HLCPPOutgoingBody
fidl::HLCPPOutgoingMessage
fidl::IncomingHeaderAndMessage
fidl::IncomingMessageBuffer
fidl::InterfaceHandle
fidl::InterfacePtr
fidl::InterfacePtrSet
fidl::InterfaceRequest
fidl::MemberConnector
fidl::MemoryResource
fidl::MessageEncoder
fidl::MessagePart
fidl::ObjectView
fidl::OneWayStatus
fidl::OutgoingMessage
fidl::OutgoingMessageBuffer
fidl::OutgoingToEncodedMessage
fidl::OwnedEncodeResult
fidl::ServerBinding
fidl::ServerBindingGroup
fidl::ServerBindingRef
fidl::ServiceConnector
fidl::ServiceHandlerBase
fidl::SharedClient
fidl::Status
fidl::StringPtr
fidl::StringView
fidl::SyncClient
fidl::Transaction
fidl::UnbindInfo
fidl::UnknownEventHandler
fidl::UnknownMethodHandler
fidl::VectorPtr
fidl::WireClient
fidl::WireFormatMetadata
fidl::WireResponseContext
fidl::WireSharedClient
fidl::WireSyncClient

Structs
fidl::Array
fidl::BufferSpan
fidl::CallOptions
fidl::ChannelMessageStorageView
fidl::CodingTraits
fidl::CodingTraits< InterfaceHandle< T > >
fidl::CodingTraits< InterfaceRequest< T > >
fidl::CodingTraits< StringPtr >
fidl::CodingTraits< T, typename std::enable_if< IsPrimitive< T >::value >::type >
fidl::CodingTraits< VectorPtr< T > >
fidl::CodingTraits< bool >
fidl::CodingTraits< std::unique_ptr< T >, typename std::enable_if::value >::type >
fidl::CodingTraits<::std::array< T, N > >
fidl::CodingTraits<::std::string >
fidl::CodingTraits<::std::vector< T > >
fidl::Completer
fidl::ContainsHandle
fidl::ContainsHandle< Array< T, N > >
fidl::ContainsHandle< ClientEnd< Protocol > >
fidl::ContainsHandle< ServerEnd< Protocol > >
fidl::ContainsHandle< T, typename std::enable_if< IsFidlType< T >::value &&TypeTraits< T >::kMaxNumHandles==0 >::type >
fidl::ContainsHandle< bool >
fidl::ContainsHandle< double >
fidl::ContainsHandle< float >
fidl::ContainsHandle< int16_t >
fidl::ContainsHandle< int32_t >
fidl::ContainsHandle< int64_t >
fidl::ContainsHandle< int8_t >
fidl::ContainsHandle< uint16_t >
fidl::ContainsHandle< uint32_t >
fidl::ContainsHandle< uint64_t >
fidl::ContainsHandle< uint8_t >
fidl::ContainsHandle<::fdf::Channel >
fidl::ContainsHandle<::fdf::ClientEnd< T > >
fidl::ContainsHandle<::fdf::ServerEnd< T > >
fidl::DeprecatedCTypeTraits
fidl::EncodableCodingTraits
fidl::Endpoints
fidl::Equality
fidl::Equality< InterfaceHandle< T > >
fidl::Equality< InterfaceRequest< T > >
fidl::Equality< StringPtr >
fidl::Equality< T, typename std::enable_if_t< std::is_floating_point< T >::value > >
fidl::Equality< T, typename std::enable_if_t< std::is_integral< T >::value > >
fidl::Equality< UnknownBytes >
fidl::Equality< VectorPtr< T > >
fidl::Equality< std::array< T, N > >
fidl::Equality< std::map< uint64_t, std::vector< uint8_t > > >
fidl::Equality< std::string >
fidl::Equality< std::unique_ptr< T > >
fidl::Equality< std::vector< T > >
fidl::HandleInformation
fidl::HasPadding
fidl::IsFidlObject
fidl::IsFidlObject< T, typename std::enable_if< IsTable< T >::value\|\|IsUnion< T >::value\|\|IsStruct< T >::value >::type >
fidl::IsFidlTransactionalMessage
fidl::IsFidlType
fidl::IsFidlType< StringView >
fidl::IsFidlType< VectorView< E > >
fidl::IsFidlType< WireOptional< T > >
fidl::IsFidlType< bool >
fidl::IsFidlType< const T >
fidl::IsFidlType< double >
fidl::IsFidlType< float >
fidl::IsFidlType< int16_t >
fidl::IsFidlType< int32_t >
fidl::IsFidlType< int64_t >
fidl::IsFidlType< int8_t >
fidl::IsFidlType< uint16_t >
fidl::IsFidlType< uint32_t >
fidl::IsFidlType< uint64_t >
fidl::IsFidlType< uint8_t >
fidl::IsFidlUnion
fidl::IsFidlXUnion
fidl::IsMemcpyCompatible
fidl::IsMemcpyCompatible< int16_t >
fidl::IsMemcpyCompatible< int32_t >
fidl::IsMemcpyCompatible< int64_t >
fidl::IsMemcpyCompatible< int8_t >
fidl::IsMemcpyCompatible< std::array< T, N > >
fidl::IsMemcpyCompatible< uint16_t >
fidl::IsMemcpyCompatible< uint32_t >
fidl::IsMemcpyCompatible< uint64_t >
fidl::IsMemcpyCompatible< uint8_t >
fidl::IsPrimitive
fidl::IsPrimitive< bool >
fidl::IsPrimitive< double >
fidl::IsPrimitive< float >
fidl::IsPrimitive< int16_t >
fidl::IsPrimitive< int32_t >
fidl::IsPrimitive< int64_t >
fidl::IsPrimitive< int8_t >
fidl::IsPrimitive< uint16_t >
fidl::IsPrimitive< uint32_t >
fidl::IsPrimitive< uint64_t >
fidl::IsPrimitive< uint8_t >
fidl::IsProtocol
fidl::IsResource
fidl::IsResource< Array< T, N > >
fidl::IsResource< ClientEnd< Protocol > >
fidl::IsResource< ServerEnd< Protocol > >
fidl::IsResource< VectorView< E > >
fidl::IsResource< WireOptional< T > >
fidl::IsService
fidl::IsService< T, std::void_t< decltype(T::kIsService)> >
fidl::IsServiceMember
fidl::IsServiceMember< T, std::void_t< decltype(T::kIsServiceMember)> >
fidl::IsStdArray
fidl::IsStdArray< std::array< T, N > >
fidl::IsStdString
fidl::IsStdString< std::string >
fidl::IsStdVector
fidl::IsStdVector< std::vector< V, A > >
fidl::IsStringView
fidl::IsStringView< T, typename std::enable_if< IsStringView< typename std::remove_const< T >::type >::value >::type >
fidl::IsStringView< fidl::StringView, void >
fidl::IsStruct
fidl::IsStruct< MaybeConstStruct, typename std::enable_if< std::is_const< MaybeConstStruct >::value &&IsStruct< typename std::remove_const< MaybeConstStruct >::type >::value >::type >
fidl::IsTable
fidl::IsTable< MaybeConstTable, typename std::enable_if< std::is_const< MaybeConstTable >::value &&IsTable< typename std::remove_const< MaybeConstTable >::type >::value >::type >
fidl::IsUnion
fidl::IsUnion< MaybeConstUnion, typename std::enable_if< std::is_const< MaybeConstUnion >::value &&IsUnion< typename std::remove_const< MaybeConstUnion >::type >::value >::type >
fidl::IsUnion< WireOptional< T > >
fidl::IsVectorView
fidl::IsVectorView< T, typename std::enable_if< IsVectorView< typename std::remove_const< T >::type >::value >::type >
fidl::IsVectorView< VectorView< T >, void >
fidl::IsWire
fidl::MessageDynamicFlags
fidl::MutatingVisitorTrait
fidl::NonMutatingVisitorTrait
fidl::ReadOptions
fidl::TypeConverter
fidl::TypeConverter< fuchsia::media::TimelineFunction, media::TimelineFunction >
fidl::TypeConverter< media::TimelineFunction, fuchsia::media::TimelineFunction >
fidl::TypeTraits
fidl::TypeTraits< WireOptional< T > >
fidl::TypeTraits< const T >
fidl::UnknownBytes
fidl::UnknownEventMetadata
fidl::UnknownMethodMetadata
fidl::WireOptional
fidl::WireResponse
fidl::WireTableFrame
fidl::WriteOptions

Namespaces
fidl::fidl
fidl::internal_wavl
fidl::ostream
fidl::testing

Enumerations

ErrorOrigin

 ErrorOrigin

Properties
`kReceive`
`kSend`

MessageDirection

 MessageDirection

Properties
`kReceiving`
`kSending`

Reason

 Reason

Properties
`__DoNotUse`
`kAbandonedAsyncReply`
`kCanceledDueToOtherError`
`kClose`
`kDecodeError`
`kDispatcherError`
`kEncodeError`
`kPeerClosedWhileReading`
`kPendingTwoWayCallPreventsUnbind`
`kTransportError`
`kUnbind`
`kUnexpectedMessage`
`kUnknownMethod`

UnknownMethodType

 UnknownMethodType

Properties
`kOneWay`
`kTwoWay`

Typedefs

AnyMemoryResource

fit::inline_any< MemoryResource, 24, 8 > AnyMemoryResource

AsyncClientBuffer

internal::InlineMessageBuffer< AsyncClientMethodBufferSizeInChannel< FidlMethod >()> AsyncClientBuffer

BytePart

MessagePart< uint8_t > BytePart

ClientCallback

typename internal::NaturalMethodTypes< Method >::ResultCallback ClientCallback

Error

Status Error

Event

std::enable_if_t< Method::kHasServerToClient &&!Method::kHasClientToServer, typename fidl::internal::NaturalMethodTypes< Method >::Request > Event

EventBuffer

internal::InlineMessageBuffer< EventReplyBufferSizeInChannel< FidlMethod >()> EventBuffer

FrameworkErr

::fidl::internal::FrameworkErr FrameworkErr

HandleDispositionPart

MessagePart< zx_handle_disposition_t > HandleDispositionPart

HandleInfoPart

MessagePart< zx_handle_info_t > HandleInfoPart

HandlePart

MessagePart< zx_handle_t > HandlePart

InterfaceRequestHandler

fit::function< void(fidl::InterfaceRequest< Interface > request)> InterfaceRequestHandler

OnUnboundFn

fit::callback< void(ServerImpl *, UnbindInfo, internal::ServerEndType< Protocol >)> OnUnboundFn

OneWayError

OneWayStatus OneWayError

Request

std::enable_if_t< Method::kHasClientToServer, typename fidl::internal::NaturalMethodTypes< Method >::Request > Request

ServerBuffer

internal::InlineMessageBuffer< ServerReplyBufferSizeInChannel< FidlMethod >()> ServerBuffer

SyncClientBuffer

internal::InlineMessageBuffer< SyncClientMethodBufferSizeInChannel< FidlMethod >()> SyncClientBuffer

UnknownMethodCompleter

::fidl::Completer<> UnknownMethodCompleter

WireResultUnwrapType

typename::fidl::internal::WireResultUnwrap< FidlMethod >::Type WireResultUnwrapType

Functions

Arena

 Arena() -> Arena< initial_capacity >

AsyncClientMethodBufferSizeInChannel

constexpr uint32_t AsyncClientMethodBufferSizeInChannel()

BindServer

ServerBindingRef< Protocol > BindServer(
  async_dispatcher_t *dispatcher,
  fidl::ServerEnd< Protocol > server_end,
  ServerImpl *impl,
  OnUnbound && on_unbound
)

BindServer

ServerBindingRef< Protocol > BindServer(
  async_dispatcher_t *dispatcher,
  fidl::ServerEnd< Protocol > server_end,
  std::unique_ptr< ServerImpl > && impl,
  OnUnbound && on_unbound
)

BindServer

ServerBindingRef< Protocol > BindServer(
  async_dispatcher_t *dispatcher,
  fidl::ServerEnd< Protocol > server_end,
  std::shared_ptr< ServerImpl > impl,
  OnUnbound && on_unbound
)

Call

internal::SyncEndpointManagedVeneer< internal::NaturalSyncClientImpl< FidlProtocol > > Call(
  const fidl::ClientEnd< FidlProtocol > & client_end
)

Call

internal::SyncEndpointManagedVeneer< internal::NaturalSyncClientImpl< FidlProtocol > > Call(
  const fidl::UnownedClientEnd< FidlProtocol > & client_end
)

Client

 Client(
  fidl::ClientEnd< Protocol >,
  async_dispatcher_t *,
  AsyncEventHandlerReference &&
) -> Client< Protocol >

Client

 Client(
  fidl::ClientEnd< Protocol >,
  async_dispatcher_t *
) -> Client< Protocol >

Clone

zx_status_t Clone(
  ::fidl::internal::FrameworkErr value,
  ::fidl::internal::FrameworkErr *result
)

Clone

std::enable_if< IsPrimitive< T >::value, zx_status_t >::type Clone(
  const T & value,
  T *result
)

Clone

std::enable_if< IsPrimitive< T >::value||IsStdString< T >::value, zx_status_t >::type Clone(
  const std::array< T, N > & value,
  std::array< T, N > *result
)

Clone

std::enable_ifIsPrimitive< T >::value &&!IsStdString< T >::value, zx_status_t >::type Clone(
  const std::array< T, N > & value,
  std::array< T, N > *result
)

Clone

std::enable_ifIsPrimitive< T >::value &&!IsStdVector< T >::value &&!IsStdArray< T >::value, zx_status_t >::type Clone(
  const T & value,
  T *result
)

Clone

zx_status_t Clone(
  const StringPtr & value,
  StringPtr *result
)

Clone

zx_status_t Clone(
  const ::std::string & value,
  std::string *result
)

Clone

zx_status_t Clone(
  const std::unique_ptr< T > & value,
  std::unique_ptr< T > *result
)

Clone

std::enable_if< IsPrimitive< T >::value||IsStdString< T >::value, zx_status_t >::type Clone(
  const VectorPtr< T > & value,
  VectorPtr< T > *result
)

Clone

std::enable_if< IsPrimitive< T >::value||IsStdString< T >::value, zx_status_t >::type Clone(
  const ::std::vector< T > & value,
  ::std::vector< T > *result
)

Clone

std::enable_ifIsPrimitive< T >::value &&!IsStdString< T >::value, zx_status_t >::type Clone(
  const ::std::vector< T > & value,
  ::std::vector< T > *result
)

Clone

std::enable_ifIsPrimitive< T >::value &&!IsStdString< T >::value, zx_status_t >::type Clone(
  const VectorPtr< T > & value,
  VectorPtr< T > *result
)

Clone

std::enable_if< IsPrimitive< T >::value||IsStdString< T >::value, zx_status_t >::type Clone(
  const ::std::array< T, N > & value,
  ::std::array< T, N > *result
)

Clone

zx_status_t Clone(
  const UnknownBytes & value,
  UnknownBytes *result
)

Clone

zx_status_t Clone(
  const ::std::map< uint64_t,::std::vector< uint8_t >> & value,
  ::std::map< uint64_t,::std::vector< uint8_t >> *result
)

Clone

T Clone(
  const T & value
)

Clone

zx_status_t Clone(
  const InterfaceHandle< T > & value,
  InterfaceHandle< T > *result
)

Clone

zx_status_t Clone(
  const InterfaceRequest< T > & value,
  InterfaceRequest< T > *result
)

CreateEndpoints

zx::result< Endpoints< Protocol > > CreateEndpoints()

CreateEndpoints

zx::result< fidl::ServerEnd< Protocol > > CreateEndpoints(
  fidl::ClientEnd< Protocol > *out_client
)

CreateEndpoints

zx::result< fidl::ClientEnd< Protocol > > CreateEndpoints(
  fidl::ServerEnd< Protocol > *out_server
)

Decode

void Decode(
  DecoderImpl *decoder,
  T *value,
  size_t offset
)

DecodeAs

T DecodeAs(
  DecoderImpl *decoder,
  size_t offset
)

DecodeUnknownBytesContents

void DecodeUnknownBytesContents(
  DecoderImpl *decoder,
  std::vector< uint8_t > *value,
  size_t offset
)

DecodingInlineSize

size_t DecodingInlineSize(
  DecoderImpl *decoder
)

Encode

void Encode(
  EncoderImpl *encoder,
  T *value,
  size_t offset,
  cpp17::optional< HandleInformation > maybe_handle_info
)

EncodeNullVector

void EncodeNullVector(
  EncoderImpl *encoder,
  size_t offset
)

EncodeUnknownBytes

void EncodeUnknownBytes(
  EncoderImpl *encoder,
  std::vector< uint8_t > *value,
  size_t envelope_offset
)

EncodeUnknownBytesContents

void EncodeUnknownBytesContents(
  EncoderImpl *encoder,
  std::vector< uint8_t > *value,
  size_t offset
)

EncodeVectorPointer

void EncodeVectorPointer(
  EncoderImpl *encoder,
  size_t count,
  size_t offset
)

EncodingInlineSize

size_t EncodingInlineSize(
  EncoderImpl *encoder
)

Equals

bool Equals(
  const T & lhs,
  const T & rhs
)

EventReplyBufferSizeInChannel

constexpr uint32_t EventReplyBufferSizeInChannel()

HLCPPToNatural

auto HLCPPToNatural(
  HLCPP && value
)

InitTxnHeader

void InitTxnHeader(
  fidl_message_header_t *out_hdr,
  zx_txid_t txid,
  uint64_t ordinal,
  MessageDynamicFlags dynamic_flags
)

InplaceUnpersist

fit::result< fidl::Error, fidl::ObjectView< FidlType > > InplaceUnpersist(
  cpp20::span< uint8_t > data
)

IsByteOverflow

bool IsByteOverflow(
  const fidl_message_header_t *hdr
)

IsFlexibleInteraction

bool IsFlexibleInteraction(
  const fidl_message_header_t *hdr
)

MaxSizeInChannel

constexpr uint32_t MaxSizeInChannel()

MessageRead

IncomingHeaderAndMessage MessageRead(
  TransportObject && transport,
  typename internal::AssociatedTransport< TransportObject >::MessageStorageView storage,
  const ReadOptions & options
)

MessageRead

IncomingHeaderAndMessage MessageRead(
  TransportObject && transport,
  typename internal::AssociatedTransport< TransportObject >::MessageStorageView storage
)

MethodHasResultUnion

constexpr bool MethodHasResultUnion()

MethodHasUnwrapAccessors

constexpr bool MethodHasUnwrapAccessors()

NaturalToHLCPP

auto NaturalToHLCPP(
  Natural && value
)

ObserveTeardown

fidl::AnyTeardownObserver ObserveTeardown(
  Callable && callback
)

Persist

fit::result< fidl::Error, std::vector< uint8_t > > Persist(
  const FidlType & value
)

PrimaryObjectSize

zx_status_t PrimaryObjectSize(
  const fidl_type_t *type,
  uint32_t buffer_size,
  uint32_t *out_primary_size,
  uint32_t *out_first_out_of_line,
  const char **out_error
)

SendEvent

auto SendEvent(
  const ServerBindingRef< FidlProtocol > & binding_ref
)

SendEvent

auto SendEvent(
  const ServerBinding< FidlProtocol > & binding
)

SendEvent

auto SendEvent(
  const ServerEnd< FidlProtocol > & server_end
)

ServerReplyBufferSizeInChannel

constexpr uint32_t ServerReplyBufferSizeInChannel()

ShareUntilTeardown

fidl::AnyTeardownObserver ShareUntilTeardown(
  std::shared_ptr< T > object
)

SharedClient

 SharedClient(
  fidl::ClientEnd< Protocol >,
  async_dispatcher_t *,
  AsyncEventHandlerReference &&,
  fidl::AnyTeardownObserver
) -> SharedClient< Protocol >

SharedClient

 SharedClient(
  fidl::ClientEnd< Protocol >,
  async_dispatcher_t *,
  AsyncEventHandlerReference &&
) -> SharedClient< Protocol >

SharedClient

 SharedClient(
  fidl::ClientEnd< Protocol >,
  async_dispatcher_t *
) -> SharedClient< Protocol >

StandaloneDecode

::fit::result<::fidl::Error, FidlType > StandaloneDecode(
  ::fidl::EncodedMessage message,
  ::fidl::WireFormatMetadata metadata
)

StandaloneEncode

OwnedEncodeResult StandaloneEncode(
  FidlType value
)

StandaloneEncode

OwnedEncodeResult StandaloneEncode(
  FidlType & value
)

StandaloneInplaceDecode

::fit::result<::fidl::Error,::fidl::DecodedValue< FidlType > > StandaloneInplaceDecode(
  EncodedMessage message,
  WireFormatMetadata metadata
)

SyncClient

 SyncClient(
  fidl::ClientEnd< FidlProtocol >
) -> SyncClient< FidlProtocol >

SyncClientMethodBufferSizeInChannel

constexpr uint32_t SyncClientMethodBufferSizeInChannel()

To

T To(
  const U & obj
)

ToNatural

auto ToNatural(
  WireType value
)

ToUnderlying

constexpr auto ToUnderlying(
  TEnum value
) -> typename std::underlying_type< TEnum >::type

ToWire

auto ToWire(
  fidl::AnyArena & arena,
  NaturalType value
)

Unpersist

fit::result< fidl::Error, FidlType > Unpersist(
  cpp20::span< const uint8_t > data
)

VectorView

 VectorView(
  fidl::AnyArena &,
  cpp20::span< T >
) -> VectorView< T >

VectorView

 VectorView(
  fidl::AnyArena &,
  const std::vector< T > &
) -> VectorView< T >

Walk

void Walk(
  VisitorImpl & visitor,
  const fidl_type_t *type,
  typename VisitorImpl::Position start
)

WireCall

internal::SyncEndpointVeneer< internal::WireSyncClientImpl, FidlProtocol > WireCall(
  const fidl::ClientEnd< FidlProtocol > & client_end
)

WireCall

internal::SyncEndpointVeneer< internal::WireSyncClientImpl, FidlProtocol > WireCall(
  const fidl::UnownedClientEnd< FidlProtocol > & client_end
)

WireClient

 WireClient(
  fidl::ClientEnd< Protocol >,
  async_dispatcher_t *,
  AsyncEventHandlerReference &&
) -> WireClient< Protocol >

WireClient

 WireClient(
  fidl::ClientEnd< Protocol >,
  async_dispatcher_t *
) -> WireClient< Protocol >

WireSendEvent

internal::WeakEventSenderVeneer< internal::WireWeakEventSender, FidlProtocol > WireSendEvent(
  const ServerBindingRef< FidlProtocol > & binding_ref
)

WireSendEvent

internal::WeakEventSenderVeneer< internal::WireWeakEventSender, FidlProtocol > WireSendEvent(
  const ServerBinding< FidlProtocol > & binding
)

WireSendEvent

internal::SyncEndpointVeneer< internal::WireEventSender, FidlProtocol > WireSendEvent(
  const ServerEnd< FidlProtocol > & server_end
)

WireSendEvent

internal::SyncEndpointVeneer< internal::WireEventSender, FidlProtocol > WireSendEvent(
  UnownedServerEnd< FidlProtocol > server_end
)

WireSharedClient

 WireSharedClient(
  fidl::ClientEnd< Protocol >,
  async_dispatcher_t *,
  AsyncEventHandlerReference &&,
  fidl::AnyTeardownObserver
) -> WireSharedClient< Protocol >

WireSharedClient

 WireSharedClient(
  fidl::ClientEnd< Protocol >,
  async_dispatcher_t *,
  AsyncEventHandlerReference &&
) -> WireSharedClient< Protocol >

WireSharedClient

 WireSharedClient(
  fidl::ClientEnd< Protocol >,
  async_dispatcher_t *
) -> WireSharedClient< Protocol >

WireSyncClient

 WireSyncClient(
  fidl::ClientEnd< FidlProtocol >
) -> WireSyncClient< FidlProtocol >

attribute

enum __attribute__(
  (enum_extensibility(closed))
)[[nodiscard]] DispatchResult

operator!=

bool operator!=(
  const StringPtr & lhs,
  const StringPtr & rhs
)

operator!=

bool operator!=(
  const char *lhs,
  const StringPtr & rhs
)

operator!=

bool operator!=(
  const StringPtr & lhs,
  const char *rhs
)

operator!=

constexpr bool operator!=(
  const Box< T > & lhs,
  const Box< T > & rhs
) noexcept

operator!=

constexpr bool operator!=(
  const std::nullptr_t & lhs,
  const Box< T > & rhs
) noexcept

operator!=

constexpr bool operator!=(
  const Box< T > & lhs,
  const std::nullptr_t & rhs
) noexcept

operator!=

constexpr bool operator!=(
  const Box< T > & lhs,
  const std::unique_ptr< T > & rhs
) noexcept

operator!=

constexpr bool operator!=(
  const std::unique_ptr< T > & lhs,
  const Box< T > & rhs
) noexcept

operator!=

bool operator!=(
  const fidl::Array< T, N > & lhs,
  const fidl::Array< T, N > & rhs
)

operator!=

bool operator!=(
  std::nullptr_t,
  ObjectView< T > p
)

operator<

bool operator<(
  const StringPtr & lhs,
  const StringPtr & rhs
)

operator<

bool operator<(
  const char *lhs,
  const StringPtr & rhs
)

operator<

bool operator<(
  const StringPtr & lhs,
  const char *rhs
)

operator<<

std::ostream & operator<<(
  std::ostream & out,
  const StringPtr & str
)

operator<<

std::ostream & operator<<(
  std::ostream & ostream,
  const Status & result
)

operator<<

std::ostream & operator<<(
  std::ostream & ostream,
  const UnbindInfo & info
)

operator<=

bool operator<=(
  const StringPtr & lhs,
  const StringPtr & rhs
)

operator<=

bool operator<=(
  const char *lhs,
  const StringPtr & rhs
)

operator<=

bool operator<=(
  const StringPtr & lhs,
  const char *rhs
)

operator==

bool operator==(
  const StringPtr & lhs,
  const StringPtr & rhs
)

operator==

bool operator==(
  const char *lhs,
  const StringPtr & rhs
)

operator==

bool operator==(
  const StringPtr & lhs,
  const char *rhs
)

operator==

constexpr bool operator==(
  const Box< T > & lhs,
  const Box< T > & rhs
) noexcept

operator==

constexpr bool operator==(
  const std::nullptr_t & lhs,
  const Box< T > & rhs
) noexcept

operator==

constexpr bool operator==(
  const Box< T > & lhs,
  const std::nullptr_t & rhs
) noexcept

operator==

constexpr bool operator==(
  const Box< T > & lhs,
  const std::unique_ptr< T > & rhs
) noexcept

operator==

constexpr bool operator==(
  const std::unique_ptr< T > & lhs,
  const Box< T > & rhs
) noexcept

operator==

bool operator==(
  const fidl::Array< T, N > & lhs,
  const fidl::Array< T, N > & rhs
)

operator==

bool operator==(
  std::nullptr_t,
  ObjectView< T > p
)

operator>

bool operator>(
  const StringPtr & lhs,
  const StringPtr & rhs
)

operator>

bool operator>(
  const char *lhs,
  const StringPtr & rhs
)

operator>

bool operator>(
  const StringPtr & lhs,
  const char *rhs
)

operator>=

bool operator>=(
  const StringPtr & lhs,
  const StringPtr & rhs
)

operator>=

bool operator>=(
  const char *lhs,
  const StringPtr & rhs
)

operator>=

bool operator>=(
  const StringPtr & lhs,
  const char *rhs
)

operator|

MessageDynamicFlags operator|(
  MessageDynamicFlags lhs,
  MessageDynamicFlags rhs
)

fidl

Summary

Enumerations

Typedefs

Functions

Classes

Structs

Namespaces

Enumerations

ErrorOrigin

MessageDirection

Reason

UnknownMethodType

Typedefs

AnyMemoryResource

AsyncClientBuffer

BytePart

ClientCallback

Error

Event

EventBuffer

FrameworkErr

HandleDispositionPart

HandleInfoPart

HandlePart

InterfaceRequestHandler

OnUnboundFn

OneWayError

Request

ServerBuffer

SyncClientBuffer

UnknownMethodCompleter

WireResultUnwrapType

Functions

Arena

AsyncClientMethodBufferSizeInChannel

BindServer

BindServer

BindServer

Call

Call

Client

Client

Clone

Clone

Clone

Clone

Clone

Clone

Clone

Clone

Clone

Clone

Clone

Clone

Clone

Clone

Clone

Clone

Clone

Clone

CreateEndpoints

CreateEndpoints

CreateEndpoints

Decode

DecodeAs

DecodeUnknownBytesContents

DecodingInlineSize

Encode

EncodeNullVector

EncodeUnknownBytes

EncodeUnknownBytesContents

EncodeVectorPointer

EncodingInlineSize

Equals

EventReplyBufferSizeInChannel

HLCPPToNatural

InitTxnHeader

InplaceUnpersist

IsByteOverflow

attribute