class Transaction

An abstract transaction, encapsulating the logic of sending reply messages.

The transaction type is polymorphic, to cater to a variety of transports and usage patterns.

Concrete implementations of this class are provided, so most clients do not have to worry about

implementing |fidl::Transaction|, and higher-level APIs such as |fidl::BindServer| cover most use

cases.

Should greater flexibility over managing in-flight transactions and server lifecycle be desired,

clients usually manually dispatch the FIDL messages. This is accomplished in the C bindings by

creating a transaction type that is memory layout-compatible with |fidl_txn_t|, and passing that

when calling the |foo_bar_try_dispatch| functions generated by the C bindings. Similarly here,

clients can manually invoke the [Try]Dispatch functions generated by the C++ bindings, passing in

their own transaction type by inheriting from this class and implementing the pure virtual

interfaces, e.g.

// Imaginary use-case: suppose drivers send messages in their own ways

class DriverRpcTransaction : public Transaction {

public:

// Implementation left-out

DriverRpcTransaction(/* ...some args... */);

~DriverRpcTransaction();

DriverRpcTransaction(DriverRpcTransaction

&

&

other) noexcept

: Transaction(std::move(other));

DriverRpcTransaction

&

operator=(DriverRpcTransaction

&

&

other) noexcept;

protected:

zx_status_t Reply(fidl::internal::Message* message) final {

/* Send to another driver etc. */

}

void Close(zx_status_t epitaph) final { /* Send epitaph and close down transport. */ }

std::unique_ptr

<Transaction

> TakeOwnership() final {

return std::make_unique

<DriverRpcTransaction

>(std::move(*this));

}

private:

// Driver-specific state...

};

and then dispatch to the server e.g.

fidl::WireServer

<fuchsia

::device::driver>* server_impl = /* construct/obtain server */;

fidl_incoming_msg_t msg = /* read FIDL message */;

DriverRpcTransaction txn(/* ...some args... */);

fuchsia::device::driver::Dispatch(server_impl,

&msg

,

&txn

);

/* Inspect |txn| */

The LLCPP runtime provides strong invariants around each method in the interface. It is possible

to implement a variety of dispatching behaviors by relying on them.