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
AsyncClientBuffer using
internal::InlineMessageBuffer< AsyncClientMethodBufferSizeInChannel< FidlMethod >()>
BytePart using
MessagePart< uint8_t >
ClientCallback using
typename internal::NaturalMethodTypes< Method >::ResultCallback
Error typedef
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
HandleInfoPart using
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
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
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)
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)
MessageRead(TransportObject && transport, typename internal::AssociatedTransport< TransportObject >::MessageStorageView storage)
MethodHasResultUnion()
constexpr bool
MethodHasUnwrapAccessors()
constexpr bool
NaturalToHLCPP(Natural && value)
auto
ObserveTeardown(Callable && callback)
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)
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)
StandaloneEncode(FidlType & value)
StandaloneInplaceDecode(EncodedMessage message, WireFormatMetadata metadata)
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)

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

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
)